harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r472885 - in /incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf: ./ include/
Date Thu, 09 Nov 2006 13:00:16 GMT
Author: mloenko
Date: Thu Nov  9 05:00:15 2006
New Revision: 472885

URL: http://svn.apache.org/viewvc?view=rev&rev=472885
Log:
applied newest patch for HARMONY-2061
[drlvm][ipf] new node merging algorithm

Modified:
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfgVerifier.cpp
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeGenerator.cpp
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfgVerifier.h
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeGenerator.h
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h
    incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp Thu Nov  9 05:00:15 2006
@@ -17,7 +17,6 @@
                                                                                                             
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -32,11 +31,11 @@
 // Edge
 //========================================================================================//
 
-Edge::Edge(Node *source_, Node *target_, double prob_, EdgeKind edgeKind_) : 
-    edgeKind(edgeKind_),
-    source(source_), 
-    target(target_), 
-    prob(prob_) {
+Edge::Edge(Node *source, Node *target, double prob, EdgeKind edgeKind) : 
+    edgeKind(edgeKind),
+    source(source), 
+    target(target), 
+    prob(prob) {
 }
 
 //----------------------------------------------------------------------------------------//
@@ -81,48 +80,32 @@
     return false;
 }
 
-//---------------------------------------------------------------------------//
-void    Edge::connect(Node *target_) {
-    if (target!=NULL) {
-//        target->removeEdge(this);
-        target->removeInEdge(this);
-    }
-    target=target_;
-//    target_->addEdge(this);
-    target_->addInEdge(this);
-}
-    
-//----------------------------------------------------------------------------//
-void    Edge::disconnect() {
-    if (target!=NULL) {
-//        target->removeEdge(this);
-        target->removeInEdge(this);
-        target=NULL;
-    }
-}
-
 //========================================================================================//
 // ExceptionEdge
 //========================================================================================//
 
