Changeset 2446


Ignore:
Timestamp:
Oct 12, 2012, 6:53:40 PM (7 years ago)
Author:
ksherdy
Message:

Added If translation logic. First pass.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/visitors/CarryIntro.java

    r2441 r2446  
    11package compiler.visitors;
    22
     3import tokens.LextantToken;
     4import lexicalAnalyzer.Lextant;
    35import compiler.ast.Accessors;
    46import compiler.ast.Generators;
     7import compiler.codeGeneration.CarryQ;
    58import compiler.lang.idisa.SIMD;
    69import compiler.lang.pablo.builtins.Builtins;
     
    1417public class CarryIntro {
    1518               
    16         private ASTNode functionDefNode; // ASTNode     
     19        private ASTNode ASTTree; // FunctionDefNode     
    1720       
    1821    //    def __init__(self, carryvar="carryQ", carryin = "_ci", carryout = "_co"):
     
    2326    public CarryIntro(ASTNode node) {
    2427        assert node instanceof FunctionDefNode;
    25         this.functionDefNode = node;
     28        this.ASTTree = node;
    2629    }
    27 
    2830
    2931    /** Transforms FunctionDefNode AST sub-trees w.r.t. ci/co modes.
     
    3436     */ 
    3537    public void transform(boolean ci, boolean co) { // ci - carry in xformation mode, co - carry out mode xformation mode
    36        
    37                 CarryCounter carryCounter = new CarryCounter(this.functionDefNode);
    38                 int carry_count = carryCounter.count();
    39                 System.out.printf("Carry Count: %d", carry_count);
    40         if (carry_count > 0) {
     38                       
     39        if ((new CarryCounter(this.ASTTree)).count() > 0) {
    4140                CarryIntroVisitor visitor = new CarryIntroVisitor(ci, co);
    42                 functionDefNode.accept(visitor);
     41                ASTTree.accept(visitor);
    4342        }
    4443    }                   
     
    4645        private class CarryIntroVisitor extends VoidVisitor.Default {
    4746
    48             private final String carryPackage = "carryQ";
    4947                private final String ciSuffix = "_ci";
    5048                private final String coSuffix = "_co";
    51                 private String [] pendindCarryQName = {this.carryPackage, "get_carry_in"};
    52                 private String [] pending64QName = {this.carryPackage, "get_pending64"};
     49                private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETCARRYIN.cName()};
     50                private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETPENDING64.cName()};
    5351               
    5452                private boolean ciMode;
     
    5755                private int currentCarry;
    5856                private int currentAdvN;
     57                private int lastStmtCarries;
    5958               
    6059                CarryIntroVisitor(boolean ciMode, boolean coMode) {
     60                        this.ciMode = ciMode;
     61                        this.coMode = coMode;
    6162                        this.currentCarry = 0;
    6263                        this.currentAdvN = 0;
     64                        this.lastStmtCarries = 0;
     65                }
     66
     67                void setCiMode(boolean ciMode) {
    6368                        this.ciMode = ciMode;
     69                }
     70               
     71                void setCoMode(boolean coMode) {
    6472                        this.coMode = coMode;
    6573                }
    66 
     74               
    6775                //              def xfrm_fndef(self, fndef):
    6876                //          self.current_carry = 0
     
    7482                //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    7583                //          return fndef
     84                public void visitLeave(FunctionDefNode node) {
     85                        this.currentCarry = 0;
     86                        this.currentAdvN = 0;
     87                        this.lastStmtCarries = 0;                       
     88                }               
     89               
    7690                public void visitLeave(FunctionInvocationNode node) {
    7791                       
     
    91105//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    92106                        if(ciMode) {
    93                                 carryCall = Generators.makeFunctionInvocationNode(this.pendindCarryQName, node.getToken());
     107                                carryCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETCARRYIN.cName()}, node.getToken());
    94108                                carryCall.appendChild(currentCarry);
    95109                               
    96                                 advNCall = Generators.makeFunctionInvocationNode(this.pending64QName, node.getToken());
     110                                advNCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.GETPENDING64.cName()}, node.getToken());
    97111                                advNCall.appendChild(currentAdvN);
    98112                               
     
    109123        //                    return c                 
    110124                        if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCE.pabloName(), Carry1.ADVANCE.argCount())) {             
    111                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.ADVANCE.cName(), carryCall, currentCarry);
     125                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.ADVANCE.cName(), carryCall, currentCarry);
    112126                                this.currentCarry += 1;
    113127                        }
     
    120134        //            return c         
    121135                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTHRU.pabloName(), Carry1.SCANTHRU.argCount())) {                               
    122                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SCANTHRU.cName(), carryCall, currentCarry);
     136                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SCANTHRU.cName(), carryCall, currentCarry);
    123137                                this.currentCarry += 1;
    124138                        }
     
    131145        //            return c         
    132146                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCETHENSCANTHRU.pabloName(), Carry1.ADVANCETHENSCANTHRU.argCount())) {
    133                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.ADVANCETHENSCANTHRU.cName(), carryCall, currentCarry);
     147                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.ADVANCETHENSCANTHRU.cName(), carryCall, currentCarry);
    134148                                this.currentCarry += 1;
    135149                        }               
     
    142156        //            return c         
    143157                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SPANUPTO.pabloName(), Carry1.SPANUPTO.argCount())) {
    144                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SPANUPTO.cName(), carryCall, currentCarry);                               
     158                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SPANUPTO.cName(), carryCall, currentCarry);                             
    145159                                this.currentCarry += 1;
    146160                        }               
     
    155169        //            return c
    156170                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCETHENSCANTO.pabloName(), Carry1.ADVANCETHENSCANTO.argCount())) {
    157                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.ADVANCETHENSCANTO.cName(), carryCall, currentCarry);
     171                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.ADVANCETHENSCANTO.cName(), carryCall, currentCarry);
    158172                                this.currentCarry += 1;
    159173                        }               
     
    169183       
    170184                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.INCLUSIVESPAN.pabloName(), Carry1.INCLUSIVESPAN.argCount())) {
    171                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.INCLUSIVESPAN.cName(), carryCall, currentCarry);
     185                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.INCLUSIVESPAN.cName(), carryCall, currentCarry);
    172186                                this.currentCarry += 1;
    173187                        }                               
     
    183197       
    184198                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.EXCLUSIVESPAN.pabloName(), Carry1.EXCLUSIVESPAN.argCount())) {
    185                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.EXCLUSIVESPAN.cName(), carryCall, currentCarry);
     199                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.EXCLUSIVESPAN.cName(), carryCall, currentCarry);
    186200                                this.currentCarry += 1;
    187201                        }                                               
     
    199213       
    200214                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTO.pabloName(), Carry1.SCANTO.argCount())) {
    201                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SCANTO.cName(), carryCall, currentCarry);
     215                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SCANTO.cName(), carryCall, currentCarry);
    202216                                this.currentCarry += 1;
    203217                        }                                                               
     
    212226       
    213227                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTOFIRST.pabloName(), Carry1.SCANTOFIRST.argCount())) {
    214                                 replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SCANTOFIRST.cName(), carryCall, currentCarry);
     228                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, Carry1.SCANTOFIRST.cName(), carryCall, currentCarry);
    215229                                this.currentCarry += 1;
    216230                        }                                                                               
     
    223237        //            return c
    224238                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, CarryN.ADVANCE32.pabloName(), CarryN.ADVANCE32.argCount())) {
    225                                 replaceFunctionInvocationNode(node, this.carryPackage, CarryN.ADVANCE32.cName(), carryCall, currentAdvN);
     239                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, CarryN.ADVANCE32.cName(), carryCall, currentAdvN);
    226240                                this.currentAdvN += 1;
    227241                        }                       
     
    234248        //            return c         
    235249                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, CarryN.ADVANCE.pabloName(), CarryN.ADVANCE.argCount())) {
    236                                 replaceFunctionInvocationNode(node, this.carryPackage, CarryN.ADVANCE.cName(), carryCall, currentAdvN);                                 
     250                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, CarryN.ADVANCE.cName(), carryCall, currentAdvN);                                       
    237251                                this.currentAdvN += 1;                 
    238252                        }                                       
     
    278292                        }                                       
    279293       
     294//                      Deprecated - New bitblock iterators replace StreamScan.
     295//                     
    280296//              elif is_BuiltIn_Call(callnode, 'StreamScan', 2):
    281297//                      rtn = "StreamScan"           
     
    296312//                              replacementNode.appendChild(arg2);
    297313//                      }
     314
     315//                  else:
     316//                    #dump_Call(callnode)
     317//                    return callnode
    298318                        else {
    299319                                // do nothing
     
    302322                }
    303323
     324                //def visit_If(self, ifNode):
     325                //carry_base = self.current_carry
     326                //carries = CarryCounter().count(ifNode)
     327                //assert adv_nCounter().count(ifNode) == 0, "Advance(x,n) within if: illegal\n"
     328                //self.generic_visit(ifNode)
     329                //if carries == 0 or self.carryin == "": return ifNode
     330                //#CARRYSET
     331                //carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
     332                //new_test = ast.BoolOp(ast.Or(), [ifNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
     333                //new_else_part = ifNode.orelse + [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]
     334                //return ast.If(new_test, ifNode.body, new_else_part)
     335
     336               
     337                public void visitLeave(IfStatementNode node) {
     338                        assert (new AdvanceNCounter(node).count() == 0): "Advance(x,n) within if: illegal\n";
     339                       
     340                        int carryBase = this.currentCarry;
     341                        int carryCount = (new CarryCounter(node)).count();
     342                       
     343                        if(carryCount > 0 && this.ciMode) { // De Morgan's
     344
     345                                // if test, replace if test
     346                                String lexeme = Lextant.OR.getPrimaryLexeme();
     347                                LextantToken binaryOperatorToken = LextantToken.make(node.getToken().getLocation(), lexeme, Lextant.OR);
     348                               
     349                                ASTNode lhs = Accessors.ifTest(node);
     350                                FunctionInvocationNode rhs = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     351                                                                                                        new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.CARRYTEST.cName()},
     352                                                                                                        node.getToken());
     353                               
     354                                IntegerConstantNode lowerBound = Generators.makeIntegerConstantNode(carryBase, node.getToken());
     355                                IntegerConstantNode upperBound =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
     356                               
     357                                rhs.appendChild(lowerBound);
     358                                rhs.appendChild(upperBound);
     359                               
     360                                BinaryOperatorNode replacementIfTestNode = Generators.makeBinaryOperatorNode(lhs,
     361                                                                                                                                                rhs,
     362                                                                                                                                                binaryOperatorToken);
     363                               
     364                                Accessors.ifTest(node).updateSelf(replacementIfTestNode);
     365                               
     366                                // else part, append CarryDequeueEnqueue call
     367                                FunctionInvocationNode carryDequeueEnqueue = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     368                                                                                                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.Builtins.CARRYDEQUEUEENQUEUE.cName()},
     369                                                                                                                                node.getToken());
     370                               
     371                                carryDequeueEnqueue.appendChild(lowerBound);
     372                                carryDequeueEnqueue.appendChild(upperBound);                           
     373                               
     374                                if (Accessors.hasElseBlockStatement(node)) {   
     375                                        Accessors.elseBlockStatement(node).appendChild(carryDequeueEnqueue);
     376                                } else {
     377                                        BlockStatementNode blockStatementNode = Generators.makeBlockStatementNode(node.getToken());
     378                                        blockStatementNode.appendChild(carryDequeueEnqueue);
     379                                        Accessors.elseBlockStatement(node).appendChild(carryDequeueEnqueue);
     380                                }
     381                               
     382                        }                       
     383                }
     384                                       
     385                // Helpers             
    304386                private void replaceFunctionInvocationNode(FunctionInvocationNode node, String targetPackage, String targetName,
    305387                                ASTNode carryCall, ASTNode currentCarry) {
     
    317399                        node.updateSelf(replacementNode);
    318400                }
    319 
    320 //          else:
    321 //            #dump_Call(callnode)
    322 //            return callnode
    323                        
    324                        
    325 //        def visit_BinOp(self, exprnode):
    326 //          self.generic_visit(exprnode)
    327 //          carry_args = [ast.Num(self.current_carry)]
    328 //          if self.carryin == "_ci":
    329 //              carry_args = [mkCall(self.carryvar.id + "." + 'get_carry_in', [ast.Num(self.current_carry)]), ast.Num(self.current_carry)]
    330 //          else:
    331 //              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
    332 //          if isinstance(exprnode.op, ast.Sub):
    333 //            #CARRYSET
    334 //            rtn = self.carryvar.id + "." + "BitBlock_sub_ci_co"
    335 //            c = mkCall(rtn, [exprnode.left, exprnode.right] + carry_args)
    336 //            self.current_carry += 1
    337 //            return c
    338 //          elif isinstance(exprnode.op, ast.Add):
    339 //            #CARRYSET
    340 //            rtn = self.carryvar.id + "." + "BitBlock_add_ci_co"
    341 //            c = mkCall(rtn, [exprnode.left, exprnode.right] + carry_args)
    342 //            self.current_carry += 1
    343 //            return c
    344 //          else: return exprnode
    345                
    346                
    347                 public void visitLeave(FunctionDefNode node) {
    348                        
    349                 }               
     401       
    350402        }
    351403}
Note: See TracChangeset for help on using the changeset viewer.