The Tor Browser: gfx/angle/src/compiler/ForLoopUnroll.cpp@129ffea94266 (annotated)

gfx/angle/src/compiler/ForLoopUnroll.cpp@129ffea94266 (annotated)

gfx/angle/src/compiler/ForLoopUnroll.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 //
 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 #include "compiler/ForLoopUnroll.h"
 namespace {
 class IntegerForLoopUnrollMarker : public TIntermTraverser {
 public:
     virtual bool visitLoop(Visit, TIntermLoop* node)
     {
         // This is called after ValidateLimitations pass, so all the ASSERT
         // should never fail.
         // See ValidateLimitations::validateForLoopInit().
         ASSERT(node);
         ASSERT(node->getType() == ELoopFor);
         ASSERT(node->getInit());
         TIntermAggregate* decl = node->getInit()->getAsAggregate();
         ASSERT(decl && decl->getOp() == EOpDeclaration);
         TIntermSequence& declSeq = decl->getSequence();
         ASSERT(declSeq.size() == 1);
         TIntermBinary* declInit = declSeq[0]->getAsBinaryNode();
         ASSERT(declInit && declInit->getOp() == EOpInitialize);
         ASSERT(declInit->getLeft());
         TIntermSymbol* symbol = declInit->getLeft()->getAsSymbolNode();
         ASSERT(symbol);
         TBasicType type = symbol->getBasicType();
         ASSERT(type == EbtInt || type == EbtFloat);
         if (type == EbtInt)
             node->setUnrollFlag(true);
         return true;
     }
 };
 }  // anonymous namepsace
 void ForLoopUnroll::FillLoopIndexInfo(TIntermLoop* node, TLoopIndexInfo& info)
 {
     ASSERT(node->getType() == ELoopFor);
     ASSERT(node->getUnrollFlag());
     TIntermNode* init = node->getInit();
     ASSERT(init != NULL);
     TIntermAggregate* decl = init->getAsAggregate();
     ASSERT((decl != NULL) && (decl->getOp() == EOpDeclaration));
     TIntermSequence& declSeq = decl->getSequence();
     ASSERT(declSeq.size() == 1);
     TIntermBinary* declInit = declSeq[0]->getAsBinaryNode();
     ASSERT((declInit != NULL) && (declInit->getOp() == EOpInitialize));
     TIntermSymbol* symbol = declInit->getLeft()->getAsSymbolNode();
     ASSERT(symbol != NULL);
     ASSERT(symbol->getBasicType() == EbtInt);
     info.id = symbol->getId();
     ASSERT(declInit->getRight() != NULL);
     TIntermConstantUnion* initNode = declInit->getRight()->getAsConstantUnion();
     ASSERT(initNode != NULL);
     info.initValue = evaluateIntConstant(initNode);
     info.currentValue = info.initValue;
     TIntermNode* cond = node->getCondition();
     ASSERT(cond != NULL);
     TIntermBinary* binOp = cond->getAsBinaryNode();
     ASSERT(binOp != NULL);
     ASSERT(binOp->getRight() != NULL);
     ASSERT(binOp->getRight()->getAsConstantUnion() != NULL);
     info.incrementValue = getLoopIncrement(node);
     info.stopValue = evaluateIntConstant(
         binOp->getRight()->getAsConstantUnion());
     info.op = binOp->getOp();
 }
 void ForLoopUnroll::Step()
 {
     ASSERT(mLoopIndexStack.size() > 0);
     TLoopIndexInfo& info = mLoopIndexStack[mLoopIndexStack.size() - 1];
     info.currentValue += info.incrementValue;
 }
 bool ForLoopUnroll::SatisfiesLoopCondition()
 {
     ASSERT(mLoopIndexStack.size() > 0);
     TLoopIndexInfo& info = mLoopIndexStack[mLoopIndexStack.size() - 1];
     // Relational operator is one of: > >= < <= == or !=.
     switch (info.op) {
       case EOpEqual:
         return (info.currentValue == info.stopValue);
       case EOpNotEqual:
         return (info.currentValue != info.stopValue);
       case EOpLessThan:
         return (info.currentValue < info.stopValue);
       case EOpGreaterThan:
         return (info.currentValue > info.stopValue);
       case EOpLessThanEqual:
         return (info.currentValue <= info.stopValue);
       case EOpGreaterThanEqual:
         return (info.currentValue >= info.stopValue);
       default:
         UNREACHABLE();
     }
     return false;
 }
 bool ForLoopUnroll::NeedsToReplaceSymbolWithValue(TIntermSymbol* symbol)
 {
     for (TVector<TLoopIndexInfo>::iterator i = mLoopIndexStack.begin();
          i != mLoopIndexStack.end();
          ++i) {
         if (i->id == symbol->getId())
             return true;
     }
     return false;
 }
 int ForLoopUnroll::GetLoopIndexValue(TIntermSymbol* symbol)
 {
     for (TVector<TLoopIndexInfo>::iterator i = mLoopIndexStack.begin();
          i != mLoopIndexStack.end();
          ++i) {
         if (i->id == symbol->getId())
             return i->currentValue;
     }
     UNREACHABLE();
     return false;
 }
 void ForLoopUnroll::Push(TLoopIndexInfo& info)
 {
     mLoopIndexStack.push_back(info);
 }
 void ForLoopUnroll::Pop()
 {
     mLoopIndexStack.pop_back();
 }
 // static
 void ForLoopUnroll::MarkForLoopsWithIntegerIndicesForUnrolling(
     TIntermNode* root)
 {
     ASSERT(root);
     IntegerForLoopUnrollMarker marker;
     root->traverse(&marker);
 }
 int ForLoopUnroll::getLoopIncrement(TIntermLoop* node)
 {
     TIntermNode* expr = node->getExpression();
     ASSERT(expr != NULL);
     // for expression has one of the following forms:
     //     loop_index++
     //     loop_index--
     //     loop_index += constant_expression
     //     loop_index -= constant_expression
     //     ++loop_index
     //     --loop_index
     // The last two forms are not specified in the spec, but I am assuming
     // its an oversight.
     TIntermUnary* unOp = expr->getAsUnaryNode();
     TIntermBinary* binOp = unOp ? NULL : expr->getAsBinaryNode();
     TOperator op = EOpNull;
     TIntermConstantUnion* incrementNode = NULL;
     if (unOp != NULL) {
         op = unOp->getOp();
     } else if (binOp != NULL) {
         op = binOp->getOp();
         ASSERT(binOp->getRight() != NULL);
         incrementNode = binOp->getRight()->getAsConstantUnion();
         ASSERT(incrementNode != NULL);
     }
     int increment = 0;
     // The operator is one of: ++ -- += -=.
     switch (op) {
         case EOpPostIncrement:
         case EOpPreIncrement:
             ASSERT((unOp != NULL) && (binOp == NULL));
             increment = 1;
             break;
         case EOpPostDecrement:
         case EOpPreDecrement:
             ASSERT((unOp != NULL) && (binOp == NULL));
             increment = -1;
             break;
         case EOpAddAssign:
             ASSERT((unOp == NULL) && (binOp != NULL));
             increment = evaluateIntConstant(incrementNode);
             break;
         case EOpSubAssign:
             ASSERT((unOp == NULL) && (binOp != NULL));
             increment = - evaluateIntConstant(incrementNode);
             break;
         default:
             ASSERT(false);
     }
     return increment;
 }
 int ForLoopUnroll::evaluateIntConstant(TIntermConstantUnion* node)
 {
     ASSERT((node != NULL) && (node->getUnionArrayPointer() != NULL));
     return node->getIConst(0);
 }

The Tor Browser / annotate

gfx/angle/src/compiler/ForLoopUnroll.cpp@129ffea94266 (annotated)

gfx/angle/src/compiler/ForLoopUnroll.cpp