-ExceptionEdge::ExceptionEdge(Node   *source_, 
-                             Node   *target_, 
-                             double  prob_, 
-                             Type   *exceptionType_, 
-                             uint32  priority_) :
-    Edge(source_, target_, prob_, EDGE_EXCEPTION), 
-    exceptionType(exceptionType_),
-    priority(priority_) {
+ExceptionEdge::ExceptionEdge(Node   *source, 
+                             Node   *target, 
+                             double  prob, 
+                             Type   *exceptionType, 
+                             uint32  priority) :
+    Edge(source, target, prob, EDGE_EXCEPTION), 
+    exceptionType(exceptionType),
+    priority(priority) {
 }
 
 //========================================================================================//
 // Node
 //========================================================================================//
 
-Node::Node(uint32 id_, NodeKind kind_)  {
-    id         = id_;
-    nodeKind   = kind_;
-    loopHeader = NULL;
+Node::Node(MemoryManager &mm, uint32 id, uint32 execCounter, NodeKind kind) : 
+    id(id), 
+    execCounter(execCounter),
+    nodeKind(kind),  
+    inEdges(mm),
+    outEdges(mm),
+    loopHeader(NULL),
+    liveSet(mm) {
 }
 
 //----------------------------------------------------------------------------------------//
@@ -211,71 +194,19 @@
 
 void Node::remove() {
     
-    EdgeVector edges;
-    
-    // remove out edges
-    edges = outEdges;                          
-    for (uint16 i=0; i<edges.size(); i++) edges[i]->remove();                    
-    
-    // remove in edges
-    edges = inEdges;
-    for (uint16 i=0; i<edges.size(); i++) edges[i]->remove();                    
-}
-
-//----------------------------------------------------------------------------------------//
-
-void Node::removeInEdge(Edge *edge) {
-//    remove(inEdges.begin(), inEdges.end(), edge);
-    EdgeVector::iterator last=inEdges.end();
-    EdgeVector::iterator pos=find(inEdges.begin(), last, edge);
-    if (pos==last) return; // not found
-    inEdges.erase(pos);
-}
-
-void Node::addInEdge(Edge *edge) {
-    inEdges.push_back(edge);
-}
-
-void Node::printEdges(ostream& out, EdgeVector& edges, bool head) {
-    for (uint i=0; i<edges.size(); i++) {
-        Edge *edge=edges[i];
-        if (edge==NULL) {
-            out << " <edge[" << i << "]=null>";
-            continue;
-        }
-        Node *sibling=head? edge->getTarget(): edge->getSource();
-        if (sibling==NULL) {
-            out << " null";
-            continue;
-        }
-          out << " " << sibling->getId();
-    }
-}
-
-void Node::printEdges(ostream& out) {
-    out << " ins:";
-    printEdges(out, getInEdges(), false);
-    out << " outs:";
-    printEdges(out, getOutEdges(), true);
+    for (int16 i=outEdges.size()-1; i>=0; i--) outEdges[i]->remove(); // remove out edges
+    for (int16 i=inEdges.size()-1;  i>=0; i--) inEdges[i]->remove();  // remove in edges
 }
 
 //========================================================================================//
 // BbNode
 //========================================================================================//
 
-BbNode::BbNode(uint32 id_, uint32 execCounter_) : 
-    Node(id_, NODE_BB),
+BbNode::BbNode(MemoryManager &mm, uint32 id, uint32 execCounter) : 
+    Node(mm, id, execCounter, NODE_BB),
+    insts(mm),
     layoutSucc(NULL),
-    address(0),
-    execCounter(execCounter_) {
-}
-
-//----------------------------------------------------------------------------------------//
-
-void BbNode::addInst(Inst *inst) { 
-
-    IPF_LOG << "        " << IrPrinter::toString(inst) << endl;
-    insts.push_back(inst); 
+    address(0) {
 }
 
 //========================================================================================//
@@ -284,13 +215,14 @@
 
 Cfg::Cfg(MemoryManager &mm, CompilationInterface &compilationInterface):
     mm(mm),
-    compilationInterface(compilationInterface) {
+    compilationInterface(compilationInterface),
+    maxNodeId(0),
+    enterNode(NULL),
+    exitNode(NULL),
+    searchResult(mm),
+    lastSearchKind(SEARCH_UNDEF_ORDER) {
 
-    maxNodeId      = 0;
-    opndManager    = new(mm) OpndManager(mm, compilationInterface);
-    enterNode      = NULL;
-    exitNode       = NULL;
-    lastSearchKind = SEARCH_UNDEF_ORDER;
+    opndManager = new(mm) OpndManager(mm, compilationInterface);
 }
 
 //----------------------------------------------------------------------------------------//
@@ -300,7 +232,7 @@
     if(lastSearchKind == searchKind) return searchResult;
     lastSearchKind = searchKind;
 
-    NodeSet visitedNodes;
+    NodeSet visitedNodes(mm);
     searchResult.clear();
 
     switch(searchKind) {

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfgVerifier.cpp
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfgVerifier.cpp?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfgVerifier.cpp (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfgVerifier.cpp Thu Nov  9 05:00:15 2006
@@ -17,753 +17,12 @@
                                                                                                             
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
-#include "BitSet.h"
-#include "IpfCfgVerifier.h"
-#include "IpfOpndManager.h"
-#include "IpfIrPrinter.h"
 
 namespace Jitrino {
 namespace IPF {
     
-//========================================================================================//
-// OrderededNodeVector
-//========================================================================================//
-class OrderededNodeVector:public NodeVector {
-    friend class CfgView;
-public:
-    OrderededNodeVector(Cfg& cfg_, const char*  orderName, bool fromEnter=true):
-        cfg(cfg_),
-        orderName(orderName),
-        valid(false),
-        fromEnter(fromEnter),
-        nodes(*this),
-        visitedNodes(cfg_.getMM(), cfg_.getMaxNodeId())
-    {}
-    
-    void collect();
-    void printContent(ostream& out);
-    
-protected:
-
-    virtual void makeOrdered(Node* node)=0;
-    virtual ~OrderededNodeVector(){}; // for gcc 
-    
-    Cfg& cfg;
-    const char*   orderName;
-    bool valid;
-    bool fromEnter;
-    NodeVector& nodes;
-    BitSet visitedNodes;
-
-};
-
-//---------------------------------------------------------------------------//
-void OrderededNodeVector::collect() {
-    if (valid) return;
-    nodes.clear();
-    uint32 numNodes=cfg.getMaxNodeId();
-    visitedNodes.resizeClear(numNodes);
-    makeOrdered(fromEnter?cfg.getEnterNode():cfg.getExitNode()); 
-    valid=true;
-}    
-
-//---------------------------------------------------------------------------//
-void OrderededNodeVector::printContent(ostream& out) {
-    out << "CFG ordered: " << orderName << " size:" << size() << endl;
-    for(uint k=0; k<nodes.size(); k++) {
-        Node* node=nodes[k];
-        out << "node " << node->getId() << ": ";
-        node->printEdges(out);
-        out << endl;
-    }
-}
-
-//---------------------------------------------------------------------------//
-class DirectOrderedNodeVector: public OrderededNodeVector {
-public:
-    DirectOrderedNodeVector(Cfg& cfg_):
-        OrderededNodeVector(cfg_, "Direct", false)
-    {}
-protected:
-    virtual void makeOrdered(Node* node);
-
-};
-
-void DirectOrderedNodeVector::makeOrdered(Node* node) {
-    visitedNodes.setBit(node->getId());              // mark node visited
-    EdgeVector& inEdges = node->getInEdges();        // get inEdges
-    for (uint i=0; i<inEdges.size(); i++) {          // iterate through inEdges
-        Edge* edge=inEdges[i];
-        if (edge==NULL) {
-            assert(edge);
-            continue;
-        }
-        Node* pred = edge->getSource();     // get pred node
-        if (pred==NULL) {
-            assert(pred);
-            continue;
-        }
-        if (visitedNodes.getBit(pred->getId())) continue;  // if it is already visited - ignore
-        makeOrdered(pred);       // we have found unvisited pred - reenter
-    }
-    nodes.push_back(node);                    // all succs have been visited - place node in searchResult vector
-}
-
-//----------------------------------------------------------------------------------------//
-class PostOrderededNodeVector: public OrderededNodeVector {
-public:
-    PostOrderededNodeVector(Cfg& cfg_):
-        OrderededNodeVector(cfg_, "Post")
-    {}
-protected:
-    virtual void makeOrdered(Node* node);
-
-};
-
-void PostOrderededNodeVector::makeOrdered(Node* node) {
-    visitedNodes.setBit(node->getId());                       // mark node visited
-    EdgeVector& outEdges = node->getOutEdges();       // get outEdges
-    for (uint i=0; i<outEdges.size(); i++) {         // iterate through outEdges
-        Edge* edge=outEdges[i];
-        if (edge==NULL) {
-            assert(edge);
-            continue;
-        }
-        Node* succ = edge->getTarget();     // get succ node
-        if (succ==NULL) {
-            assert(succ);
-            continue;
-        }
-        if (visitedNodes.getBit(succ->getId())) continue;   // if it is already visited - ignore
-        makeOrdered(succ);          // we have found unvisited succ - reenter
-    }
-    nodes.push_back(node);                     // all succs have been visited - place node in searchResult vector
-}
-
-//----------------------------------------------------------------------------------------//
-
-class LayoutOrderedNodeVector: public OrderededNodeVector {
-public:
-    LayoutOrderedNodeVector(Cfg& cfg_):
-        OrderededNodeVector(cfg_, "Layout")
-    {}
-protected:
-    virtual void makeOrdered(Node* node);
-
-};
-
-void LayoutOrderedNodeVector::makeOrdered(Node* node_) {
-    BbNode* node = (BbNode*)node_;
-    while (node != NULL) {
-        visitedNodes.setBit(node->getId());       // mark node visited
-        nodes.push_back(node);
-        node = node->getLayoutSucc();
-    }
-}
-
-//========================================================================================//
-class CfgView {
-public:
-    CfgView(Cfg& cfg_):
-        directOrderedNodes(cfg_),
-        postOrderedNodes(cfg_),
-        layoutOrderedNodes(cfg_)
-    {}
-    
-    OrderededNodeVector& sortNodes(SearchKind searchKind);
-    void changed();
-    bool verifyNodes(ostream& cout);
-        
-private:
-    DirectOrderedNodeVector directOrderedNodes;
-    PostOrderededNodeVector postOrderedNodes;
-    LayoutOrderedNodeVector layoutOrderedNodes;
-};
-
-//---------------------------------------------------------------------------//
-OrderededNodeVector& CfgView::sortNodes(SearchKind searchKind) {
-    switch (searchKind) {
-        case SEARCH_DIRECT_ORDER :
-            directOrderedNodes.collect(); 
-            return directOrderedNodes; 
-        case SEARCH_POST_ORDER   :
-            postOrderedNodes.collect(); 
-            return postOrderedNodes; 
-        case SEARCH_LAYOUT_ORDER :
-            layoutOrderedNodes.collect(); 
-            return layoutOrderedNodes; 
-         case SEARCH_UNDEF_ORDER     :
-            if (directOrderedNodes.valid) return directOrderedNodes;
-            if (postOrderedNodes.valid) return postOrderedNodes;
-            layoutOrderedNodes.collect();
-            return layoutOrderedNodes;
-        default:
-            IPF_LOG << IPF_ERROR << endl;
-            assert(0);
-            layoutOrderedNodes.collect();
-            return layoutOrderedNodes;
-    }
-}    
-
-bool CfgView::verifyNodes(ostream& cout) {
-    OrderededNodeVector& dir=sortNodes(SEARCH_DIRECT_ORDER);
-    OrderededNodeVector& post=sortNodes(SEARCH_POST_ORDER);
-    if (dir.visitedNodes.isEqual(post.visitedNodes)) return true;
-    cout << "verifyNodes: DIRECT_ORDER and POST_ORDER differs:" << endl;
-    BitSet collectedNodes(dir.visitedNodes);
-    collectedNodes.subtract(post.visitedNodes);
-    if (!collectedNodes.isEmpty()) {
-        cout << "    DIRECT-POST = ";
-        collectedNodes.print(cout);
-    }
-    collectedNodes.copyFrom(post.visitedNodes);
-    collectedNodes.subtract(dir.visitedNodes);
-    if (!collectedNodes.isEmpty()) {
-        cout << "    POST-DIRECT =  ";
-        collectedNodes.print(cout);
-    }
-//        IPF_EXIT("CfgView::verifyNodes");
-    return false;
-}
-
-void CfgView::changed() {
-    directOrderedNodes.valid=false;
-    postOrderedNodes.valid=false;
-    layoutOrderedNodes.valid=false;
-}
-
-//===========================================================================//
-class IpfCfgVerifier: public CfgView {
-    friend class Vertex;
-    friend class VertexBB;
-protected:
-    MemoryManager& mm;
-    Cfg& cfg;
-    uint numAllNodes;
-    uint numNodes;
-    uint numOpnds;
-    NodeVector& nodes;
-    Vertex** verticesById;  // by node ids
-    Vertex** vertices;  // post-ordered
-    BitSet tmpSet;
-    BitSet tmpSet2;
-    BitSet ignoredOpnds;
-    RegOpnd** opndsById;
-    uint p0Id;
-    
-    Vertex* getVertex(Node* node) {
-        return verticesById[node->getId()];
-    }
-    VertexBB* getVertexBB(BbNode* node) {
-        return (VertexBB*)(verticesById[node->getId()]);
-    }
-    Vertex* getSourceVertex(Edge* edge) {
-        return getVertex(edge->getSource());
-    }
-    Vertex* getTargetVertex(Edge* edge) {
-        return getVertex(edge->getTarget());
-    }
-        
-    void registerOpnds(OpndVector& opnds);
-    void printOpndSet(ostream& os, const char* str, BitSet& set);
-public:
-
-    IpfCfgVerifier(MemoryManager& mm, Cfg& cfg);
-    void setDefUse();
-    bool collectLiveSets();                        
-    virtual bool checkLiveSets();
-
-    void setDefs();
-    bool collectDefs();
-    virtual bool checkDefs();
-    
-    virtual ~IpfCfgVerifier() {}
-};  // end class IpfCfgVerifier
-
-struct Vertex {
-//    friend class IpfCfgVerifier;
-    IpfCfgVerifier& fSolver;
-    Node* node;
-    BitSet* in; 
-    BitSet* out; 
-
-    Vertex(MemoryManager& mm, IpfCfgVerifier& fSolver, Node* node, int width):
-        fSolver(fSolver),
-        node(node),
-        in(new(mm) BitSet(mm, width)),
-        out(in)
-    {}
-    
-    EdgeVector& getInEdges() {
-        return node->getInEdges();
-    }
-    EdgeVector& getOutEdges() {
-        return node->getOutEdges();
-    }
-
-    virtual void computeIn();
-//    virtual bool checkLiveSet() {return true; }
-    bool checkLiveSet();
-    
-    virtual void computeOut();
-    virtual bool checkDefs() {return true; }
-
-};
-
-struct VertexBB:Vertex {
-//    friend class IpfCfgVerifier;
-    BbNode* node;
-    BitSet* use; 
-    BitSet* def; 
-
-    VertexBB(MemoryManager& mm, IpfCfgVerifier& fSolver, BbNode* node, int width):
-        Vertex(mm, fSolver, node, width),
-        node(node),
-        use(new(mm) BitSet(mm, width)),
-        def(new(mm) BitSet(mm, width))  // TODO: def and use may be null
-    {
-        in=new(mm) BitSet(mm, width);
-    }
-
-    void setDefUse();
-    virtual void computeIn();
-//    virtual bool checkLiveSet();
-    
-    void setDef(Inst* inst);
-    void setDef();
-    virtual void computeOut();
-    bool checkOpndIsDef(Opnd* opnd, uint instId);
-    virtual bool checkDefs();
-
-};
-
-//---------------------------------------------------------------------------//
-IpfCfgVerifier::IpfCfgVerifier(MemoryManager& mm, Cfg& cfg):
-    CfgView(cfg),
-    mm(mm),
-    cfg(cfg),
-    numAllNodes(cfg.getMaxNodeId()),
-    numOpnds(cfg.getOpndManager()->getNumOpnds()),
-    nodes(sortNodes(SEARCH_DIRECT_ORDER)),
-    verticesById(new(mm) (Vertex*)[numAllNodes]),
-    vertices(NULL),
-    tmpSet(mm, numOpnds),
-    tmpSet2(mm, numOpnds),
-    ignoredOpnds(mm, numOpnds),
-    opndsById(new(mm) (RegOpnd*)[numOpnds]),
-    p0Id(cfg.getOpndManager()->getP0()->getId())
-{
-    for (uint k=0; k<numAllNodes; k++) {
-        verticesById[k]=NULL;
-    }
-    for (uint k=0; k<numOpnds; k++) {
-        opndsById[k]=NULL;
-    }
-    
-    numNodes=nodes.size();
-    vertices=new(mm) (Vertex*)[numNodes];
-    for (uint k=0; k<numNodes; k++) {
-        Node* node=nodes[k];
-        Vertex* vertex;
-        if (node->getNodeKind()==NODE_BB) {
-            vertex=new(mm) VertexBB(mm, *this, (BbNode*)node, numOpnds);
-        } else {
-            vertex=new(mm) Vertex(mm, *this, node, numOpnds);
-        }                
-        verticesById[node->getId()]=vertex;
-        vertices[k]=vertex;
-    }
-}
-    
-//---------------------------------------------------------------------------//
-void IpfCfgVerifier::printOpndSet(ostream& os, const char* str, BitSet& set) {
-    RegOpndSet  opndSet;
-    os << str;
-    for (uint k=0; k<numOpnds; k++) {
-        if (set.getBit(k)) {
-            RegOpnd* opnd=opndsById[k];
-            if (opnd==NULL) {
-                os << "opnd[" << k << "] ";
-                continue;
-            }            
-            opndSet.insert(opnd);
-        }
-    }
-    os << IrPrinter::toString(opndSet) << endl;
-}
-    
-//---------------------------------------------------------------------------//
-// register ALL opnds in 'opndsById'
-void IpfCfgVerifier::registerOpnds(OpndVector& opnds) {    
-    for (uint k=0; k<opnds.size(); k++) {
-           Opnd* opnd = opnds[k];
-           if (!opnd->isReg()) continue;
-           RegOpnd* reg = (RegOpnd*)opnd;
-        uint id=opnd->getId();
-        if (opndsById[id]==reg) {
-            continue; // registered already
-        }
-        opndsById[id]=reg;
-        
-        int num=reg->getValue();
-        switch(reg->getOpndKind()) {
-            case OPND_G_REG:
-                // ignore r0 r8
-                if ((num == 0)|| (num == 8)) {
-                    // r8 - returned value;  TODO: more accurate
-                    ignoredOpnds.setBit(id);
-                }
-                break;
-            case OPND_F_REG:
-                // ignore f0 f1 f8
-                if ((num == 0) || (num == 1) || (num == 8)) {
-                    // f8 - returned value;  TODO: more accurate
-                    ignoredOpnds.setBit(id);
-                }
-                break;
-            case OPND_P_REG:
-                // ignore p0
-                if (num == 0) {
-                    ignoredOpnds.setBit(id);
-                }
-                break;
-            case OPND_B_REG:
-                // ignore  all br:
-                ignoredOpnds.setBit(id);
-                break;
-            default: ;
-        }
-    }
-}
-
-//---------------------------------------------------------------------------//
-// check live sets
-//---------------------------------------------------------------------------//
-
-void VertexBB::setDefUse() {
-    // iterate through instructions postorder and calculate liveSet for begining of the node
-    InstVector& insts = node->getInsts();
-    for (int j=insts.size()-1; j>=0; j--) {
-        Inst* inst=insts[j];
-        uint numDst=inst->getNumDst();
-        OpndVector& opnds    = inst->getOpnds();            // get inst opnds
-        
-        if (((RegOpnd*) opnds[0])->getValue() == 0) {  // qp==p0
-            for (uint k=1; k<numDst+1; k++) {
-                Opnd* opnd = opnds[k];
-                if (!opnd->isReg()) continue; // ignore non register opnd
-                uint id=opnd->getId();
-                def->setBit(id); 
-                use->setBit(id, false);
-            }
-            // TODO: If no one opnd was in Live Set - inst is dead
-        } else {
-            // add qp opnd in Use Set
-            use->setBit(opnds[0]->getId()); 
-        }
-        // add src opnds in Use Set
-        for (uint k=numDst+1; k<opnds.size(); k++) {
-            Opnd* opnd = opnds[k];
-             if (!opnd->isReg()) continue; // ignore non register opnd
-            use->setBit(opnd->getId());
-        }
-        fSolver.registerOpnds(opnds);
-    }
-}
-
-void IpfCfgVerifier::setDefUse() {
-    for (int k=numNodes-1; k>=0; k--) {
-        Node* node=nodes[k];
-        if (node->getNodeKind()==NODE_BB) {
-            VertexBB* vertex=getVertexBB((BbNode*)node);
-            vertex->setDefUse();
-        }                
-    }
-}
-
-void Vertex::computeIn() {
-    // out[B] := U in[S]
-    EdgeVector& outEdges=getOutEdges();
-    uint size=outEdges.size();
-    if (size==0) return;
-    Vertex* succ=fSolver.getTargetVertex(outEdges[0]);
-    out->copyFrom(*(succ->in));
-    for (uint k=1; k<outEdges.size(); k++) {
-        succ=fSolver.getTargetVertex(outEdges[k]);
-        out->unionWith(*(succ->in));
-    }
-    // in[B] == out[B]
-}
-    
-void VertexBB::computeIn() {
-    // out[B] := U in[S]
-    Vertex::computeIn();
-    // in[B] := use[B} U (out[B] - def[B])
-    in->copyFrom(*out);
-    in->subtract(*def);
-    in->unionWith(*use);
-}
-    
-//---------------------------------------------------------------------------//
-//bool VertexBB::checkLiveSet() {
-bool Vertex::checkLiveSet() {
-
-    RegOpndSet& liveSet = node->getLiveSet();
-    BitSet& dceIn=fSolver.tmpSet;
-    BitSet& tmpSet=fSolver.tmpSet2;
-    dceIn.clear();
-
-    for (RegOpndSetIterator i=liveSet.begin(); i!=liveSet.end(); i++) {
-        Opnd* opnd = (Opnd*)(*i);
-        IPF_ASSERT(opnd!=NULL);
-        uint id = opnd->getId();
-        dceIn.setBit(id);
-    }
-    dceIn.subtract(fSolver.ignoredOpnds);  // ignore p0, r0, f0 etc
-    in->subtract(fSolver.ignoredOpnds);
-    if (in->isEqual(dceIn)) return true;
-
-    IPF_LOG << "checkLiveSets: DCE and IpfCfgVerifier results differs for node" << node->getId() << endl;
-    bool res=true;
-    tmpSet.copyFrom(dceIn);
-    tmpSet.subtract(*in);
-    if (!tmpSet.isEmpty()) {
-        if (LOG_ON) {
-            fSolver.printOpndSet(LOG_OUT, "    DCE has  ", tmpSet);
-        }
-//            res=false;      commented out while too many failures to concide
-    }
-    
-    tmpSet.copyFrom(*in);
-    tmpSet.subtract(dceIn);
-    if (!tmpSet.isEmpty()) {
-        if (LOG_ON) {
-            fSolver.printOpndSet(LOG_OUT, "    IpfCfgVerifier has  ", tmpSet);
-        }
-        res=false;        
-    }
-    
-    return res;
-}
-
-//---------------------------------------------------------------------------//
-
-bool IpfCfgVerifier::collectLiveSets() {
-    bool changed = false;
-    for (int k=numNodes-1; k>=0; k--) {
-        Vertex* vertex=vertices[k];
-        tmpSet.copyFrom(*vertex->in);  // save to compare
-        vertex->computeIn();
-//printf(" %s%d", vertex->in->getBit(9)?"*":" ", vertex->node->getId());
-        if (!changed) {
-            changed = !vertex->in->isEqual(tmpSet);  // compare
-        }
-    }
-//printf("\n");
-    return changed;
-}
-
-//---------------------------------------------------------------------------//
-bool IpfCfgVerifier::checkLiveSets() {
-    setDefUse();
-//printf("IpfCfgVerifier::checkLiveSets():\n");
-    // solve the flow equation set
-    while (collectLiveSets()) {};
-    
-    // compare our results with DCE results
-    bool res = true;
-    for (uint k=0; k<numNodes; k++) {
-        Vertex* vertex=vertices[k];
-        res=vertex->checkLiveSet() & res;
-    }
-    if (res) {
-        if (LOG_ON) {
-            IPF_LOG << "ignoredOpnds="; 
-            ignoredOpnds.print(LOG_OUT);
-        }
-    }
-    return res;
-}
-
-//---------------------------------------------------------------------------//
-// check defs
-//---------------------------------------------------------------------------//
-
-void VertexBB::setDef(Inst* inst) {
-    uint numDst=inst->getNumDst();
-    OpndVector& opnds    = inst->getOpnds();            // get inst opnds
-    
-//    if (((RegOpnd*) opnds[0])->getLocation() == 0) {  // qp==p0
-// TODO: handle conditional instructions more accurate 
-    for (uint k=1; k<numDst+1; k++) {
-        Opnd* opnd = opnds[k];
-        if (!opnd->isReg()) continue; // ignore non register opnd
-        uint id=opnd->getId();
-        def->setBit(id); 
-    }
-}
-
-void VertexBB::setDef() {
-    // iterate through instructions in direct order
-    InstVector& insts = node->getInsts();
-    for (uint j=0; j<insts.size(); j++) {
-        Inst* inst=insts[j];
-        setDef(inst);
-        OpndVector& opnds    = inst->getOpnds();            // get inst opnds
-        fSolver.registerOpnds(opnds);
-    }
-}
-
-//---------------------------------------------------------------------------//
-void IpfCfgVerifier::setDefs() {
-    OpndVector args; // = cfg.getArgs();
-    BitSet* enterIn=getVertex(cfg.getEnterNode())->in;
-    for (uint k=0; k<args.size(); k++) {
-        enterIn->setBit(args[k]->getId());
-    }    
-
-    for (uint k=0; k<numNodes; k++) {
-        Node* node=nodes[k];
-        if (node->getNodeKind()==NODE_BB) {
-            VertexBB* vertex=getVertexBB((BbNode*)node);
-            vertex->setDef();
-        }                
-    }
-
-    // after opnds registered and ignoredOpnds collected
-    enterIn->unionWith(ignoredOpnds);
-    for (uint k=0; k<numNodes; k++) {
-        Node* node=nodes[k];
-        Vertex* vertex=getVertex(node);
-        vertex->out->setAll();
-        if (node->getNodeKind()==NODE_BB) {
-            ((VertexBB*)vertex)->def->unionWith(ignoredOpnds);
-        }                
-    }
-}
-
-void Vertex::computeOut() {
-    // in[B] := & out[Preds]
-    EdgeVector& inEdges=getInEdges();
-    uint size=inEdges.size();
-    if (size==0) return;
-    Vertex* pred=fSolver.getSourceVertex(inEdges[0]);
-    in->copyFrom(*(pred->out));
-    for (uint k=1; k<inEdges.size(); k++) {
-        pred=fSolver.getSourceVertex(inEdges[k]);
-        in->intersectWith(*(pred->out));
-    }
-    // out[B] := in[B]
-}
-
-void VertexBB::computeOut() {
-    Vertex::computeOut();
-    // out[B] := in[B] U def[B]
-    out->copyFrom(*in);
-    out->unionWith(*def);
-}
-
-//---------------------------------------------------------------------------//
-
-bool IpfCfgVerifier::collectDefs() {
-    bool changed = false;
-    for (uint k=0; k<numNodes; k++) {
-        Vertex* vertex=vertices[k];
-        tmpSet.copyFrom(*vertex->out);  // save to compare
-        vertex->computeOut();
-
-//        bool vchanged = !vertex->out->isEqual(tmpSet);  // compare
-        if (!changed) {
-            changed = !vertex->out->isEqual(tmpSet);  // compare
-        }
-    }
-    return changed;
-}
-
-bool VertexBB::checkOpndIsDef(Opnd* opnd, uint instId) {
-    uint id=opnd->getId();
-    if (def->getBit(id)) return true;
-    IPF_LOG << "UNDEF Opnd: " << IrPrinter::toString(opnd) << " in "
-        << node->getId() << ":" << instId << " "
-        << IrPrinter::toString((node->getInsts())[instId]) << endl;
-    return false;
-}
-    
-bool VertexBB::checkDefs() {
-    bool res=true;
-    // iterate through instructions in direct order
-    InstVector& insts = ((BbNode*)node)->getInsts();
-    def->copyFrom(*in);
-    for (uint j=0; j<insts.size(); j++) {
-        Inst* inst=insts[j];
-        uint numDst=inst->getNumDst();
-        OpndVector& opnds    = inst->getOpnds();            // get inst opnds
-        
-        // check src opnds
-           RegOpnd* qp = (RegOpnd*)opnds[0];
-        if (qp->getValue() != 0) {  // qp != p0, check qp opnd 
-            res = checkOpndIsDef(qp, j) & res; 
-        }
-        for (uint k=numDst+1; k<opnds.size(); k++) {
-            Opnd* opnd = opnds[k];
-            if (!opnd->isReg()) continue; // ignore non register opnd
-            res = checkOpndIsDef(opnd, j) & res;
-        }
-        
-        // handle dst opnds
-        setDef(inst);
-    }
-    return res;
-}
-
-//---------------------------------------------------------------------------//
-bool IpfCfgVerifier::checkDefs() {
-    setDefs();
-    
-    // solve the flow equation set
-    while (collectDefs()) {};
-    
-    bool res = true;
-    for (uint k=0; k<numNodes; k++) {
-        Vertex* vertex=vertices[k];
-        res=vertex->checkDefs() & res;
-    }
-    return res;
-}
-
-//---------------------------------------------------------------------------//
-void    ipfCfgVerifier(Cfg& cfg) {
-    MemoryManager mm(1024, "IpfCfgVerifier");
-    IpfCfgVerifier verifier(mm, cfg);
-    MethodDesc* method = cfg.getMethodDesc();
-    const char* methodName     = method->getName();
-    const char* methodTypeName = (method->getParentType()!=NULL
-        ? method->getParentType()->getName()
-        : "");
-    const char * methodSignature = method->getSignatureString();
-    
-    if (!verifier.verifyNodes(LOG_OUT)) {
-        cout << "CFG check failed for " << methodTypeName << "." << methodName << methodSignature << endl;
-    }
-    // print
-    if (LOG_ON) {
-        verifier.sortNodes(SEARCH_DIRECT_ORDER).printContent(LOG_OUT);
-    }
-    
-    if (!verifier.checkLiveSets()) {
-        cout << "liveset check failed for [" << cfg.getMaxNodeId() << "] " << methodTypeName << "." << methodName << methodSignature << endl;
-    }
-    if (!verifier.checkDefs()) {
-        cout << "def check failed for [" << cfg.getMaxNodeId() << "] " << methodTypeName << "." << methodName << methodSignature << endl;
-    }
-        
-}
-
 } // IPF
 } // Jitrino
-// TODO:
-// debug this file saved in ~/saved

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeGenerator.cpp
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeGenerator.cpp?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeGenerator.cpp (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeGenerator.cpp Thu Nov  9 05:00:15 2006
@@ -14,10 +14,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+                                                                                                            
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -34,6 +33,7 @@
 #include "IpfPrologEpilogGenerator.h"
 #include "IpfRuntimeSupport.h"
 #include "IpfCfgVerifier.h"
+#include "IpfInstrumentator.h"
 
 namespace Jitrino {
 namespace IPF {
@@ -56,14 +56,13 @@
 
     MemoryManager  mm(0x1000, "IpfCodeGenerator");
     cfg = new(mm) Cfg(mm, compilationInterface);
-    char logDirName[] = "tmp_dir_name";
-    IrPrinter irPrinter(*cfg, logDirName);
+    IrPrinter irPrinter(*cfg, (char *)Log::getLogDirName());
     methodDesc = compilationInterface.getMethodToCompile();
 
-//    bool ipfLogIsOnSaved = ipfLogIsOn;
-//    if (isIpfLogoutMethod(methodDesc)) {
-//        ipfLogIsOn = true;
-//    }
+    bool ipfLogIsOnSaved = ipfLogIsOn;
+    if (isIpfLogoutMethod(methodDesc)) {
+        ipfLogIsOn = true;
+    }
     if(LOG_ON) {
         const char *methodName     = methodDesc->getName();
         const char *methodTypeName = (methodDesc->getParentType()!=NULL
@@ -81,15 +80,17 @@
     methodDesc = ipfMethodCodeSelector.getMethodDesc();
     cfg->getOpndManager()->initCompBases((BbNode *)cfg->getEnterNode());
     cfg->getOpndManager()->saveThisArg();
-    if(LOG_ON) irPrinter.printCfgDot("/cfg_cs.dot");
+    if(LOG_ON) irPrinter.printCfgDot("/cs.dot");
+
+    IPF_LOG << endl << "=========== Stage: Code Instrumentation ======================" << endl;
+//    Instrumentator instrumentator(*cfg);
+//    instrumentator.instrument();
 
     IPF_LOG << endl << "=========== Stage: Code Layouter =============================" << endl;
     CodeLayouter codeLayouter(*cfg);
     codeLayouter.layout();
-    if(LOG_ON) {
-        irPrinter.printCfgDot("/cfg_cl.dot");
-        irPrinter.printLayoutDot("/lot.dot");
-    }
+    if(LOG_ON) irPrinter.printCfgDot("/cl.dot");
+    if(LOG_ON) irPrinter.printAsm(LOG_OUT);
 
     IPF_LOG << endl << "=========== Stage: Liveness analyzis =========================" << endl;
     LiveAnalyzer liveAnalyzer(*cfg);
@@ -98,8 +99,8 @@
     IPF_LOG << endl << "=========== Stage: Dead Code Eliminator ======================" << endl;
     Dce dce(*cfg);
     dce.eliminate();
-
     liveAnalyzer.makeLiveSets(false);
+
     IPF_LOG << endl << "=========== Stage: Build GC Root Set =========================" << endl;
     RuntimeSupport runtimeSupport(*cfg, compilationInterface);
     runtimeSupport.buildRootSet();
@@ -128,7 +129,7 @@
     if(ret) IPF_LOG << endl << "=========== Compilation Successful ===========================" << endl;
     else    IPF_LOG << endl << "=========== Compilation Failed ===============================" << endl;
 
-//    ipfLogIsOn = ipfLogIsOnSaved;
+    ipfLogIsOn = ipfLogIsOnSaved;
     return ret;
 }
 

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp Thu Nov  9 05:00:15 2006
@@ -17,7 +17,6 @@
                                                                                                             
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -32,21 +31,31 @@
 // Compare two edges by prob value
 //========================================================================================//
 
-bool greaterEdge(Edge *e1, Edge *e2) { return e1->getProb() > e2->getProb(); }
+bool greaterEdge(Edge *e1, Edge *e2) { 
+
+    double c1 = e1->getProb() * e1->getSource()->getExecCounter();
+    double c2 = e2->getProb() * e2->getSource()->getExecCounter();
+    return c1 > c2; 
+}
  
 //========================================================================================//
 // CodeLayouter
 //========================================================================================//
 
-CodeLayouter::CodeLayouter(Cfg &cfg_) : 
-    mm(cfg_.getMM()),
-    cfg(cfg_) {
+CodeLayouter::CodeLayouter(Cfg &cfg) : 
+    mm(cfg.getMM()),
+    cfg(cfg),
+    chains(mm),
+    visitedNodes(mm) {
 }
 
 //----------------------------------------------------------------------------------------//
 
 void CodeLayouter::layout() {
 
+    IPF_LOG << endl << "  Outline predicated direct calls " << endl;
+    transformPredicatedCalls();
+
     IPF_LOG << endl << "  Merge Nodes" << endl;
     mergeNodes();
     checkUnwind();
@@ -63,10 +72,90 @@
 
 //----------------------------------------------------------------------------------------//
 
+void CodeLayouter::transformPredicatedCalls() {
+
+    Long2Node addr2node(mm);
+    NodeVector &nodes = cfg.search(SEARCH_POST_ORDER);
+    for(uint16 i=0; i<nodes.size(); i++) {            // iterate through CFG nodes
+        if(nodes[i]->isBb() == false) continue;       // ignore non BB nodes
+
+        BbNode *node  = (BbNode *)nodes[i];
+        if (node->getInsts().size() == 0) continue;
+        transformPredicatedCall(node, addr2node);
+    }
+    cfg.search(SEARCH_UNDEF_ORDER);
+}
+    
+//----------------------------------------------------------------------------------------//
+
+void CodeLayouter::transformPredicatedCall(BbNode *branchNode, Long2Node &addr2node) {
+
+    Inst *branchInst = branchNode->getInsts().back();    // inst to be branch
+    Edge *unwindEdge = getUnwindEdge(branchNode);        // get edge to unwind node
+    
+    if (branchInst->getOpnd(0)->getValue() == 0) return; // if not predicated - ignore
+    if (branchInst->isCall() == false)           return; // if not call - ignore
+    if (unwindEdge == NULL)                      return; // if there is no unwind edge - ignore
+
+    uint64     addr   = branchInst->getOpnd(3)->getValue();
+    OpndVector &opnds = branchInst->getOpnds();
+    
+    BbNode *callNode = NULL;
+    Inst   *callInst = NULL;
+    Edge   *callEdge = NULL;
+    
+    IPF_LOG << "    branch inst is " << IrPrinter::toString(branchInst);
+    
+    if (addr2node.find(addr) == addr2node.end()) {              // this call has not been moved in outstanding node
+        callNode = new(mm) BbNode(mm, cfg.getNextNodeId(), 0);  // create new node
+        callInst = new(mm) Inst(mm, INST_BRL13, CMPLT_BTYPE_CALL, cfg.getOpndManager()->getP0());
+        for (uint16 i=1; i<opnds.size(); i++) callInst->addOpnd(opnds[i]);
+        callNode->addInst(callInst);                            // create and add call instruction 
+        addr2node[addr] = callNode;                             // the addr is processed, next time we will use this node
+        unwindEdge->changeSource(callNode);                     // change unwind edge source
+        
+        IPF_LOG << "  created new node" << callNode->getId();
+        IPF_LOG << " call inst is " << IrPrinter::toString(callInst) << endl;
+    } else {                                                    // call on this addr has been already moved in outstanding node
+        callNode = addr2node[addr];                             // get the node
+        unwindEdge->remove();                                   // the node has already had edge on unwind node
+        IPF_LOG << "  use node" << callNode->getId() << endl;
+    }
+
+    // replace call with branch
+    for (uint16 i=opnds.size()-1; i>0; i--) opnds.pop_back();
+    NodeRef *branchTarget = cfg.getOpndManager()->newNodeRef(); 
+    branchInst->addOpnd(branchTarget);
+    branchInst->setInstCode(INST_BR);
+    branchInst->getComps().clear();
+    branchInst->addComp(CMPLT_BTYPE_COND);
+    branchInst->addComp(CMPLT_WH_SPNT);
+
+    // create branch edge
+    callEdge = new(mm) Edge(branchNode, callNode, 0.001, EDGE_BRANCH);
+    callEdge->insert();
+}
+
+//----------------------------------------------------------------------------------------//
+
+Edge* CodeLayouter::getUnwindEdge(Node *node) {
+
+    Edge       *unwindEdge = NULL;
+    EdgeVector &outEdges   = node->getOutEdges();
+    for (uint16 i=0; i<outEdges.size(); i++) {
+        Node *target = outEdges[i]->getTarget();
+        if (target->getNodeKind() == NODE_UNWIND) unwindEdge = outEdges[i];
+    }
+    return unwindEdge;
+}
+
+//----------------------------------------------------------------------------------------//
+
 void CodeLayouter::mergeNodes() {
     
     NodeVector& nodeVector = cfg.search(SEARCH_POST_ORDER);
-    NodeList    nodes(nodeVector.begin(), nodeVector.end());
+    NodeList    nodes(mm); 
+    nodes.insert(nodes.begin(), nodeVector.begin(), nodeVector.end());
 
     // try to merge current node with its successor
     for (NodeListIterator it=nodes.begin(); it!=nodes.end(); it++) {
@@ -76,13 +165,22 @@
         if (node == cfg.getEnterNode())     continue; // do not merge enter node
         
         BbNode *pred = (BbNode *)node;                // let's name current node "pred"
-        BbNode *succ = getSucc(pred);                 // check if it has mergable successor
-        if (succ == NULL)              continue;      // current node does not have mergable successor
+        BbNode *succ = getCandidate(pred);            // check if it has mergable successor
+        if (succ == NULL) {
+            IPF_LOG << "    node" << left << setw(3) << node->getId() << " does not have mergable successor" << endl;
+            continue;      // current node does not have mergable successor
+        }
+
         if (succ == cfg.getExitNode()) continue;      // do not merge exit node
-        if (checkSucc(succ) == false)  continue;      // succ can not be merged with pred
+
+        if (isMergable(pred, succ) == false) {
+            IPF_LOG << "    node" << left << setw(3) << node->getId() << " succ can not be merged with pred" << endl;
+            continue;      // succ can not be merged with pred
+        }
         
         merge(pred, succ);                            // merge pred and succ nodes
-        nodes.remove(succ);                           // remove succ node from current nodes list
+        nodes.remove(pred);                           // remove pred node from current nodes list
+        IPF_LOG << " node" << pred->getId() << " removed" << endl;
     }
     cfg.search(SEARCH_UNDEF_ORDER);                   // we could remove some nodes - old search is broken
 }
@@ -90,7 +188,7 @@
 //----------------------------------------------------------------------------------------//
 // if node has only one succ (not taking in account unwind) - return the succ
 
-BbNode* CodeLayouter::getSucc(BbNode *node) {
+BbNode* CodeLayouter::getCandidate(BbNode *node) {
     
     Node       *succ     = NULL;
     EdgeVector &outEdges = node->getOutEdges();
@@ -110,11 +208,17 @@
 //----------------------------------------------------------------------------------------//
 // check if succ can be merged with pred (has only one pred)
 
-bool CodeLayouter::checkSucc(BbNode *node) {
+bool CodeLayouter::isMergable(BbNode *pred, BbNode *succ) {
 
-    EdgeVector &inEdges = node->getInEdges();   // get succ in edges
-    if (inEdges.size() > 1) return false;       // succ has more than one pred - it can not be merged
-    return true;
+    EdgeVector &outEdges = succ->getOutEdges();                   // get out edges of succ
+    for (uint16 i=0; i<outEdges.size(); i++) {                    // iterate them
+        Node *target = outEdges[i]->getTarget();                  // get successor of current succ :)
+        if (target->getNodeKind() == NODE_DISPATCH) return false; // if it is dispatch node - do not merge
+    }
+
+    if (pred->getInsts().size() == 0)   return true; // empty pred can be merged with any succ
+    if (succ->getInEdges().size() == 1) return true; // succ has one pred - it can be merged
+    return false;
 }
     
 //----------------------------------------------------------------------------------------//
@@ -125,26 +229,21 @@
     // copy succ's insts in pred node
     InstVector &predInsts = pred->getInsts();
     InstVector &succInsts = succ->getInsts();
-    predInsts.insert(predInsts.end(), succInsts.begin(), succInsts.end());
+    succInsts.insert(succInsts.begin(), predInsts.begin(), predInsts.end());
     
     // remove pred out edges
-    EdgeVector predOutEdges = pred->getOutEdges();    // make copy of pred out edges vector
-    for (uint16 i=0; i<predOutEdges.size(); i++) {    // iterate edges
-        predOutEdges[i]->remove();                    // remove edge
+    EdgeVector &predOutEdges = pred->getOutEdges();
+    for (int16 i=predOutEdges.size()-1; i>=0; i--) {   // iterate edges
+        predOutEdges[i]->remove();                     // remove edge
     }
     
-    // redirect succ's out edges on pred
-    EdgeVector succOutEdges = succ->getOutEdges();    // make copy of succ out edges vector
-    for (uint16 i=0; i<succOutEdges.size(); i++) {    // iterate edges
-        succOutEdges[i]->changeSource(pred);          // redirect edge
+    // redirect pred in edges on succ
+    EdgeVector &predInEdges = pred->getInEdges(); 
+    for (int16 i=predInEdges.size()-1; i>=0; i--) {    // iterate edges
+        predInEdges[i]->changeTarget(succ);            // redirect edge
     }
     
-    IPF_LOG << "    node" << left << setw(3) << pred->getId() << " merged with node" << succ->getId() << endl;
-
-    if (LOG_ON) {
-        if (succ->getInEdges().size()  != 0) IPF_ERR << " size " << succ->getInEdges().size() << endl;
-        if (succ->getOutEdges().size() != 0) IPF_ERR << " size " << succ->getOutEdges().size() << endl;
-    }
+    IPF_LOG << "    node" << left << setw(3) << pred->getId() << " merged with node" << succ->getId();
 }
         
 //----------------------------------------------------------------------------------------//
@@ -168,6 +267,7 @@
     
     // remove useless unwind
     unwind->remove();
+    cfg.search(SEARCH_UNDEF_ORDER);
     IPF_LOG << endl << "    unwind node removed" << endl;
 }
 
@@ -176,7 +276,7 @@
 void CodeLayouter::makeChains() {
 
     // make edge list
-    EdgeVector edges;
+    EdgeVector edges(mm);
     NodeVector &nodes = cfg.search(SEARCH_POST_ORDER);               // get nodes vector
     for (uint16 i=0; i<nodes.size(); i++) {                          // iterate throgh it
         EdgeVector &outEdges = nodes[i]->getOutEdges();              // get out edges of current node
@@ -224,7 +324,7 @@
     }
 
     // there is no chain that can be merged with the edge 
-    Chain *newChain = new Chain();                              // create new chain
+    Chain *newChain = new(mm) Chain(mm);                        // create new chain
     pushBack(newChain, sourceNode);                             // push source back in new chain
     pushBack(newChain, targetNode);                             // push target back in new chain
     if (newChain->size() > 0) chains.push_back(newChain);       // insert new chain in chain list
@@ -261,7 +361,7 @@
     }
 
     // set layout successors for BbNodes
-    BbNode *pred = new(mm) BbNode(0, 0);            // current pred node (init with fake node)
+    BbNode *pred = new(mm) BbNode(mm, 0, 0);            // current pred node (init with fake node)
     BbNode *succ = NULL;                            // currend succ node
     for (ChainMapIterator it1=order.begin(); it1!=order.end(); it1++) {
         Chain *chain = it1->second;                 // current chain
@@ -370,13 +470,14 @@
     NodeRef *targetOpnd = (NodeRef *)branchInst->getOpnd(POS_BR_TARGET);
     targetOpnd->setNode(branchTargetNode);
 
-    IPF_LOG << " branch target is node" << branchTargetNode->getId() << endl;
+    IPF_LOG << " branch target is node" << branchTargetNode->getId();
     
     // if fall through node coinsides with layout successor - noting more to do
-    if (fallThroughNode == layoutSuccNode) return;
+    if (fallThroughNode == layoutSuccNode) { IPF_LOG << endl; return; }
     
-    // create new node for unconditional branch on through edge target node
-    BbNode *branchNode = new(mm) BbNode(cfg.getNextNodeId(), fallThroughNode->getExecCounter());
+    // create new node for unconditional branch on through edge target node 
+    // branch instruction will be inserted in fixUnconditionalBranch method
+    BbNode *branchNode = new(mm) BbNode(mm, cfg.getNextNodeId(), fallThroughNode->getExecCounter());
     branchNode->setLayoutSucc(layoutSuccNode); // layout successor of current node becomes layoute successor of new node
     node->setLayoutSucc(branchNode);           // the new node becomes layout successor of current node
 
@@ -436,7 +537,7 @@
     // Add branch to through edge target
     Opnd    *p0         = cfg.getOpndManager()->getP0();
     NodeRef *targetNode = cfg.getOpndManager()->newNodeRef(target);
-    node->addInst(new(mm) Inst(INST_BR, CMPLT_BTYPE_COND, p0, targetNode));
+    node->addInst(new(mm) Inst(mm, INST_BR, CMPLT_WH_SPTK, CMPLT_PH_FEW, p0, targetNode));
     
     throughEdge->setEdgeKind(EDGE_BRANCH);
     IPF_LOG << " branch on node" << target->getId() << " added" << endl;

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp Thu Nov  9 05:00:15 2006
@@ -14,10 +14,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+                                                                                                            
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -32,14 +31,14 @@
 // IpfMethodCodeSelector
 //========================================================================================//
 
-IpfMethodCodeSelector::IpfMethodCodeSelector(Cfg                  &cfg_,
-                                             CompilationInterface &compilationInterface_) : 
-    mm(cfg_.getMM()),
-    cfg(cfg_), 
-    compilationInterface(compilationInterface_) {
-
-    methodDesc   = NULL;
-//    codeProfiler = NULL;
+IpfMethodCodeSelector::IpfMethodCodeSelector(Cfg                  &cfg,
+                                             CompilationInterface &compilationInterface) : 
+    mm(cfg.getMM()),
+    cfg(cfg), 
+    compilationInterface(compilationInterface),
+    methodDesc(NULL),
+    opnds(mm),
+    nodes(mm) {
 }
 
 //----------------------------------------------------------------------------------------//
@@ -70,22 +69,16 @@
 
 //----------------------------------------------------------------------------------------//
 
-//void IpfMethodCodeSelector::setProfileInfo(CodeProfiler *codeProfiler_) {
-//    codeProfiler = codeProfiler_;
-//}
-
-//----------------------------------------------------------------------------------------//
-
 MethodDesc *IpfMethodCodeSelector::getMethodDesc() { return methodDesc; }
 
 //========================================================================================//
 // IpfVarCodeSelector
 //========================================================================================//
 
-IpfVarCodeSelector::IpfVarCodeSelector(Cfg &cfg_, OpndVector &opnds_) :
-    mm(cfg_.getMM()),
-    cfg(cfg_),
-    opnds(opnds_) {
+IpfVarCodeSelector::IpfVarCodeSelector(Cfg &cfg, OpndVector &opnds) :
+    mm(cfg.getMM()),
+    cfg(cfg),
+    opnds(opnds) {
 
     opndManager = cfg.getOpndManager();
 }
@@ -119,15 +112,15 @@
 // IpfCfgCodeSelector
 //========================================================================================//
 
-IpfCfgCodeSelector::IpfCfgCodeSelector(Cfg                  &cfg_, 
-                                       NodeVector           &nodes_, 
-                                       OpndVector           &opnds_,
-                                       CompilationInterface &compilationInterface_) : 
-    mm(cfg_.getMM()),
-    cfg(cfg_),
-    nodes(nodes_), 
-    opnds(opnds_),
-    compilationInterface(compilationInterface_) {
+IpfCfgCodeSelector::IpfCfgCodeSelector(Cfg                  &cfg, 
+                                       NodeVector           &nodes, 
+                                       OpndVector           &opnds,
+                                       CompilationInterface &compilationInterface) : 
+    mm(cfg.getMM()),
+    cfg(cfg),
+    nodes(nodes), 
+    opnds(opnds),
+    compilationInterface(compilationInterface) {
 }
 
 //----------------------------------------------------------------------------------------//
@@ -136,7 +129,7 @@
                                            uint32 numOutEdges, 
                                            double cnt) {
 
-    Node *node = new(mm) Node(cfg.getNextNodeId(), NODE_DISPATCH);
+    Node *node = new(mm) Node(mm, cfg.getNextNodeId(), (uint32) cnt, NODE_DISPATCH);
     nodes.push_back(node);
 
     IPF_LOG << endl << "    Generate Dispatch node" << node->getId() << endl;
@@ -145,13 +138,13 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32 IpfCfgCodeSelector::genBlock(uint32                numInEdges, 
-                                    uint32                numOutEdges, 
-                                    BlockKind            blockKind, 
-                                    BlockCodeSelector&    codeSelector, 
-                                    double                cnt) {
+uint32 IpfCfgCodeSelector::genBlock(uint32            numInEdges, 
+                                    uint32            numOutEdges, 
+                                    BlockKind         blockKind, 
+                                    BlockCodeSelector &codeSelector, 
+                                    double            cnt) {
 
-    BbNode *node = new(mm) BbNode(cfg.getNextNodeId(), (uint32)cnt);
+    BbNode *node = new(mm) BbNode(mm, cfg.getNextNodeId(), (uint32)cnt);
 
     nodes.push_back(node);
     if(blockKind == Prolog) cfg.setEnterNode(node);
@@ -169,7 +162,7 @@
                                           uint32 numOutEdges, 
                                           double cnt) {
 
-    Node *node = new(mm) Node(cfg.getNextNodeId(), NODE_UNWIND);
+    Node *node = new(mm) Node(mm, cfg.getNextNodeId(), (uint32) cnt, NODE_UNWIND);
     nodes.push_back(node);
 
     IPF_LOG << endl << "    Generate Unwind node" << node->getId() << endl;
@@ -180,7 +173,7 @@
 
 uint32 IpfCfgCodeSelector::genExitNode(uint32 numInEdges, double cnt) {
 
-    BbNode *node = new(mm) BbNode(cfg.getNextNodeId(), (uint32) cnt);
+    BbNode *node = new(mm) BbNode(mm, cfg.getNextNodeId(), (uint32) cnt);
     nodes.push_back(node);
     cfg.setExitNode(node);
 
@@ -198,7 +191,7 @@
     IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
 
     Edge *edge = new(mm) Edge(nodes[tailNodeId], nodes[headNodeId], prob, EDGE_THROUGH);
-    cfg.addEdge(edge);
+    edge->insert();
 }
 
 //----------------------------------------------------------------------------------------//
@@ -209,7 +202,7 @@
     IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
 
     Edge *edge = new(mm) Edge(nodes[tailNodeId], nodes[headNodeId], prob, EDGE_BRANCH);
-    cfg.addEdge(edge);
+    edge->insert();
 }
 
 //----------------------------------------------------------------------------------------//
@@ -220,7 +213,7 @@
     IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
 
     Edge *edge = new(mm) Edge(nodes[tailNodeId], nodes[headNodeId], prob, EDGE_THROUGH);
-    cfg.addEdge(edge);
+    edge->insert();
 }
 
 //----------------------------------------------------------------------------------------//
@@ -247,7 +240,7 @@
         << "; defaultTarget=" << defaultTarget << endl;
 
     defedge = new(mm) Edge(nodes[tailNodeId], nodes[defaultTarget], probs[defaultTarget], EDGE_BRANCH);
-    cfg.addEdge(defedge);
+    defedge->insert();
 
     for(i=0; i<numTargets; i++) {
         if(targets[i] == defaultTarget) {
@@ -259,8 +252,8 @@
         }
         IPF_LOG << "        case " << i << ": " << targets[i] << endl;
         edge = new(mm) Edge(nodes[tailNodeId], nodes[targets[i]], probs[i], EDGE_BRANCH);
+        edge->insert();
         switchConstant->addEdge(edge);
-        cfg.addEdge(edge);
     }
 
     if (!defadded) {
@@ -282,7 +275,8 @@
 
     IPF_LOG << "    Generate Exception     edge node" << tailNodeId;
     IPF_LOG << " -> node" << headNodeId << endl;
-    cfg.addEdge(new(mm) Edge(tailNode, headNode, prob, EDGE_DISPATCH));
+    Edge *edge = new(mm) Edge(tailNode, headNode, prob, EDGE_DISPATCH);
+    edge->insert();
 }
 
 //----------------------------------------------------------------------------------------//
@@ -300,7 +294,7 @@
     IPF_LOG << " -> node" << headNode->getId() << endl;
 
     ExceptionEdge *edge = new(mm) ExceptionEdge(tailNode, headNode, prob, exceptionType, priority);
-    cfg.addEdge(edge);
+    edge->insert();
 }
 
 //----------------------------------------------------------------------------------------//
@@ -316,7 +310,7 @@
     IPF_LOG << " -> node" << headNode->getId() << endl;
 
     Edge *edge = new(mm) Edge(tailNode, headNode, prob, EDGE_THROUGH);
-    cfg.addEdge(edge);
+    edge->insert();
 }
 
 //----------------------------------------------------------------------------------------//

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp Thu Nov  9 05:00:15 2006
@@ -14,10 +14,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+                                                                                                            
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -32,18 +31,18 @@
 // Constant
 //============================================================================//
 
-Constant::Constant(DataKind dataKind_) {
-    offset   = LOCATION_INVALID;
-    size     = 0;
-    dataKind = dataKind_;
+Constant::Constant(DataKind dataKind) :
+    address(NULL),
+    offset(LOCATION_INVALID),
+    size(0),
+    dataKind(dataKind) {
 }
 
 //============================================================================//
 // SwitchConstant
 //============================================================================//
 
-SwitchConstant::SwitchConstant() : Constant(DATA_U64) { 
-}
+SwitchConstant::SwitchConstant(MemoryManager &mm) : Constant(DATA_U64), edgeList(mm) {}
 
 //----------------------------------------------------------------------------//
 
@@ -77,44 +76,14 @@
 }
 
 //============================================================================//
-// Float Constants
-//============================================================================//
-
-FloatConstant::FloatConstant(float value_) : Constant(DATA_S) { 
-    value = value_; 
-    setSize(sizeof(float)); 
-}
-
-//----------------------------------------------------------------------------//
-
-void *FloatConstant::getData() {
-    return NULL;
-}
-
-//============================================================================//
-// Double Constants
-//============================================================================//
-
-DoubleConstant::DoubleConstant(double value_) : Constant(DATA_D) { 
-    value = value_; 
-    setSize(sizeof(double)); 
-}
-
-//----------------------------------------------------------------------------//
-
-void *DoubleConstant::getData() {
-    return NULL;
-}
-
-//============================================================================//
 // Opnd
 //============================================================================//
 
-Opnd::Opnd(uint32 id_, OpndKind opndKind_, DataKind dataKind_, int64 value_) :
-    id(id_), 
-    opndKind(opndKind_), 
-    dataKind(dataKind_), 
-    value(value_) { 
+Opnd::Opnd(uint32 id, OpndKind opndKind, DataKind dataKind, int64 value) :
+    id(id), 
+    opndKind(opndKind), 
+    dataKind(dataKind), 
+    value(value) { 
 }
 
 //----------------------------------------------------------------------------//
@@ -173,11 +142,12 @@
 // RegOpnd
 //============================================================================//
 
-RegOpnd::RegOpnd(uint32 id_, OpndKind opndKind_, DataKind dataKind_, int32 value_) : 
-    Opnd(id_, opndKind_, dataKind_, value_) { 
-    
-    spillCost     = 0;
-    crossCallSite = false;
+RegOpnd::RegOpnd(MemoryManager &mm, uint32 id, OpndKind opndKind, DataKind dataKind, int32 value) : 
+    Opnd(id, opndKind, dataKind, value),
+    spillCost(0),
+    depOpnds(mm),
+    crossCallSite(false),
+    coalesceCands(mm) { 
 }
 
 //----------------------------------------------------------------------------//

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h Thu Nov  9 05:00:15 2006
@@ -17,7 +17,6 @@
                                                                                                             
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -52,7 +51,7 @@
 
 class Constant {
 public:
-                 Constant(DataKind dataKind_);
+                 Constant(DataKind);
     void         setOffset(int32 offset_)    { offset = offset_; }
     int32        getOffset()                 { return offset; }
     void         setAddress(void *address_)  { address = address_; }
@@ -75,7 +74,7 @@
 
 class SwitchConstant : public Constant {
 public:
-               SwitchConstant();
+               SwitchConstant(MemoryManager&);
     void       addEdge(Edge*);
     Edge       *getEdge(int16 choice) { return edgeList[choice]; };
     uint16     getChoice(Edge*);
@@ -94,7 +93,7 @@
 
 class Int64Constant : public Constant {
 public:
-           Int64Constant(int64 value_) : Constant(DATA_I64) { value = value_; setSize(sizeof(int64)); };
+           Int64Constant(int64 value) : Constant(DATA_I64), value(value) { setSize(sizeof(int64)); }
     void   *getData() { return NULL; };
     int64  getValue() { return value; };
 
@@ -108,8 +107,8 @@
 
 class FloatConstant : public Constant {
 public:
-           FloatConstant(float value_);
-    void   *getData();
+           FloatConstant(float value) : Constant(DATA_S), value(value) { setSize(sizeof(float)); }
+    void   *getData() { return NULL; }
     double getValue() { return value; };
 
 protected:
@@ -122,8 +121,8 @@
 
 class DoubleConstant : public Constant {
 public:
-           DoubleConstant(double value_);
-    void   *getData();
+           DoubleConstant(double value) : Constant(DATA_D), value(value) { setSize(sizeof(double)); }
+    void   *getData() { return NULL; }
     double getValue() { return value; };
 
 protected:
@@ -152,9 +151,9 @@
     bool            isWritable();
     bool            isConstant();
     bool            isMem();
-
-    bool            isFoldableImm(int16 size) { return isFoldableImm(value, size); }
     bool            isImm(int);
+
+    bool            isFoldableImm(int16 size)       { return isFoldableImm(value, size); }
     static bool     isFoldableImm(int64 value, int16 size);
     
 protected:
@@ -170,7 +169,7 @@
 
 class RegOpnd : public Opnd {
 public:
-                RegOpnd(uint32, OpndKind, DataKind, int32=LOCATION_INVALID);
+                RegOpnd(MemoryManager&, uint32, OpndKind, DataKind, int32=LOCATION_INVALID);
     int64       getValue();
     void        setLocation(int32 value_)             { value = value_; }
     int32       getLocation()                         { return value; }
@@ -178,11 +177,13 @@
     void        incSpillCost(uint32 spillCost_)       { spillCost += spillCost_; }
     uint32      getSpillCost()                        { return spillCost; }
     RegOpndSet  &getDepOpnds()                        { return depOpnds; }
-    void        markRegBusy(uint16 regNum)            { busyRegMask[regNum] = true; }
-    RegBitSet   &getBusyRegMask()                     { return busyRegMask; }
+    void        insertDepOpnds(RegOpndSet &opnds)     { depOpnds.insert(opnds.begin(), opnds.end()); }
+    void        insertDepOpnd(RegOpnd*);
     void        setCrossCallSite(bool crossCallSite_) { crossCallSite = crossCallSite_; }
     bool        getCrossCallSite()                    { return crossCallSite; }
-    void        insertDepOpnd(RegOpnd *depOpnd);
+
+    Int2OpndMap &getCoalesceCands()                   { return coalesceCands; }
+    void        addCoalesceCand(uint32 execCnt, RegOpnd *opnd) { coalesceCands.insert(make_pair(execCnt, opnd)); }
 
     virtual     ~RegOpnd() {}
 
@@ -190,8 +191,8 @@
     // These fields are for register allocation algorithm
     uint32      spillCost;          // number of opnd uses
     RegOpndSet  depOpnds;           // opnds which can not be placed in the same reg with the opnd
-    RegBitSet   busyRegMask;        // registers that can not be used for allocation of this opnd
     bool        crossCallSite;      // opnd live range crosses call site
+    Int2OpndMap coalesceCands;      // 
 };
 
 //========================================================================================//
@@ -200,10 +201,8 @@
 
 class ConstantRef : public Opnd {
 public:
-    ConstantRef::ConstantRef(uint32 id_, Constant *constant_, DataKind dataKind_ = DATA_CONST_REF)
-    : Opnd(id_, OPND_IMM, dataKind_, LOCATION_INVALID) { 
-        constant = constant_; 
-    }
+    ConstantRef::ConstantRef(uint32 id, Constant *constant, DataKind dataKind = DATA_CONST_REF) :
+        Opnd(id, OPND_IMM, dataKind, LOCATION_INVALID), constant(constant) {}
 
     int64     getValue()     { return (int64)constant->getAddress(); }
     Constant  *getConstant() { return constant; }
@@ -218,8 +217,8 @@
 
 class NodeRef : public Opnd {
 public:
-    NodeRef(uint32 id_, BbNode *node_ = NULL) 
-    : Opnd(id_, OPND_IMM, DATA_NODE_REF, LOCATION_INVALID), node(node_) {}
+    NodeRef(uint32 id, BbNode *node = NULL) 
+    : Opnd(id, OPND_IMM, DATA_NODE_REF, LOCATION_INVALID), node(node) {}
     
     int64    getValue();
     void     setNode(BbNode *node_)  { node = node_; }
@@ -229,15 +228,14 @@
     BbNode   *node;
 };
 
-
 //========================================================================================//
 // MethodRef
 //========================================================================================//
 
 class MethodRef : public Opnd {
 public:
-    MethodRef(uint32 id_, MethodDesc *method_ = NULL) 
-    : Opnd(id_, OPND_IMM, DATA_METHOD_REF, LOCATION_INVALID), method(method_) {}
+    MethodRef(uint32 id, MethodDesc *method = NULL) 
+    : Opnd(id, OPND_IMM, DATA_METHOD_REF, LOCATION_INVALID), method(method) {}
     
     int64       getValue();
     void        setMethod(MethodDesc *method_) { method = method_; }
@@ -253,17 +251,17 @@
 
 class Inst {
 public:
-    Inst(InstCode instCode_, 
-         Opnd *op1=NULL, Opnd *op2=NULL, Opnd *op3=NULL, Opnd *op4=NULL, Opnd *op5=NULL, Opnd *op6=NULL);
+    Inst(MemoryManager&, InstCode, 
+         Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL);
 
-    Inst(InstCode instCode_, Completer comp1, 
-         Opnd *op1=NULL, Opnd *op2=NULL, Opnd *op3=NULL, Opnd *op4=NULL, Opnd *op5=NULL, Opnd *op6=NULL);
+    Inst(MemoryManager&, InstCode, Completer, 
+         Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL);
 
-    Inst(InstCode instCode_, Completer comp1, Completer comp2, 
-         Opnd *op1=NULL, Opnd *op2=NULL, Opnd *op3=NULL, Opnd *op4=NULL, Opnd *op5=NULL, Opnd *op6=NULL);
+    Inst(MemoryManager&, InstCode, Completer, Completer, 
+         Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL);
 
-    Inst(InstCode instCode_, Completer comp1, Completer comp2, Completer comp3,
-         Opnd *op1=NULL, Opnd *op2=NULL, Opnd *op3=NULL, Opnd *op4=NULL, Opnd *op5=NULL, Opnd *op6=NULL);
+    Inst(MemoryManager&, InstCode, Completer, Completer, Completer,
+         Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL, Opnd* =NULL);
 
     InstCode    getInstCode()                        { return instCode; }
     void        setInstCode(InstCode instCode_)      { instCode = instCode_; }
@@ -305,7 +303,7 @@
 
 class Edge {
 public:
-                Edge(Node *source_, Node *target_, double prob_, EdgeKind kind_);
+                Edge(Node*, Node*, double, EdgeKind);
     Node        *getSource()                { return source; }
     Node        *getTarget()                { return target; }
     double      getProb()                   { return prob; }
@@ -317,8 +315,6 @@
     void        changeSource(Node *source_);
     void        changeTarget(Node *target_);
     bool        isBackEdge();
-    void        connect(Node *target);
-    void        disconnect();
 
 protected:
     EdgeKind    edgeKind;
@@ -348,7 +344,7 @@
 
 class Node {
 public:
-                Node(uint32 id_, NodeKind kind_ = NODE_INVALID);
+                Node(MemoryManager&, uint32, uint32, NodeKind = NODE_INVALID);
 
     void        remove();
     void        addEdge(Edge *edge);
@@ -360,30 +356,29 @@
     Node        *getDispatchNode();
     void        mergeOutLiveSets(RegOpndSet &resultSet);
 
-    EdgeVector  &getInEdges()                    { return inEdges; }
-    EdgeVector  &getOutEdges()                   { return outEdges; }
-    void        setNodeKind(NodeKind kind_)      { nodeKind = kind_; }
-    NodeKind    getNodeKind()                    { return nodeKind; }
-    void        setId(uint32 id_)                { id = id_; }
-    uint32      getId()                          { return id; }
-    void        setLiveSet(RegOpndSet& liveSet_) { liveSet = liveSet_; }
-    RegOpndSet  &getLiveSet()                    { return liveSet; }
-    void        clearLiveSet()                   { liveSet.clear(); }
-    void        setLoopHeader(Node *loopHeader_) { loopHeader = loopHeader_; }
-    Node        *getLoopHeader()                 { return loopHeader; }
-    bool        isBb()                           { return nodeKind == NODE_BB; }
-    void        addInEdge(Edge *edge);
-    void        removeInEdge(Edge *edge);
-    void        printEdges(ostream& out);
+    void        setExecCounter(uint32 execCounter_) { execCounter = execCounter_; }
+    uint32      getExecCounter()                    { return execCounter; }
+    EdgeVector  &getInEdges()                       { return inEdges; }
+    EdgeVector  &getOutEdges()                      { return outEdges; }
+    void        setNodeKind(NodeKind kind_)         { nodeKind = kind_; }
+    NodeKind    getNodeKind()                       { return nodeKind; }
+    void        setId(uint32 id_)                   { id = id_; }
+    uint32      getId()                             { return id; }
+    void        setLiveSet(RegOpndSet& liveSet_)    { liveSet = liveSet_; }
+    RegOpndSet  &getLiveSet()                       { return liveSet; }
+    void        clearLiveSet()                      { liveSet.clear(); }
+    void        setLoopHeader(Node *loopHeader_)    { loopHeader = loopHeader_; }
+    Node        *getLoopHeader()                    { return loopHeader; }
+    bool        isBb()                              { return nodeKind == NODE_BB; }
     
 protected:
     uint32      id;               // node unique Id
+    uint32      execCounter;      // profile info (how many times the node executes)
     NodeKind    nodeKind;         // 
     EdgeVector  inEdges;          // in edges list
     EdgeVector  outEdges;         // out edges list
     Node        *loopHeader;      // header of loop containing this node, if NULL - node is not in loop
     RegOpndSet  liveSet;          // set of opnds alive on node enter
-    void        printEdges(ostream& out, EdgeVector& edges, bool head);
 };
 
 //========================================================================================//
@@ -392,23 +387,20 @@
 
 class BbNode : public Node {
 public:
-                BbNode(uint32 id_, uint32 execCounter_);
-    void        addInst(Inst *inst); 
+                BbNode(MemoryManager&, uint32, uint32);
+    void        addInst(Inst *inst)                 { insts.push_back(inst); }
     void        removeInst(Inst *inst)              { insts.erase(find(insts.begin(),insts.end(),inst)); } 
     InstVector  &getInsts()                         { return insts; }
     void        setAddress(uint64 address_)         { address = address_; }
     uint64      getAddress()                        { return address; }
     void        setLayoutSucc(BbNode *layoutSucc_)  { layoutSucc = layoutSucc_; }
     BbNode      *getLayoutSucc()                    { return layoutSucc; }
-    void        setExecCounter(uint32 execCounter_) { execCounter = execCounter_; }
-    uint32      getExecCounter()                    { return execCounter; }
     uint64      getInstAddr(Inst *inst)             { return ((uint64)address + inst->getAddr()); }
 
 protected:
     InstVector  insts;
     BbNode      *layoutSucc;
     uint64      address;
-    uint32      execCounter;
 };
 
 //========================================================================================//

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfgVerifier.h
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfgVerifier.h?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfgVerifier.h (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfgVerifier.h Thu Nov  9 05:00:15 2006
@@ -14,10 +14,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+                                                                                                            
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -34,8 +33,6 @@
 //========================================================================================//
 // IpfCfgVerifier
 //========================================================================================//
-
-    extern void ipfCfgVerifier(Cfg& cfg_);
 
 } // IPF
 } // Jitrino

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeGenerator.h
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeGenerator.h?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeGenerator.h (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeGenerator.h Thu Nov  9 05:00:15 2006
@@ -14,10 +14,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+                                                                                                            
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -38,7 +37,7 @@
 public:
                          CodeGenerator(MemoryManager&, CompilationInterface&);
     bool                 genCode(MethodCodeSelector&);
-    void                 genCode(SessionAction* s, MethodCodeSelector& m) {} // TODO
+//    void                 genCode(SessionAction* s, MethodCodeSelector& m) {} // TODO
     virtual              ~CodeGenerator() {}
 
 protected:

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h Thu Nov  9 05:00:15 2006
@@ -17,7 +17,6 @@
                                                                                                             
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -29,20 +28,26 @@
 namespace Jitrino {
 namespace IPF {
 
+typedef StlMap <uint64, BbNode*> Long2Node;
+
 //========================================================================================//
 // CodeLayouter
 //========================================================================================//
 
 class CodeLayouter {
 public:
-                  CodeLayouter(Cfg &cfg_);
+                  CodeLayouter(Cfg&);
     void          layout();
 
 protected:
+    void          transformPredicatedCalls();
+    void          transformPredicatedCall(BbNode*, Long2Node&);
+    Edge*         getUnwindEdge(Node*);
+
     // merge sequential nodes
     void          mergeNodes();
-    BbNode*       getSucc(BbNode*);
-    bool          checkSucc(BbNode*);
+    BbNode*       getCandidate(BbNode*);
+    bool          isMergable(BbNode*, BbNode*);
     void          merge(BbNode*, BbNode*);
     void          checkUnwind();
 

Modified: incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h?view=diff&rev=472885&r1=472884&r2=472885
==============================================================================
--- incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h (original)
+++ incubator/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h Thu Nov  9 05:00:15 2006
@@ -14,10 +14,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+                                                                                                            
 /**
  * @author Intel, Konstantin M. Anisimov, Igor V. Chebykin
- * @version $Revision$
  *
  */
 
@@ -26,7 +25,6 @@
 
 #include "CodeGenIntfc.h"
 #include "VMInterface.h"
-//#include "Profiler.h"
 #include "IpfCfg.h"
 #include "IpfOpndManager.h"
 
@@ -48,7 +46,7 @@
     void                 genVars(uint32, VarCodeSelector&);
     void                 setMethodDesc(MethodDesc*);
     void                 genCFG(uint32, CFGCodeSelector&, bool);
-//    void                 setProfileInfo(CodeProfiler*);
+    void                 setProfileInfo(CodeProfiler*) {}
     virtual              ~IpfMethodCodeSelector() {}
 
 protected:
@@ -56,7 +54,6 @@
     Cfg                  &cfg;
     CompilationInterface &compilationInterface;
     MethodDesc           *methodDesc;
-//    CodeProfiler         *codeProfiler;
     OpndVector           opnds;
     NodeVector           nodes;
 };
@@ -111,9 +108,6 @@
 //========================================================================================//
 // IpfInstCodeSelector
 //========================================================================================//
-//Jitrino::CG_OpndHandle* Jitrino::InstructionCallback::scaledDiffRef(Jitrino::CG_OpndHandle*, Jitrino::CG_OpndHandle*)
-//virtual Jitrino::CG_OpndHandle* Jitrino::InstructionCallback::tau_ldIntfTableAddr(Jitrino::Type*, Jitrino::CG_OpndHandle*, Jitrino::NamedType*)
-//virtual Jitrino::CG_OpndHandle* Jitrino::InstructionCallback::callvmhelper(unsigned int, Jitrino::CG_OpndHandle**, Jitrino::Type*, Jitrino::VMHelperCallOp::Id, Jitrino::InlineInfo*)
 
 class IpfInstCodeSelector : public InstructionCallback {
 
@@ -213,7 +207,7 @@
     CG_OpndHandle *tau_ldVirtFunAddr(Type*, CG_OpndHandle*, MethodDesc*, CG_OpndHandle*);
     CG_OpndHandle *tau_ldVTableAddr(Type*, CG_OpndHandle*, CG_OpndHandle*);
     CG_OpndHandle *getVTableAddr(Type*, ObjectType*);
-    CG_OpndHandle *tau_ldIntfTableAddr(Type*, CG_OpndHandle*, NamedType*);
+    CG_OpndHandle *tau_ldIntfTableAddr(Type*, CG_OpndHandle*, NamedType*, CG_OpndHandle*);
     CG_OpndHandle *ldFieldAddr(Type*, CG_OpndHandle*, FieldDesc*);
     CG_OpndHandle *ldStaticAddr(Type*, FieldDesc*);
 
@@ -223,7 +217,7 @@
     CG_OpndHandle *newArray(ArrayType*, CG_OpndHandle*);
     CG_OpndHandle *newMultiArray(ArrayType*, uint32, CG_OpndHandle**);
     CG_OpndHandle *ldElemBaseAddr(CG_OpndHandle*);
-    CG_OpndHandle *addElemIndex(Type*, CG_OpndHandle*, CG_OpndHandle*);
+    CG_OpndHandle *addElemIndex(Type *, CG_OpndHandle *, CG_OpndHandle *);
     CG_OpndHandle *tau_arrayLen(Type*, ArrayType*, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
 
     //---------------------------------------------------------------------------//
@@ -304,7 +298,7 @@
     void          tau_stField(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stField") }
     void          tau_stElem(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stElem") }
     void          optimisticBalancedMonitorExit(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("optimisticBalancedMonitorExit") }
-    CG_OpndHandle *callvmhelper(uint32, CG_OpndHandle**, Type*, VMHelperCallOp::Id, InlineInfo* = NULL) { NOT_IMPLEMENTED_C("callvmhelper") }
+    CG_OpndHandle *callvmhelper(uint32, CG_OpndHandle**, Type *, VMHelperCallOp::Id) { NOT_IMPLEMENTED_C("callvmhelper") }
 
     //---------------------------------------------------------------------------//
     // convertors from HLO to IPF::CG types
@@ -329,6 +323,7 @@
 protected:
 
     // Create new inst and add it in current node
+    void      addInst(Inst* inst);
     Inst&     addNewInst(InstCode instCode_, 
                   CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
                   CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
@@ -338,10 +333,13 @@
     Inst&     addNewInst(InstCode instCode_, Completer comp1, Completer comp2,
                   CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
                   CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
+    Inst&     addNewInst(InstCode instCode_, Completer comp1, Completer comp2, Completer comp3,
+                  CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
+                  CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
         
     // CG helper methods
-    void      directCall(uint32, Opnd**, RegOpnd*, Opnd*, RegOpnd*);
-    void      indirectCall(uint32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*);
+    void      directCall(uint32, Opnd**, RegOpnd*, Opnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
+    void      indirectCall(uint32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
     void      makeCallArgs(uint32, Opnd**, Inst*, RegOpnd*);
     RegOpnd   *makeConvOpnd(RegOpnd*);
     void      makeRetVal(RegOpnd*, RegOpnd*, RegOpnd*);



Mime
View raw message