~ubuntu-branches/ubuntu/vivid/qtdeclarative-opensource-src-gles/vivid

        QVector<Stmt *> code;

        QHash<Stmt *, BasicBlock *> leader;

 

                continue;

                code.append(s);

            }

        }

                qout << endl;

                QByteArray str;

                str.append('L');

                str.append(':');

                if (bb->catchBlock) {

                    str.append(" (exception handler L");

                    str.append(')');

                }

                for (int i = 66 - str.length(); i; --i)

                qout << str;

                qout << "// predecessor blocks:";

                foreach (BasicBlock *in, bb->in)

                if (bb->in.isEmpty())

                    qout << "(none)";

                if (BasicBlock *container = bb->containingGroup())

                if (bb->isGroupStart())

                    qout << "; group start";

                qout << endl;

            qout << endl;

 

            if (n && s->asCJump()) {

            }

        }

 

    QBitArray processed;

 

public:

    {

    }

 

    bool alreadyProcessed(BasicBlock *bb) const

    {

        Q_ASSERT(bb);

 

    }

 

    void markAsProcessed(BasicBlock *bb)

    {

    }

};

 

 

    Numbers *blockNumbers;

    Flags *blockFlags;

    enum { MaxVectorCapacity = 8 };

 

    // Q_DISABLE_COPY(BasicBlockSet); disabled because MSVC wants assignment operator for std::vector

                else

                    flagIt = set.blockFlags->size();

            } else {

                    numberIt = set.blockNumbers->begin();

            }

        }

 

    public:

        BasicBlock *operator*() const

        {

            if (set.blockNumbers) {

            } else {

                Q_ASSERT(flagIt <= INT_MAX);

            }

        }

 

 

        const_iterator &operator++()

        {

                ++numberIt;

 

            return *this;

        }

    friend class const_iterator;

 

public:

#ifdef Q_COMPILER_RVALUE_REFS

    BasicBlockSet(BasicBlockSet &&other): blockNumbers(0), blockFlags(0)

    {

        std::swap(blockNumbers, other.blockNumbers);

        std::swap(blockFlags, other.blockFlags);

    }

 

#endif // Q_COMPILER_RVALUE_REFS

    ~BasicBlockSet() { delete blockNumbers; delete blockFlags; }

 

    {

        blockNumbers = new Numbers;

        blockNumbers->reserve(MaxVectorCapacity);

    }

    void insert(BasicBlock *bb)

    {

        if (blockFlags) {

            return;

        }

 

        for (std::vector<int>::const_iterator i = blockNumbers->begin(), ei = blockNumbers->end();

             i != ei; ++i)

                return;

 

        if (blockNumbers->size() == MaxVectorCapacity) {

            for (std::vector<int>::const_iterator i = blockNumbers->begin(), ei = blockNumbers->end();

                 i != ei; ++i)

                blockFlags->operator[](*i) = true;

            delete blockNumbers;

            blockNumbers = 0;

        } else {

        }

    }

 

    typedef int BasicBlockIndex;

    enum { InvalidBasicBlockIndex = -1 };

 

    int N;

    std::vector<int> dfnum; // BasicBlock index -> dfnum

    std::vector<int> vertex;

                vertex[N] = n;

                parent[n] = todo.parent;

                ++N;

                for (int i = out.size() - 1; i > 0; --i)

 

                if (out.size() > 0) {

                    todo.parent = n;

                    continue;

                }

    }

 

    void calculateIDoms() {

 

 

        QHash<BasicBlockIndex, std::vector<BasicBlockIndex> > bucket;

 

 

        std::vector<BasicBlockIndex> worklist;

        worklist.reserve(vertex.capacity() / 2);

            BasicBlockIndex p = parent[n];

            BasicBlockIndex s = p;

 

                BasicBlockIndex ss = InvalidBasicBlockIndex;

                else

                if (dfnum[ss] < dfnum[s])

                    s = ss;

            }

                qout << "(none)";

            qout << " -> " << to->index << endl;

        }

#endif // SHOW_SSA

    }

 

    void computeDF() {

        // compute children of each node in the dominator tree

        std::vector<std::vector<BasicBlockIndex> > children; // BasicBlock index -> children

            const BasicBlockIndex nodeDominator = idom[nodeIndex];

            if (nodeDominator == InvalidBasicBlockIndex)

                continue; // there is no dominator to add this node to as a child (e.g. the start node)

 

        // Fill the worklist and initialize the node status for each basic-block

        QHash<BasicBlockIndex, NodeProgress> nodeStatus;

        std::vector<BasicBlockIndex> worklist;

            worklist.push_back(nodeIndex);

            NodeProgress &np = nodeStatus[nodeIndex];

            np.children = children[nodeIndex];

            np.todo = children[nodeIndex];

        }

 

 

        while (!worklist.empty()) {

            BasicBlockIndex node = worklist.back();

 

            if (np.todo.empty()) {

                BasicBlockSet &S = DF[node];

                        S.insert(y);

                foreach (BasicBlockIndex child, np.children) {

                    const BasicBlockSet &ws = DF[child];

                    for (BasicBlockSet::const_iterator it = ws.begin(), eit = ws.end(); it != eit; ++it) {

                        BasicBlock *w = *it;

                            S.insert(w);

                    }

                }

    }

 

public:

        , N(0)

    {

        calculateIDoms();

        computeDF();

    }

 

    const BasicBlockSet &dominatorFrontier(BasicBlock *n) const {

    }

 

    BasicBlock *immediateDominator(BasicBlock *bb) const {

    }

 

    void dumpImmediateDominators() const

 

    void updateImmediateDominator(BasicBlock *bb, BasicBlock *newDominator)

    {

 

            // This is a new block, probably introduced by edge splitting. So, we'll have to grow

            // the array before inserting the immediate dominator.

        }

 

    }

 

    bool dominates(BasicBlock *dominator, BasicBlock *dominated) const {

    }

 

