Changeset 2970


Ignore:
Timestamp:
Mar 24, 2013, 1:41:00 AM (4 years ago)
Author:
ksherdy
Message:

Minor updates in support of stream initializer impl.

Location:
proto/pabloj/trunk/src/compilers
Files:
1 added
12 edited
1 copied

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/visitors/CPPUnparser.java

    r2967 r2970  
    2929    $block_statements
    3030  }                             
    31   CarryArray<$carry_count, $carry_n_count> carryQ;
     31 
     32  CarryDeclare(name, count1, countN);
    3233};
    3334*/
     
    161162                CodeStore code = new CodeStore();
    162163               
     164                // TODO - Hook for PabloB Kernel init section, state.
    163165                /*
    164166                code.addFormattedLine("for(int i=0; i<%s; i++)", stateSize);
     
    175177               
    176178                CodeStore code = new CodeStore();
    177                
     179
     180                // TODO - Hook for PabloB Kernel init section, state.
    178181                /*
    179182                for(int i=0; i<childResults.size(); i++) {
     
    297300        public CodeStore visitLeave(WhileStmtNode node, List<CodeStore> childResults) {
    298301                CodeStore code = new CodeStore();
    299                 CodeStore ifTest                        = childResults.get(0);
     302                CodeStore ifTest                = childResults.get(0);
    300303                CodeStore blockStmt     = childResults.get(1);
    301304                code.addFormattedLine("while (%s)", ifTest.getResultVarName());
     
    527530        public CodeStore visitLeave(StreamTypeNode node, List<CodeStore> childResults) {
    528531                CodeStore code = new CodeStore();
    529                 // TODO - Map stream --> BitBlock and stream<1> --> BitBlock
     532
     533                // TODO - Hook for 2^k field width types.
    530534                // code.setResultVarName(Accessors.streamTypeName(node));
     535               
    531536                code.setResultVarName("BitBlock");
    532537               
     538                // TODO - Hook for 2^k field width types.
    533539                /*
    534                  * TODO - 2^k field width types.
    535                  *
    536540                if(Accessors.hasFieldWidth(node)) {
    537541                        CodeStore fieldWidth;
    538542                        fieldWidth = childResults.get(0);
    539543                        code.setResultVarName(code.getResultVarName() + "<" + fieldWidth.getResultVarName() + ">");
    540                 }
    541                 *
    542                 *
     544                }               
    543545                */             
    544546               
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/SIMD.java

    r2952 r2970  
    5656        public String IDISALexeme() { return (SIMD + "_" + lexeme); }
    5757        public String IDISALexeme(String fieldWidth) { return (SIMD + "<" + fieldWidth + ">::" + lexeme); }
    58         public String IDISAConstantLexeme(String constant, String fieldWidth) {
     58        public String IDISAConstantLexeme(String fieldWidth, String constant) {
    5959                return (SIMD + "<" + fieldWidth + ">::" + CONSTANT.lexeme + "<" + constant +">");
    6060        }
  • proto/pabloj/trunk/src/compilers/pabloS/ast/Accessors.java

    r2952 r2970  
    8484        }       
    8585       
    86         public static ASTNode lhs(LocalVarDeclNode node) {
    87                 return node.child(1);
     86        ////////////////////////////////////////////////////////////////////////////
     87        // Local variable declarations
     88        ////////////////////////////////////////////////////////////////////////////
     89        public static ASTNode type(LocalVarDeclNode node) {
     90                return node.child(0);
     91        }       
     92       
     93        public static IdentifierNode identifier(LocalVarDeclNode node) {
     94                ASTNode child = node.child(1);
     95                assert child instanceof IdentifierNode;
     96                return (IdentifierNode)node.child(1);
    8897        }       
    8998       
    9099        public static ASTNode rhs(LocalVarDeclNode node) {
    91        
    92100                return node.child(2);
    93101        }               
     
    128136                return node.getToken().getLexeme();
    129137        }                       
    130 
    131         public static String streamConstantLexeme(StreamConstantNode node) {
    132                 return node.getToken().getLexeme();
    133         }                       
    134                
     138                                       
    135139        public static String stringConstantLexeme(StringConstantNode node) {
    136140                return node.getToken().getLexeme();
     
    273277        return Accessors.name(node.child(1));
    274278        }       
    275                        
     279       
     280        ////////////////////////////////////////////////////////////////////////////
     281        // 2^k stream type
     282        ////////////////////////////////////////////////////////////////////////////
    276283        public static String streamTypeName(StreamTypeNode node) {
    277284                return Accessors.name(node);
    278285        }       
    279286
     287        ////////////////////////////////////////////////////////////////////////////
     288        // Field Width
     289        ////////////////////////////////////////////////////////////////////////////
    280290        public static boolean hasFieldWidth(StreamTypeNode node) {             
    281291                if(1 == node.nChildren()) {
     
    285295                return false;
    286296        }
    287 
     297       
     298        public static FieldWidthNode fieldWidthNode(StreamTypeNode node) {
     299                assert node.nChildren() == 1 && node.child(0) instanceof FieldWidthNode;
     300                return (FieldWidthNode) node.child(0);
     301        }
     302       
    288303        public static String fieldWidthLexeme(FieldWidthNode node) {           
    289304                return node.getToken().getLexeme();
  • proto/pabloj/trunk/src/compilers/pabloS/ast/Generators.java

    r2952 r2970  
    4444        }
    4545       
    46 
    47         /** Makes a new FuncCallNode with an identifier string and the TextLocation taken from token.
    48          * @param identifier
    49          * @param locationToken
    50          * @return FuncCallNode
    51          */
     46        public static LocalVarDeclNode makeLocalVarDeclNode(ASTNode type, IdentifierNode identifier, ASTNode rhs, Token locationToken) {
     47               
     48                Token assignToken = Generators.makeLextantToken(Lextant.ASSIGN, locationToken);
     49                LocalVarDeclNode localVarDeclNode = new LocalVarDeclNode(assignToken);
     50               
     51                localVarDeclNode.appendChild(type);
     52                localVarDeclNode.appendChild(identifier);
     53                localVarDeclNode.appendChild(rhs);
     54               
     55                return localVarDeclNode;
     56        }
     57
     58        // Make function Call variants
    5259        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken) {
    5360                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);       
     
    5562        }
    5663
    57         /** Makes a new compound FuncCallNode with a array of identifiers string and the TextLocation taken from token.
    58          * @param identifiers - a compound identifier a.b()     
    59          * @param locationToken
    60          * @return
    61          */
    6264        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
    6365               
     
    203205            return integerConstantNode;
    204206        }
    205 
    206         public static StreamConstantNode makeStreamConstantNode(int n, Token locationToken) {
    207                 Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
    208                 StreamConstantNode streamConstantNode = new StreamConstantNode(newToken);
    209                 streamConstantNode.setValue(n);
    210             return streamConstantNode;
    211         }       
    212207       
    213208        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token locationToken) {
  • proto/pabloj/trunk/src/compilers/pabloS/lang/Builtins2CPP.java

    r2952 r2970  
    2727        pabloS2CPPCode.put(Builtins.ADVANCEN, "BitBlock_advance_n_<%s>");
    2828
    29         pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.IDISAConstantLexeme("1", "%s"));
     29        pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.IDISAConstantLexeme("%s", "1"));
    3030        pabloS2CPPCode.put(Builtins.MASKFW, SIMD.CONSTANT.IDISAConstantLexeme("%s", "%s"));
    3131       
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins2CPP.java

    r2952 r2970  
    3838        pabloS2CPPCode.put(Builtins.ADVANCEN, "BitBlock_advance_n_<%s>");
    3939
    40         pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.IDISAConstantLexeme("1", "%s"));
     40        pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.IDISAConstantLexeme("%s", "1"));
    4141        pabloS2CPPCode.put(Builtins.MASKFW, SIMD.CONSTANT.IDISAConstantLexeme("%s", "%s"));
    4242       
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/Transformer.java

    r2967 r2970  
    1313import compilers.pabloS.semanticAnalyzer.visitors.AugAssignXFormer;
    1414import compilers.pabloS.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
     15import compilers.pabloS.semanticAnalyzer.visitors.InitStreamDefaultsXFormer;
    1516import compilers.pabloS.semanticAnalyzer.visitors.CarryIntroXFormer;
    1617import compilers.pabloS.semanticAnalyzer.visitors.DumpAssignStmtsXFormer;
     
    8687                bitwiseToIDISA.XForm();                 
    8788
     89                InitStreamDefaultsXFormer initStreamDefaults = new InitStreamDefaultsXFormer(decoratedTree);
     90                initStreamDefaults.XForm();
     91               
    8892                return decoratedTree;
    8993               
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AdvanceCombinerXFormer.java

    r2952 r2970  
    9191                                                        Accessors.funcCallArgsListNode(child));
    9292               
    93                 StreamConstantNode integerConstantNode = Generators.makeStreamConstantNode(amount1+amount2, node.getToken());
     93                IntegerConstantNode integerConstantNode = Generators.makeIntegerConstantNode(amount1+amount2, node.getToken());
    9494                if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
    9595                        Accessors.funcCallArgsListNode(child).appendChild(integerConstantNode);
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AssertBitBlockAlignStmtsXFormer.java

    r2952 r2970  
    3737                               
    3838                public void visitEnter(LocalVarDeclNode node) {
    39                         addAssertBitBlockAssignStmt(node, Accessors.lhs(node));
     39                        addAssertBitBlockAssignStmt(node, Accessors.identifier(node));
    4040                }               
    4141               
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AugAssignXFormer.java

    r2952 r2970  
    4747                public void visitLeave(LocalVarDeclNode node) {
    4848                        if(Accessors.hasInitializationAssign(node)) {
    49                                 XFormAugAssign(node, Accessors.lhs(node), Accessors.rhs(node));
     49                                XFormAugAssign(node, Accessors.identifier(node), Accessors.rhs(node));
    5050                        }
    5151                }
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2961 r2970  
    258258                                                new ASTNode [] {currentAdvN});
    259259                        } else {
    260                                 carryAtCallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
    261                                 pending64CallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
     260                                carryAtCallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("1", "0"), node.getToken());
     261                                pending64CallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("1", "0"), node.getToken());
    262262                        }
    263263                                               
     
    565565                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    566566                                } else {
    567                                         replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());                                   
     567                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("1", "0"), node.getToken());                                   
    568568                                }
    569569                                node.updateSelf(replacementNode);
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/DumpAssignStmtsXFormer.java

    r2952 r2970  
    3636                               
    3737                public void visitEnter(LocalVarDeclNode node) {
    38                         addDumpStmt(node, Accessors.lhs(node));
     38                        addDumpStmt(node, Accessors.identifier(node));
    3939                }               
    4040               
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/InitStreamDefaultsXFormer.java

    r2956 r2970  
    11/*
    2  * Transforms bitwise operations to IDISA operations.
     2 * Sets unintialized stream primitives variables and members to defaults.
    33 *
    4  * Transforms expressions to BitBlock::any(expr). BitBlock:any expects stream<1> type.
    5  *
    6  * TODO
    7  *
    8  * - Move to PabloB.
    9  * - Remove transformation of integer constants to simd::constant<1>(0)
     4 * stream<2^k> (stream) ->      simd<2^k>::constant(0)
     5 * Integer                      ->      0
     6 * String                               ->      empty string
    107 *
    118 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    2320import compilers.pabloS.ast.Generators;
    2421
    25 public class Bitwise2IDISAXFormer {
     22public class InitStreamDefaultsXFormer {
    2623        private ASTNode ASTTree;
    2724       
    28         public Bitwise2IDISAXFormer(ASTNode ASTree) {
     25        public InitStreamDefaultsXFormer(ASTNode ASTree) {
    2926                this.ASTTree = ASTree;
    3027        }
    3128       
    3229        public ASTNode XForm() {
    33                
    34                 Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
    35                 ASTTree.accept(binOpXformer);
    36                
    37                 Bitwise2IDISAUnaryOperatorXFormer unOpXFormer = new Bitwise2IDISAUnaryOperatorXFormer();
    38                 ASTTree.accept(unOpXFormer);
    3930               
    4031                Bitwise2IDISAGeneralXFormer xFormer = new Bitwise2IDISAGeneralXFormer();
     
    4334                return ASTTree;
    4435        }
     36               
     37        private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
     38                       
     39                public void visitLeave(LocalVarDeclNode node) {
    4540       
    46         private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
    47 
    48                 public void visitLeave(BinaryOperatorNode node) {
    49                         Token token = node.getToken();
     41                        if(!Accessors.hasInitializationAssign(node)) {
    5042                       
    51                         if(token.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
    52                                 FuncCallNode funcCallNode = null;
    53                                 if(token.isLextant(Lextant.OR)) {
    54                                         funcCallNode = Generators.makeFuncCallNode(SIMD.OR.IDISALexeme(),
    55                                                                                                                                 token,
    56                                                                                                                                 new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
    57                                 } else if(token.isLextant(Lextant.AND)) {
     43                                ASTNode type                            = Accessors.type(node);
     44                                IdentifierNode identifier       = Accessors.identifier(node);
     45                               
     46                                if(type instanceof StreamTypeNode) {
    5847                                       
    59                                         if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
    60                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(),
    61                                                                                                                                         token,
    62                                                                                                                                         new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
    63                                         } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
    64                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(),
    65                                                                                                                                         token,
    66                                                                                                                                         new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
    67                                         } else {
    68                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.AND.IDISALexeme(),
    69                                                                                                                                         token,
    70                                                                                                                                         new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
     48                                        String fieldWidth = "0";
     49                                       
     50                                        if(Accessors.hasFieldWidth((StreamTypeNode)type)) {
     51                                                fieldWidth = Accessors.fieldWidthLexeme(Accessors.fieldWidthNode((StreamTypeNode)type));
    7152                                        }
    7253                                       
    73                                 } else if (token.isLextant(Lextant.XOR)){
    74                                         funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.IDISALexeme(),
    75                                                                                                                                 token,
    76                                                                                                                                 new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
    77                                 }
    78                                
    79                                 //funcCallNode.setParent(node.getParent());
    80                                 //node = (BinaryOperatorNode)funcCallNode;
    81                                
    82                                 node.updateSelf(funcCallNode);
    83                                
    84                                 //System.out.println(funcCallNode);
    85                                
    86                         }               
     54                                        String name = SIMD.CONSTANT.IDISAConstantLexeme(fieldWidth,"0");
     55                                        FuncCallNode funcCallNode = Generators.makeFuncCallNode(name, node.getToken());
     56                                       
     57                                        LocalVarDeclNode localVarDeclNode = Generators.makeLocalVarDeclNode(type, identifier, funcCallNode, node.getToken());
     58                                       
     59                                        node.updateSelf(localVarDeclNode);
     60                                       
     61                                }
     62                        }
     63                }
     64               
     65                public void visitLeave(StructMemberNode node) {
    8766                       
    8867                }
    89         }       
    90 
    91         private class Bitwise2IDISAUnaryOperatorXFormer extends VoidVisitor.Default {
    92                 public void visitLeave(UnaryOperatorNode node) {
    93                         Token op = node.getToken();
    94                         if(op.isLextant(Lextant.NOT)) {
    95 
    96                                 FuncCallNode FuncCallNode =
    97                                                 Generators.makeFuncCallNode(SIMD.NOT.IDISALexeme(),
    98                                                                                                                                 op,
    99                                                                                                                                 new ASTNode [] {Accessors.operand(node)});                     
    100                                 node.updateSelf(FuncCallNode);
    101                         }
    102                 }               
    103         }       
    104        
    105         private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
    106                 /*
    107                 public void visitLeave(IntegerConstantNode node) {
    108                         String name;
    109                         int constantValue = ((IntegerConstantNode)(node)).getValue();
    110                        
    111                         if(constantValue == 0 || constantValue == -1) {
    112                                
    113                                 int fieldWidth = 1;
    114                                 int constant = -1 * constantValue;
    115                                
    116                                 name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
    117                                 FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
    118                                 node.updateSelf(FuncCallNode);
    119                         }
    120                 }
    121                 */
    12268               
    123                 /*
    124                 public void visitLeave(LocalVarDeclNode node) {
    125                         if(Accessors.hasInitializationAssign(node)) {
    126                                 ASTNode rhs = Accessors.rhs(node);
    127                                 integerConstant2IDISA(node, rhs);
    128                         }
    129                 }
    130                 */
    131                
    132                 /*
    133                 public void visitLeave(StreamConstantNode node) {
    134                         streamConstant2IDISA(node);
    135                 }
    136                 */
    137                
    138                 /*
    139                 private void streamConstant2IDISA(ASTNode node) {                       
    140                         if(node instanceof StreamConstantNode) {
    141                        
    142                                 int value = ((StreamConstantNode) node).getValue();
    143                                
    144                                 if(value == 0 || value == -1) {
    145                                        
    146                                         int fieldWidth = 1;
    147                                         int constant = -1 * value;
    148                                        
    149                                         String name = SIMD.CONSTANT.IDISAConstantLexeme(Integer.toString(fieldWidth), Integer.toString(constant));
    150                                         FuncCallNode funcCallNode = Generators.makeFuncCallNode(name, node.getToken());
    151                                         node.updateSelf(funcCallNode);
    152                                 }
    153                         }
    154                 }
    155                 */             
    156                
    157 //          def visit_If_Node(self, ifNode):
    158 //        self.generic_visit(ifNode)
    159 //        ifNode.test = makeCall('bitblock::any', [ifNode.test])
    160 //        return ifNode         
    161                 public void visitLeave(IfStmtNode node) {
    162                         ASTNode ifTest = Accessors.ifTest(node);                       
    163                         String FuncName = BitBlock.ANY.IDISALexeme();
    164                         FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest});
    165                         node.replaceChild(ifTest, FuncCallNode);
    166                 }
    167                
    168 //          def visit_While_Node(self, whileNode):
    169 //              self.generic_visit(whileNode)
    170 //              whileNode.test = makeCall('bitblock::any', [whileNode.test])
    171 //              return whileNode
    172                 public void visitLeave(WhileStmtNode node) {
    173                         ASTNode whileTest = Accessors.whileTest(node);                 
    174                                                                                                                                
    175                         FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
    176                                         BitBlock.ANY.IDISALexeme(),
    177                                         node.getToken(),
    178                                         new ASTNode [] {whileTest});                           
    179                        
    180                         node.replaceChild(whileTest, FuncCallNode);
    181                 }
    18269        }
    18370}
Note: See TracChangeset for help on using the changeset viewer.