Changeset 4643

Timestamp:

Jul 6, 2015, 5:56:51 PM (4 years ago)

Author:

nmedfort

Message:

Simplified While structure. Next nodes are in the AST again but are treated like independent variable assignments; they're only associated with their original Assign by including them in the While instruction.

Location:

icGREP/icgrep-devel/icgrep

Files:

• pablo/codegenstate.cpp (modified) (1 diff)
• pablo/pablo_compiler.cpp (modified) (6 diffs)
• pablo/pablo_compiler.h (modified) (1 diff)
• pablo/pe_next.h (modified) (2 diffs)
• pablo/printer_pablos.cpp (modified) (1 diff)
• re/re_compiler.cpp (modified) (3 diffs)

icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

@@ -94 +94 @@
 Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
     assert (assign && expr);
-    assert (assign->getName());
-    std::string name = assign->getName()->to_string() + "'";
-    return new Next(assign, createAssign(std::move(name), expr), this);
+    return insertAtInsertionPoint(new Next(assign, expr, this));
 }
 

icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

@@ -415 +415 @@
 }
 
-void PabloCompiler::compileBlock(PabloBlock & blk) {
-    mPabloBlock = & blk;
-    for (const Statement * statement : blk) {
+void PabloCompiler::compileBlock(PabloBlock & block) {
+    mPabloBlock = █
+    for (const Statement * statement : block) {
         compileStatement(statement);
     }
-    mPabloBlock = blk.getParent();
+    mPabloBlock = block.getParent();
 }
 
@@ -634 +634 @@
 
 
-void PabloCompiler::compileStatement(const Statement * stmt)
-{
+void PabloCompiler::compileStatement(const Statement * stmt) {
+    Value * expr = nullptr;
     if (const Assign * assign = dyn_cast<const Assign>(stmt)) {
-        Value * expr = compileExpression(assign->getExpr());
+        expr = compileExpression(assign->getExpr());
         if (DumpTrace) {
             genPrintRegister(assign->getName()->to_string(), expr);
         }
-        mMarkerMap[assign] = expr;
         if (LLVM_UNLIKELY(assign->isOutputAssignment())) {
             SetOutputValue(expr, assign->getOutputIndex());
@@ -647 +646 @@
     }
     else if (const Next * next = dyn_cast<const Next>(stmt)) {
-        Value * expr = compileExpression(next->getExpr());
+        expr = compileExpression(next->getExpr());
         if (TraceNext) {
-            genPrintRegister(next->getInitial()->getName()->to_string(), expr);
-        }
-        mMarkerMap[next->getInitial()] = expr;
-    }
-    else if (const If * ifStatement = dyn_cast<const If>(stmt))
-    {
+            genPrintRegister(next->getName()->to_string(), expr);
+        }
+    }
+    else if (const If * ifStatement = dyn_cast<const If>(stmt)) {
         compileIf(ifStatement);
-    }
-    else if (const While * whileStatement = dyn_cast<const While>(stmt))
-    {
+        return;
+    }
+    else if (const While * whileStatement = dyn_cast<const While>(stmt)) {
         compileWhile(whileStatement);
+        return;
     }
     else if (const Call* call = dyn_cast<Call>(stmt)) {
         //Call the callee once and store the result in the marker map.
-        auto mi = mMarkerMap.find(call);
-        if (mi == mMarkerMap.end()) {
-            auto ci = mCalleeMap.find(call->getCallee());
-            if (LLVM_UNLIKELY(ci == mCalleeMap.end())) {
-                throw std::runtime_error("Unexpected error locating static function for \"" + call->getCallee()->to_string() + "\"");
-            }
-            mi = mMarkerMap.insert(std::make_pair(call, mBuilder->CreateCall(ci->second, mBasisBitsAddr))).first;
-        }
-        // return mi->second;
+        if (mMarkerMap.count(call) != 0) {
+            return;
+        }
+        auto ci = mCalleeMap.find(call->getCallee());
+        if (LLVM_UNLIKELY(ci == mCalleeMap.end())) {
+            throw std::runtime_error("Unexpected error locating static function for \"" + call->getCallee()->to_string() + "\"");
+        }
+        expr = mBuilder->CreateCall(ci->second, mBasisBitsAddr);
     }
     else if (const And * pablo_and = dyn_cast<And>(stmt)) {
-        Value * expr = mBuilder->CreateAnd(compileExpression(pablo_and->getExpr1()), compileExpression(pablo_and->getExpr2()), "and");
+        expr = mBuilder->CreateAnd(compileExpression(pablo_and->getExpr1()), compileExpression(pablo_and->getExpr2()), "and");
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[pablo_and] = expr;
-        // return expr;
     }
     else if (const Or * pablo_or = dyn_cast<Or>(stmt)) {
-        Value * expr = mBuilder->CreateOr(compileExpression(pablo_or->getExpr1()), compileExpression(pablo_or->getExpr2()), "or");
+        expr = mBuilder->CreateOr(compileExpression(pablo_or->getExpr1()), compileExpression(pablo_or->getExpr2()), "or");
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[pablo_or] = expr;
-        // return expr;
     }
     else if (const Xor * pablo_xor = dyn_cast<Xor>(stmt)) {
-        Value * expr = mBuilder->CreateXor(compileExpression(pablo_xor->getExpr1()), compileExpression(pablo_xor->getExpr2()), "xor");
-        mMarkerMap[pablo_xor] = expr;
-        // return expr;
+        expr = mBuilder->CreateXor(compileExpression(pablo_xor->getExpr1()), compileExpression(pablo_xor->getExpr2()), "xor");
     }
     else if (const Sel * sel = dyn_cast<Sel>(stmt)) {
@@ -698 +689 @@
         Value* ifTrue = mBuilder->CreateAnd(ifMask, compileExpression(sel->getTrueExpr()));
         Value* ifFalse = mBuilder->CreateAnd(genNot(ifMask), compileExpression(sel->getFalseExpr()));
-        Value * expr = mBuilder->CreateOr(ifTrue, ifFalse);
+        expr = mBuilder->CreateOr(ifTrue, ifFalse);
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[sel] = expr;
-        // return expr;
     }
     else if (const Not * pablo_not = dyn_cast<Not>(stmt)) {
-        Value * expr = genNot(compileExpression(pablo_not->getExpr()));
+        expr = genNot(compileExpression(pablo_not->getExpr()));
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[pablo_not] = expr;
-        // return expr;
     }
     else if (const Advance * adv = dyn_cast<Advance>(stmt)) {
-        Value* strm_value = compileExpression(adv->getExpr());
+        Value* value = compileExpression(adv->getExpr());
         int shift = adv->getAdvanceAmount();
         unsigned advance_index = adv->getLocalAdvanceIndex();
-        Value * expr = genAdvanceWithCarry(strm_value, shift, advance_index);
+        expr = genAdvanceWithCarry(value, shift, advance_index);
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[adv] = expr;
-        // return expr;
-    }
-    else if (const MatchStar * mstar = dyn_cast<MatchStar>(stmt))
-    {
+    }
+    else if (const MatchStar * mstar = dyn_cast<MatchStar>(stmt)) {
         Value * marker = compileExpression(mstar->getMarker());
         Value * cc = compileExpression(mstar->getCharClass());
         Value * marker_and_cc = mBuilder->CreateAnd(marker, cc);
         unsigned carry_index = mstar->getLocalCarryIndex();
-        Value * expr = mBuilder->CreateOr(mBuilder->CreateXor(genAddWithCarry(marker_and_cc, cc, carry_index), cc), marker, "matchstar");
+        expr = mBuilder->CreateOr(mBuilder->CreateXor(genAddWithCarry(marker_and_cc, cc, carry_index), cc), marker, "matchstar");
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[mstar] = expr;
-        // return expr;
-    }
-    else if (const ScanThru * sthru = dyn_cast<ScanThru>(stmt))
-    {
+    }
+    else if (const ScanThru * sthru = dyn_cast<ScanThru>(stmt)) {
         Value * marker_expr = compileExpression(sthru->getScanFrom());
         Value * cc_expr = compileExpression(sthru->getScanThru());
         unsigned carry_index = sthru->getLocalCarryIndex();
-        Value * expr = mBuilder->CreateAnd(genAddWithCarry(marker_expr, cc_expr, carry_index), genNot(cc_expr), "scanthru");
+        expr = mBuilder->CreateAnd(genAddWithCarry(marker_expr, cc_expr, carry_index), genNot(cc_expr), "scanthru");
         if (DumpTrace) {
             genPrintRegister(stmt->getName()->to_string(), expr);
         }
-        mMarkerMap[sthru] = expr;
-        // return expr;
     }
     else {
@@ -754 +733 @@
         throw std::runtime_error("Unrecognized Pablo Statement! can't compile.");
     }
+    mMarkerMap[stmt] = expr;
 }
 
@@ -763 +743 @@
         return mZeroInitializer;
     }
-    else if (const Next * next = dyn_cast<Next>(expr)) {
-        expr = next->getInitial();
-    }
     auto f = mMarkerMap.find(expr);
-    if (f == mMarkerMap.end()) {
+    if (LLVM_UNLIKELY(f == mMarkerMap.end())) {
         std::string o;
         llvm::raw_string_ostream str(o);

icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.h

@@ -108 +108 @@
 
     void genPrintRegister(std::string regName, Value * bitblockValue);
-    void compileBlock(PabloBlock & blk);
+    void compileBlock(PabloBlock & block);
     void compileStatement(const Statement * stmt);
     void compileIf(const If * ifStmt);

icGREP/icgrep-devel/icgrep/pablo/pe_next.h

@@ -8 +8 @@
 
 namespace pablo {
-
-class Assign;
 
 class Next : public Statement {
@@ -21 +19 @@
     }
     inline const Assign * getInitial() const {
-        return cast<const Assign>(getOperand(0));
+        return cast<const Assign>(getOperand(1));
     }
     inline PabloAST * getExpr() const {
-        return getOperand(1);
+        return getOperand(0);
     }
     virtual ~Next() {}
 protected:
-    Next(PabloAST * initial, PabloAST * expr, PabloBlock * parent)
-    : Statement(ClassTypeId::Next, {cast<Assign>(initial), cast<Assign>(expr)}, cast<Assign>(initial)->getName(), parent) {
+    explicit Next(PabloAST * initial, PabloAST * expr, PabloBlock * parent)
+    : Statement(ClassTypeId::Next, {expr, cast<Assign>(initial)}, cast<Assign>(initial)->getName(), parent) {
         this->addUser(initial);
     }

icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

@@ -75 +75 @@
     }
     else if (const Next * next = dyn_cast<const Next>(stmt)) {        
-        strm << "Next(" << next->getName() << ") = ";
+        strm << next->getName() << "' = ";
         print(next->getExpr(), strm);
     }

icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

@@ -513 +513 @@
         mLoopVariants.push_back(nextPending);
         mLoopVariants.push_back(nextStarAccum);
-        mWhileTest = pb.createOr(mWhileTest, nextPending->getExpr());
+        mWhileTest = pb.createOr(mWhileTest, nextPending);
         mStarDepth--;
         
-        return makeMarker(InitialPostPositionByte, pb.createAssign("unbounded", pb.createOr(base, nextStarAccum->getExpr())));
+        return makeMarker(InitialPostPositionByte, pb.createAssign("unbounded", pb.createOr(base, nextStarAccum)));
     }    
     else {
@@ -530 +530 @@
         Next * nextWhilePending = wb.createNext(whilePending, wb.createAnd(loopComputation, wb.createNot(whileAccum)));
         Next * nextWhileAccum = wb.createNext(whileAccum, wb.createOr(loopComputation, whileAccum));
-        Next * nextWhileTest = wb.createNext(whileTest, wb.createOr(mWhileTest, nextWhilePending->getExpr()));
+        Next * nextWhileTest = wb.createNext(whileTest, wb.createOr(mWhileTest, nextWhilePending));
         mLoopVariants.push_back(nextWhilePending);
         mLoopVariants.push_back(nextWhileAccum);
@@ -537 +537 @@
         mStarDepth--;
         mLoopVariants.clear();
-        return makeMarker(InitialPostPositionByte, pb.createAssign("unbounded", nextWhileAccum->getExpr()));
+        return makeMarker(InitialPostPositionByte, pb.createAssign("unbounded", nextWhileAccum));
     }    
 } // end of namespace re