private:

    bool dominates(BasicBlockIndex dominator, BasicBlockIndex dominated) const {

        // dominator can be Invalid when the dominated block has no dominator (i.e. the start node)

        Q_ASSERT(dominated != InvalidBasicBlockIndex);

 

            if (it == dominator)

                return true;

        }

};

 

class VariableCollector: public StmtVisitor, ExprVisitor {

    QSet<Temp> nonLocals;

    QSet<Temp> killed;

 

        : function(function)

    {

        _defsites.reserve(function->tempCount);

 

#if defined(SHOW_SSA)

        qout << "Variables collected:" << endl;

#endif // SHOW_SSA

 

            currentBB = bb;

            killed.clear();

                s->accept(this);

            }

        }

    }

 

    QSet<Temp> inBlock(BasicBlock *n) const {

    }

 

    bool isNonLocal(const Temp &var) const { return nonLocals.contains(var); }

                qout << " -> L" << currentBB->index << endl;

#endif // SHOW_SSA

 

 

                // For semi-pruned SSA:

                killed.insert(*t);

    phiNode->d = new Stmt::Data;

    phiNode->targetTemp = f->New<Temp>();

    phiNode->targetTemp->init(a.kind, a.index, 0);

 

    phiNode->d->incoming.resize(y->in.size());

    for (int i = 0, ei = y->in.size(); i < ei; ++i) {

    VariableRenamer(IR::Function *f)

        : function(f)

        , tempCount(0)

    {

        localMapping.reserve(f->tempCount);

        vregMapping.reserve(f->tempCount);

    }

 

    void run() {

 

        while (!todo.isEmpty()) {

            TodoAction todoAction = todo.back();

 

    void renameStatementsAndPhis(BasicBlock *bb)

    {

            s->accept(this);

 

        foreach (BasicBlock *Y, bb->out) {

            const int j = Y->in.indexOf(bb);

            Q_ASSERT(j >= 0 && j < Y->in.size());

                if (Phi *phi = s->asPhi()) {

                    Temp *t = phi->d->incoming[j]->asTemp();

                    unsigned newTmp = currentNumber(*t);

 

void convertToSSA(IR::Function *function, const DominatorTree &df)

{

    qout << "Converting function ";

    if (function->name)

        qout << *function->name;

    // Collect all applicable variables:

    VariableCollector variables(function);

 

    // Place phi functions:

    foreach (Temp a, variables.vars()) {

        if (!variables.isNonLocal(a))

            continue; // for semi-pruned SSA

            for (BasicBlockSet::const_iterator it = dominatorFrontierForN.begin(), eit = dominatorFrontierForN.end();

                 it != eit; ++it) {

                BasicBlock *y = *it;

                    insertPhiNode(a, y, function);

                    if (!variables.inBlock(y).contains(a))

                        W.append(y);

                }

 

private:

    IR::Function *function;

    QHash<Stmt *, QList<Temp> > _usesPerStatement;

 

    BasicBlock *_block;

    DefUsesCalculator(IR::Function *function)

        : function(function)

    {

            _block = bb;

                _stmt = stmt;

                stmt->accept(this);

            }

    QList<Temp> usedVars(Stmt *s) const

    { return _usesPerStatement[s]; }

 

 

    QVector<Stmt*> removeDefUses(Stmt *s)

    {

        foreach (const UntypedTemp &var, _defUses.keys()) {

            const DefUse &du = _defUses[var];

            var.temp.dump(qout);

            du.defStmt->dump(qout);

            qout<<endl<<"     uses:"<<endl;

            foreach (Stmt *s, du.uses) {

    foreach (Phi *phi, toRemove) {

        Temp targetVar = *phi->targetTemp;

 

 

        foreach (const Temp &usedVar, defUses.usedVars(phi))

            defUses.removeUse(phi, usedVar);

{

    QVector<Stmt *> worklist;

    QBitArray inWorklist;

 

public:

    StatementWorklist(IR::Function *function)

 

        // Put in all statements, and number them on the fly. The numbering is used to index the

        // bit array.

            }

        }

 

    void clear(Stmt *stmt)

    {

        Q_ASSERT(!inWorklist.at(stmt->id));

    }

 

    void replace(Stmt *oldStmt, Stmt *newStmt)

    {

        Q_ASSERT(oldStmt);

        Q_ASSERT(newStmt);

 

        if (newStmt->id == -1)

            newStmt->id = oldStmt->id;

    }

 

    void cleanup(IR::Function *function)

    {

                }

            }

        }

    }

    QQmlEnginePrivate *qmlEngine;

    IR::Function *function;

    const DefUsesCalculator &_defUses;

    struct TypingResult {

        DiscoveredType type;

        bool fullyTyped;

 

        // TODO: the worklist handling looks a bit inefficient... check if there is something better

        _worklist.clear();

            if (i == 0 || !bb->in.isEmpty())

        }

 

        while (!_worklist.isEmpty()) {

            _worklist.clear();

            while (!worklist.isEmpty()) {

                Stmt *s = worklist.first();

                worklist.removeFirst();

#if defined(SHOW_SSA)

                qout<<"Typing stmt ";s->dump(qout);qout<<endl;

#endif

 

                if (!run(s)) {

#if defined(SHOW_SSA)

                    qout<<"Pushing back stmt: ";

                    s->dump(qout);qout<<endl;

#endif

            if (isAlwaysVar(t))

                ty = DiscoveredType(VarType);