Changeset 2441


Ignore:
Timestamp:
Oct 12, 2012, 4:34:00 PM (7 years ago)
Author:
ksherdy
Message:

Refactored CarryIntro? visitor.

File:
1 edited

Legend:

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

    r2437 r2441  
    33import compiler.ast.Accessors;
    44import compiler.ast.Generators;
     5import compiler.lang.idisa.SIMD;
    56import compiler.lang.pablo.builtins.Builtins;
    67import compiler.lang.pablo.builtins.Carry1;
    78import compiler.lang.pablo.builtins.CarryN;
     9import compiler.lang.pablo.builtins.Constants;
    810import compiler.lang.pablo.builtins.NoCarry;
    911
     
    3537                CarryCounter carryCounter = new CarryCounter(this.functionDefNode);
    3638                int carry_count = carryCounter.count();
     39                System.out.printf("Carry Count: %d", carry_count);
    3740        if (carry_count > 0) {
    3841                CarryIntroVisitor visitor = new CarryIntroVisitor(ci, co);
     
    4346        private class CarryIntroVisitor extends VoidVisitor.Default {
    4447
    45             private final String carryVar = "carryQ";
     48            private final String carryPackage = "carryQ";
    4649                private final String ciSuffix = "_ci";
    4750                private final String coSuffix = "_co";
    48                 private String [] pendindCarryQName = {this.carryVar, "get_carry_in"};
    49                 private String [] pending64QName = {this.carryVar, "get_pending64"};
     51                private String [] pendindCarryQName = {this.carryPackage, "get_carry_in"};
     52                private String [] pending64QName = {this.carryPackage, "get_pending64"};
    5053               
    5154                private boolean ciMode;
     
    7275                //          return fndef
    7376                public void visitLeave(FunctionInvocationNode node) {
    74        
    75                         String [] carryBuiltinQName = {this.carryVar,""};
    7677                       
    7778                        ASTNode replacementNode;
     
    8283                        ASTNode advNCall;
    8384                        ASTNode currentAdvN = Generators.makeIntegerConstantNode(this.currentAdvN, node.getToken());
    84                        
     85
    8586//                  if self.carryin == "_ci":
    8687//              carry_args = [mkCall(self.carryvar.id + "." + 'get_carry_in', [ast.Num(self.current_carry)]), ast.Num(self.current_carry)]
     
    108109        //                    return c                 
    109110                        if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCE.pabloName(), Carry1.ADVANCE.argCount())) {             
    110                                
    111                                 carryBuiltinQName[1] = Carry1.ADVANCE.cName();
    112                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    113                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    114                                         replacementNode.appendChild(arg);
    115                                 }                               
    116                                 replacementNode.appendChild(carryCall);
    117                                 replacementNode.appendChild(currentCarry);
    118 
    119                                 node.updateSelf(replacementNode);
     111                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.ADVANCE.cName(), carryCall, currentCarry);
    120112                                this.currentCarry += 1;
    121113                        }
     
    127119        //            self.current_carry += 1
    128120        //            return c         
    129                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTHRU.pabloName(), Carry1.SCANTHRU.argCount())) {
    130                        
    131                                 carryBuiltinQName[1] = Carry1.SCANTHRU.cName();
    132                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    133                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    134                                         replacementNode.appendChild(arg);
    135                                 }                               
    136                                 replacementNode.appendChild(carryCall);
    137                                 replacementNode.appendChild(currentCarry);
    138 
    139                                 node.updateSelf(replacementNode);
     121                        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);
    140123                                this.currentCarry += 1;
    141124                        }
     
    148131        //            return c         
    149132                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCETHENSCANTHRU.pabloName(), Carry1.ADVANCETHENSCANTHRU.argCount())) {
    150                                 carryBuiltinQName[1] = Carry1.ADVANCETHENSCANTHRU.cName();
    151                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    152                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    153                                         replacementNode.appendChild(arg);
    154                                 }                               
    155                                 replacementNode.appendChild(carryCall);
    156                                 replacementNode.appendChild(currentCarry);
    157 
    158                                 node.updateSelf(replacementNode);                               
     133                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.ADVANCETHENSCANTHRU.cName(), carryCall, currentCarry);
    159134                                this.currentCarry += 1;
    160135                        }               
     
    167142        //            return c         
    168143                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SPANUPTO.pabloName(), Carry1.SPANUPTO.argCount())) {
    169                                 carryBuiltinQName[1] = Carry1.SPANUPTO.cName();
    170                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    171                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    172                                         replacementNode.appendChild(arg);
    173                                 }                               
    174                                 replacementNode.appendChild(carryCall);
    175                                 replacementNode.appendChild(currentCarry);
    176                                
    177                                 node.updateSelf(replacementNode);                               
     144                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SPANUPTO.cName(), carryCall, currentCarry);                               
    178145                                this.currentCarry += 1;
    179146                        }               
     
    188155        //            return c
    189156                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.ADVANCETHENSCANTO.pabloName(), Carry1.ADVANCETHENSCANTO.argCount())) {
    190                                 carryBuiltinQName[1] = Carry1.ADVANCETHENSCANTO.cName();
    191                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    192                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    193                                         replacementNode.appendChild(arg);
    194                                 }                               
    195                                 replacementNode.appendChild(carryCall);
    196                                 replacementNode.appendChild(currentCarry);
    197                                                                
    198                                 node.updateSelf(replacementNode);                               
     157                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.ADVANCETHENSCANTO.cName(), carryCall, currentCarry);
    199158                                this.currentCarry += 1;
    200159                        }               
     
    210169       
    211170                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.INCLUSIVESPAN.pabloName(), Carry1.INCLUSIVESPAN.argCount())) {
    212                                 carryBuiltinQName[1] = Carry1.INCLUSIVESPAN.cName();
    213                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    214                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    215                                         replacementNode.appendChild(arg);
    216                                 }                               
    217                                 replacementNode.appendChild(carryCall);
    218                                 replacementNode.appendChild(currentCarry);
    219                                                                
    220                                 node.updateSelf(replacementNode);
     171                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.INCLUSIVESPAN.cName(), carryCall, currentCarry);
    221172                                this.currentCarry += 1;
    222173                        }                               
     
    232183       
    233184                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.EXCLUSIVESPAN.pabloName(), Carry1.EXCLUSIVESPAN.argCount())) {
    234                                 carryBuiltinQName[1] = Carry1.EXCLUSIVESPAN.cName();
    235                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    236                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    237                                         replacementNode.appendChild(arg);
    238                                 }                               
    239                                 replacementNode.appendChild(carryCall);
    240                                 replacementNode.appendChild(currentCarry);
    241                                                                
    242                                 node.updateSelf(replacementNode);
     185                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.EXCLUSIVESPAN.cName(), carryCall, currentCarry);
    243186                                this.currentCarry += 1;
    244187                        }                                               
     
    256199       
    257200                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTO.pabloName(), Carry1.SCANTO.argCount())) {
    258                                 carryBuiltinQName[1] = Carry1.SCANTO.cName();
    259                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    260                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    261                                         replacementNode.appendChild(arg);
    262                                 }                               
    263                                 replacementNode.appendChild(carryCall);
    264                                 replacementNode.appendChild(currentCarry);
    265                                                                
    266                                 node.updateSelf(replacementNode);                               
     201                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SCANTO.cName(), carryCall, currentCarry);
    267202                                this.currentCarry += 1;
    268203                        }                                                               
     
    277212       
    278213                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, Carry1.SCANTOFIRST.pabloName(), Carry1.SCANTOFIRST.argCount())) {
    279                                 carryBuiltinQName[1] = Carry1.SCANTOFIRST.cName();
    280                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    281                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    282                                         replacementNode.appendChild(arg);
    283                                 }                               
    284                                 replacementNode.appendChild(carryCall);
    285                                 replacementNode.appendChild(currentCarry);
    286                                                                
    287                                 node.updateSelf(replacementNode);                                       
     214                                replaceFunctionInvocationNode(node, this.carryPackage, Carry1.SCANTOFIRST.cName(), carryCall, currentCarry);
    288215                                this.currentCarry += 1;
    289216                        }                                                                               
     
    296223        //            return c
    297224                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, CarryN.ADVANCE32.pabloName(), CarryN.ADVANCE32.argCount())) {
    298                                 carryBuiltinQName[1] = CarryN.ADVANCE32.cName();
    299                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    300                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    301                                         replacementNode.appendChild(arg);
    302                                 }                               
    303                                 replacementNode.appendChild(carryCall);
    304                                 replacementNode.appendChild(currentAdvN);
    305                                                                
    306                                 node.updateSelf(replacementNode);                                       
     225                                replaceFunctionInvocationNode(node, this.carryPackage, CarryN.ADVANCE32.cName(), carryCall, currentAdvN);
    307226                                this.currentAdvN += 1;
    308227                        }                       
     
    315234        //            return c         
    316235                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, CarryN.ADVANCE.pabloName(), CarryN.ADVANCE.argCount())) {
    317                                 carryBuiltinQName[1] = CarryN.ADVANCE.cName();
    318                                 replacementNode = Generators.makeFunctionInvocationNode(carryBuiltinQName, node.getToken());
    319                                 for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    320                                         replacementNode.appendChild(arg);
    321                                 }                               
    322                                 replacementNode.appendChild(carryCall);
    323                                 replacementNode.appendChild(currentAdvN);
    324                                                                
    325                                 node.updateSelf(replacementNode);                                       
     236                                replaceFunctionInvocationNode(node, this.carryPackage, CarryN.ADVANCE.cName(), carryCall, currentAdvN);                                 
    326237                                this.currentAdvN += 1;                 
    327238                        }                                       
     
    332243        //              return mkCall('simd<1>::constant<0>', [])
    333244        //            else: return mkCall('simd_andc', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    334                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.ATEOF.pabloName(), NoCarry.ATEOF.argCount())) {
    335                                
     245                       
     246                        else  if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.ATEOF.pabloName(), NoCarry.ATEOF.argCount())) {
     247                                         
     248                                if(!this.coMode) { // non final block
     249                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
     250                                } else {
     251                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.ANDC.idisaName(), node.getToken());
     252                                        for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
     253                                                replacementNode.appendChild(arg);
     254                                        }                                                                       
     255                                        replacementNode.appendChild(Generators.makeIdentifierNode(Constants.EOFMASK.cName(), node.getToken()));
     256                                }
     257                                node.updateSelf(replacementNode);
    336258                        }                                       
    337259       
     
    340262        //              # Non final block: inFile(x) = x.
    341263        //              return callnode.args[0]
     264        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
     265
     266                        // if X & EOF_mask ==> inFile(X)
    342267                        else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.INFILE.pabloName(), NoCarry.INFILE.argCount())) {
    343                                
     268                                if(!this.coMode) {  // non final block
     269                                        replacementNode = Accessors.functionInvocationArg(node,0);
     270                                } else {
     271                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.AND.idisaName(), node.getToken());
     272                                        for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
     273                                                replacementNode.appendChild(arg);
     274                                        }                                                                       
     275                                        replacementNode.appendChild(Generators.makeIdentifierNode(Constants.EOFMASK.cName(), node.getToken()));
     276                                }
     277                                node.updateSelf(replacementNode);
    344278                        }                                       
    345279       
    346         //              TODO - Add In mkCall           
    347         //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    348 
    349         //          elif is_BuiltIn_Call(callnode, 'StreamScan', 2):
    350         //            rtn = "StreamScan"           
    351         //            c = mkCall(rtn, [ast.Name('(ScanBlock *) &' + callnode.args[0].id, ast.Load()),
    352         //                                                 ast.Name('sizeof(BitBlock)/sizeof(ScanBlock)', ast.Load()),
    353         //                                                 ast.Name(callnode.args[1].id, ast.Load())])
    354         //            return c                                 
    355                         else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.INFILE.pabloName(), NoCarry.INFILE.argCount())) {
    356                                
     280//              elif is_BuiltIn_Call(callnode, 'StreamScan', 2):
     281//                      rtn = "StreamScan"           
     282//                      c = mkCall(rtn, [ast.Name('(ScanBlock *) &' + callnode.args[0].id, ast.Load()),
     283//                                                 ast.Name('sizeof(BitBlock)/sizeof(ScanBlock)', ast.Load()),
     284//                                                 ast.Name(callnode.args[1].id, ast.Load())])
     285//              return c                                       
     286//
     287//                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
     288//                              replacementNode = Generators.makeFunctionInvocationNode(NoCarry.STREAMSCAN.cName(), node.getToken());
     289//                             
     290//                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.functionInvocationArg(node, 0)), node.getToken());
     291//                              ASTNode arg1 = Generators.makeIdentifierNode("sizeof(BitBlock)/sizeof(ScanBlock)", node.getToken());
     292//                              ASTNode arg2 = Accessors.functionInvocationArg(node, 1);
     293//                             
     294//                              replacementNode.appendChild(arg0);
     295//                              replacementNode.appendChild(arg1);
     296//                              replacementNode.appendChild(arg2);
     297//                      }
     298                        else {
     299                                // do nothing
    357300                        }
    358 
     301                       
     302                }
     303
     304                private void replaceFunctionInvocationNode(FunctionInvocationNode node, String targetPackage, String targetName,
     305                                ASTNode carryCall, ASTNode currentCarry) {
     306                        ASTNode replacementNode;
     307                        String [] compoundName = new String [2];
     308                        compoundName[0] = targetPackage;
     309                        compoundName[1] = targetName;
     310                        replacementNode = Generators.makeFunctionInvocationNode(compoundName, node.getToken());
     311                        for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
     312                                replacementNode.appendChild(arg);
     313                        }                               
     314                        replacementNode.appendChild(carryCall);
     315                        replacementNode.appendChild(currentCarry);
     316
     317                        node.updateSelf(replacementNode);
    359318                }
    360319
Note: See TracChangeset for help on using the changeset viewer.