Changeset 3368 for proto/pabloj/trunk


Ignore:
Timestamp:
Jun 27, 2013, 12:49:29 PM (6 years ago)
Author:
ksherdy
Message:

Added support to create IDISA function calls. Meng will be pleased.

Location:
proto/pabloj/trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/test/pabloB/test.pablob

    r3282 r3368  
    1818        BitBlock k;
    1919        BitBlock r;
    20         bool t;
     20
     21        r = simd.constant<1>(0);
    2122       
    2223        /*
     
    3233        */
    3334
    34         t = bitblock.any<1>(a);
    35         r = bitblock.slli<1>(10, a);
    36         bitblock.store_unaligned<1>(a, b);
    37         r = bitblock.load_aligned<1>(b);
    38        
    39         r = simd.not<1>(a);     
    40         r = simd.nor<1>(a, b);
    41         r = simd.ifh<16>(a, b, c);         
    42        
    43         r = simd.constant<2>(3);
    44         r = simd.slli<8>(1, a);         
    45 
    46         r = simd.add<1>(a,b);
    47         r = simd.sub<2>(a,b);
    48         r = simd.mult<4>(a,b);
    49         r = simd.eq<8>(a,b);
    50         r = simd.gt<16>(a,b);
    51         r = simd.ugt<32>(a,b);
    52         r = simd.lt<64>(a,b);
    53         r = simd.ult<128>(a,b);
    54         r = simd.max<128>(a,b);
    55         r = simd.umax<1>(a,b);
    56         r = simd.min<2>(a,b);
    57         r = simd.umin<4>(a,b);
    58         r = simd.sll<64>(a,b);
    59         r = simd.srl<64>(a,b);
    60         //r = simd.srai<32>(10,a);
    61        
    62         //r = simd.if<128>(a,b,c);
     35       
    6336       
    6437    }
  • proto/pabloj/trunk/input/test/pabloB/test_meng.pablob

    r3282 r3368  
    4040                r = simd.constant<2>(3);
    4141                r = simd.slli<8>(1, a);                 
    42 
     42                r = esimd.mergh<8>(a,b,c);
    4343                r = simd.add<1>(a,b);
    4444                r = simd.sub<2>(a,b);
  • proto/pabloj/trunk/output/cpplang/idisa_definitions.hpp

    r3330 r3368  
    2626ErrorTracker error_tracker;
    2727
    28 #define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
     28#define assert_0_error(errstrm,errkind) error_tracker.NoteError(errkind, errstrm);
    2929BitBlock EOF_mask = simd<1>::constant<1>();
    3030
     
    7171                BitBlock k;
    7272                BitBlock r;
    73                 bool t;
    74                 t = bitblock::any(a);
    75                 r = bitblock::slli<10>(a);
    76                 bitblock::store_unaligned(a, &b);
    77                 r = bitblock::load_aligned(&b);
    78                 r = simd_not(a);
    79                 r = simd_nor(a,b);
    80                 r = simd<16>::ifh(a,b,c);
    81                 r = simd<2>::constant<3>();
    82                 r = simd<8>::slli<1>(a);
    83                 r = simd<1>::add(a,b);
    84                 r = simd<2>::sub(a,b);
    85                 r = simd<4>::mult(a,b);
    86                 r = simd<8>::eq(a,b);
    87                 r = simd<16>::gt(a,b);
    88                 r = simd<32>::ugt(a,b);
    89                 r = simd<64>::lt(a,b);
    90                 r = simd<128>::ult(a,b);
    91                 r = simd<128>::max(a,b);
    92                 r = simd<1>::umax(a,b);
    93                 r = simd<2>::min(a,b);
    94                 r = simd<4>::umin(a,b);
    95                 r = simd<64>::sll(a,b);
    96                 r = simd<64>::srl(a,b);
     73                r = simd<1>::constant<0>();
    9774        }
    9875       
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3358 r3368  
    165165        // IfStmtNode
    166166        ////////////////////////////////////////////////////////////////////////////   
    167         public static ASTNode ifTest(IfStmtNode node) {
     167        public static ASTNode condition(IfStmtNode node) {
    168168                return (ASTNode) node.child(0);
    169169        }
     
    180180                return (BlockStmtNode) node.child(2);
    181181        }       
     182       
     183    ////////////////////////////////////////////////////////////////////////////
     184    // WhileStmtNode
     185    ////////////////////////////////////////////////////////////////////////////
     186    public static ASTNode condition(WhileStmtNode node) {
     187        return node.child(0);
     188    }
     189
     190    public static BlockStmtNode body(WhileStmtNode node) {
     191        return (BlockStmtNode) node.child(1);
     192    }   
    182193       
    183194    ////////////////////////////////////////////////////////////////////////////
     
    345356        }       
    346357       
    347         public static String idisaLibraryName(String fullyQualifiedName)
     358        public static String idisaPackageName(String fullyQualifiedName)
    348359        {
    349360                return fullyQualifiedName.split("\\.")[0];
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3358 r3368  
    1212import pabloB.lexicalAnalyzer.Lextant;
    1313import toolchain.pabloB.ast.Accessors;
     14import toolchain.pabloB.lang.idisa.IDISABuiltin;
    1415import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    1516import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
     
    1920        ////////////////////////////////////////////////////////////////////////////
    2021        // PabloS2PabloB Token Conversion 
    21         ////////////////////////////////////////////////////////////////////////////
     22        //
    2223        public static final String LEXICAL_CONTEXT = "main";   
    2324       
     
    9798       
    9899        ////////////////////////////////////////////////////////////////////////////
    99         // PabloB Nodes
    100         ////////////////////////////////////////////////////////////////////////////   
     100        // Kernel
    101101        public static KernelDefNode makeKernelDef(String identifier,
    102102                        InitDefNode stateDefNode,
     
    156156        }       
    157157
    158         /*
    159     public static FuncCallNode makeIdisaFuncCallNode(Locator locator, int fieldWidth, String identifier) {       
    160         IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
    161         return Generators.makeFuncCallNode(locator, identifierNode);
    162     }
    163    
    164     public static FuncCallNode makeIdisaFuncCallNode(Locator locator, int fieldWidth, String identifier, ASTNode ...args) {
    165         FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
    166         Generators.addFuncCallArgs(node, args);
    167         return node;
     158        //////////////////////////////////////////////////////////////////////////
     159        // IDISA function calls
     160    public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, String pckage, String name, int fw, ASTNode... args ) {
     161        CompoundIdentifierNode identifier = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
     162        FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, fw);
     163        IdisaFuncCallNode idisaFuncCall = Generators.makeIdisaFuncCallNode(locator, identifier, fieldWidth, args);
     164        return idisaFuncCall;
    168165    }   
    169166   
    170     public static FuncCallNode makeIdisaFuncCallNode(Locator locator, int fieldWidth, String pckage, String name) {
    171         CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
    172         return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
    173     }
    174    
    175     public static FuncCallNode makeIdisaFuncCallNode(Locator locator, int fieldWidth, String pckage, String name, ASTNode ...args ) {
    176         CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
    177         FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
    178         Generators.addFuncCallArgs(node, args);
    179         return node;
    180     }   
    181 
    182     private static FuncCallNode makeIdisaFuncCallNode(Locator locator, int fieldWidth, ASTNode identifier) {
    183         assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    184         LextantToken token = Generators.makeLextantToken(locator, Lextant.LANGLE);
    185         // ADD FIELD WIDTH NODE
    186         FuncCallNode FuncCallNode = new FuncCallNode(token);
    187         FuncCallNode.appendChild(identifier);
    188         FuncCallNode.appendChild(new IdisaFuncCallArgListNode(token));       
    189         return FuncCallNode;
    190     }   
    191        
    192     private static void addIdisaFuncCallArgs(FuncCallNode node, ASTNode ...args) {
     167    public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, CompoundIdentifierNode identifier, FieldWidthNode fieldWidth, ASTNode... args) {
     168        IdisaFuncCallNode idisaFuncCall = new IdisaFuncCallNode(makeLextantToken(locator, Lextant.LANGLE));
     169        idisaFuncCall.appendChild(identifier);
     170        idisaFuncCall.appendChild(fieldWidth);
     171       
     172       
     173        idisaFuncCall.appendChild(new IdisaFuncCallArgListNode( Generators.makeLextantToken(locator, Lextant.LROUND)));   
     174        Generators.addIdisaFuncCallArgs(idisaFuncCall, args);
     175        return idisaFuncCall;
     176    }
     177
     178    private static void addIdisaFuncCallArgs(IdisaFuncCallNode node, ASTNode ...args) {
    193179        if(args.length > 0) {
    194180            for(ASTNode child: args) {
    195                 Accessors.funcCallArgsListNode(node).appendChild(child);
     181                Accessors.idisaFuncCallArgListNode(node).appendChild(child);
    196182            }
    197             Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
     183            Accessors.idisaFuncCallArgListNode(node).setToken(args[0].getToken());
    198184        }   
    199185    }
    200          */
    201        
     186       
     187    public static FieldWidthNode makeIdisaFieldWidthNode(Locator locator, int fw) {
     188        IntConstantToken fieldWidthConstant = Generators.makeIntegerConstantToken(locator, fw);
     189        FieldWidthNode fieldWidthNode = new FieldWidthNode(fieldWidthConstant);
     190       
     191        IntegerConstantNode integerConstant = Generators.makeIntegerConstantNode(locator, fw);
     192        fieldWidthNode.appendChild(integerConstant);
     193       
     194        return fieldWidthNode;
     195    }
     196   
     197    //////////////////////////////////////////////////////////////////////////
     198    // Function calls     
    202199    public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {       
    203200        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
     
    254251        }
    255252       
    256        
     253        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
     254            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
     255
     256            BlockStmtNode result = new BlockStmtNode(token);
     257            for(ASTNode child: children) {
     258                result.appendChild(child);
     259            }
     260            return result;
     261        }
     262
     263        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
     264            IfStmtNode ifStmtNode = makeIfStmtNode(locator, expression, ifBlockStmt);
     265            ifStmtNode.appendChild(elseBlockStmt);
     266            return ifStmtNode;
     267        }       
     268       
     269        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode blockStmt) {
     270            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
     271            IfStmtNode ifStmtNode = new IfStmtNode(token);
     272            ifStmtNode.appendChild(expression);
     273            ifStmtNode.appendChild((ASTNode)blockStmt);
     274            return ifStmtNode;
     275        }       
     276
    257277        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
    258278         * Currently, no special consideration with only one identifier in the array.
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/AbstractIDISABuiltinGenerator.java

    r3032 r3368  
    1111               
    1212        public abstract String makeIDISAFuncCall(AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    13                                                         String operationBaseName, String operationClassName,
     13                                                        String operationClassName, String operationBaseName,
    1414                                                        String fieldWidth, String ...arguments);
    1515       
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDBitblockBuiltinGenerator.java

    r3032 r3368  
    66        public String makeIDISAFuncCall(
    77                        AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    8                         String operationBaseName, String operationClassName,
     8                        String operationClassName, String operationBaseName,
    99                        String fieldWidth, String... arguments) {
    1010               
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDBitblockImmediateBuiltinGenerator.java

    r3032 r3368  
    77        public String makeIDISAFuncCall(
    88                        AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    9                         String operationBaseName, String operationClassName,
     9                        String operationClassName, String operationBaseName,
    1010                        String fieldWidth, String... arguments) {
    1111               
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDBitblockLoadBuiltinGenerator.java

    r3032 r3368  
    77        public String makeIDISAFuncCall(
    88                        AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    9                         String operationBaseName, String operationClassName,
     9                        String operationClassName, String operationBaseName,
    1010                        String fieldWidth, String... arguments) {
    1111               
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDBitblockStoreBuiltinGenerator.java

    r3032 r3368  
    77        public String makeIDISAFuncCall(
    88                        AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    9                         String operationBaseName, String operationClassName,
     9                        String operationClassName, String operationBaseName,
    1010                        String fieldWidth, String... arguments) {
    1111               
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDBuiltinGenerator.java

    r3032 r3368  
    2222        @Override
    2323        public String makeIDISAFuncCall(AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    24                         String operationBaseName, String operationClassName,
     24                        String operationClassName, String operationBaseName,
    2525                        String fieldWidth, String ...arguments) {
    2626
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDConstantBuiltinGenerator.java

    r3032 r3368  
    2424        public
    2525        String makeIDISAFuncCall(       AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    26                                         String operationBaseName, String operationClassName,
     26                                        String operationClassName, String operationBaseName,
    2727                                        String fieldWidth, String ...arguments) {
    2828               
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/idisa/SIMDLogicBuiltinGenerator.java

    r3032 r3368  
    66        public String makeIDISAFuncCall(
    77                        AbstractIDISABuiltin2Lang idisaBuiltins2Lang,
    8                         String operationBaseName, String operationClassName,
     8                        String operationClassName, String operationBaseName,
    99                        String fieldWidth, String... arguments) {
    1010               
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3358 r3368  
    323323                CodeStore code = new CodeStore();
    324324               
     325                System.out.println(node);
     326               
    325327                String idisaFullyQualifiedName  = childResults.get(0).getResultVarName();
    326328                String idisaOperationName               = Accessors.idisaBaseName(idisaFullyQualifiedName);
    327                 String idisaPackageName                 = Accessors.idisaLibraryName(idisaFullyQualifiedName);
     329                String idisaPackageName                 = Accessors.idisaPackageName(idisaFullyQualifiedName);
    328330                String fieldWidth                               = childResults.get(1).getResultVarName();
    329331                String arguments                                = childResults.get(2).getResultVarName();
     
    337339                        = idisaBuiltin.getSignature(Integer.valueOf(fieldWidth)).getIDISABuiltinsGenerator();           
    338340               
    339                 String idisaFuncCallString = idisaBuiltinsGenerator.makeIDISAFuncCall(idisaBuiltins2Lang, idisaOperationName, idisaPackageName, fieldWidth, arguments);         
     341                String idisaFuncCallString = idisaBuiltinsGenerator.makeIDISAFuncCall(idisaBuiltins2Lang, idisaPackageName, idisaOperationName, fieldWidth, arguments);         
    340342               
    341343                code.setResultVarName(idisaFuncCallString);             // Function invocation as an expression
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/idisa/IDISABuiltin.java

    r3134 r3368  
    3535
    3636public enum IDISABuiltin {
     37   
     38
     39   
    3740               
    3841        // SIMD operations (opPattern == 0)
     
    135138        BITBLOCK_LOAD_ALIGNED (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockLoadBuiltinGenerator(),  BITBLOCK_POINTER,  BITBLOCK)),
    136139        BITBLOCK_LOAD_UNALIGNED (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockLoadBuiltinGenerator(),  BITBLOCK_POINTER,  BITBLOCK));
    137        
     140
    138141        private static final Map<String, IDISABuiltin> operationName2IDISABuilinMap = new HashMap<String, IDISABuiltin>();
    139142           
     
    150153        private IDISAFunctionSignature [] signatures;
    151154       
     155        //private IDISABuiltin(String className, String opName, IDISAFunctionSignature ...signatures) {
    152156        private IDISABuiltin(IDISAFunctionSignature ...signatures) {
    153                 this.signatures = signatures;
    154         }
    155 
     157                this.signatures    = signatures;
     158        }
     159       
     160        public String pckageName() {
     161            return this.name().toLowerCase().split("_")[0];
     162        }
     163       
     164        public String baseName() {
     165            return this.name().toLowerCase().split("_")[1];
     166        }
    156167       
    157168        @Override
     
    178189                return IDISAFunctionSignature.nullInstance();
    179190        }
    180        
    181191       
    182192        public boolean hasSignature(int fieldWidth, Type ... types) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/BuiltinCallUtil.java

    r3360 r3368  
    1010    public static final String BUILTIN_PACKAGE_NAME = "pablo";
    1111       
     12    public static boolean isAssertZero(ASTNode node) {
     13        return isBuiltInCall(node, PabloSBuiltin.ASSERT_ZERO);
     14    }
     15   
    1216    public static boolean isMask(ASTNode node) {
    1317        return isBuiltInCall(node, PabloSBuiltin.MASK);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/BitwiseBoolean2IDISA.java

    r3364 r3368  
    11/*
     2 * Deprecated - Moved to pabloS2pabloB translation.
     3 *
    24 * Transforms bitwise operations to IDISA operations.
    35 *
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBController.java

    r3364 r3368  
    3838        decoratedTree = SurroundAssert0sWithIfs.apply(decoratedTree, builtinEncoder);     
    3939        decoratedTree = CarryIntroXFormer.apply(decoratedTree, builtinEncoder, carrySetEncoder, finalBlockMode);
    40         decoratedTree = SurroundConditionsWithBitBlockAny.apply(decoratedTree);
     40        //decoratedTree = SurroundConditionsWithBitBlockAny.apply(decoratedTree);
    4141        //decoratedTree = BitwiseBoolean2IDISA.apply(decoratedTree);
    4242        //decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3364 r3368  
    1616import pabloB.ast.*;
    1717import pabloB.inputHandler.*;
     18import pabloB.tokens.Token;
    1819import toolchain.pabloB.lang.KernelState;
    1920import toolchain.pabloB.ast.Accessors;
    2021import toolchain.pabloB.ast.Generators;
     22import toolchain.pabloB.lang.idisa.IDISABitBlockBuiltins;
     23import toolchain.pabloB.lang.idisa.IDISABuiltin;
    2124import toolchain.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins;
    2225import static toolchain.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins.*;
     
    2427// non-conflicting pabloS imports
    2528import toolchain.pabloS.lang.BuiltinCallUtil;
     29import toolchain.pabloS.lang.PabloSBuiltin;
    2630import toolchain.pabloS.lang.PabloSBuiltinEncoder;
    2731import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
     
    237241                    pabloB.lexicalAnalyzer.Lextant.forLexeme(lexeme, Generators.LEXICAL_CONTEXT));     
    238242
    239             pabloB.ast.ASTNode replacment = new pabloB.ast.BitBlockTypeNode(bToken);
    240             appendChildResults(replacment, childResults);
    241             return replacment;
     243            pabloB.ast.ASTNode replacement = new pabloB.ast.BitBlockTypeNode(bToken);
     244            appendChildResults(replacement, childResults);
     245            return replacement;
    242246        }
    243247
    244248        public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<pabloB.ast.ASTNode> childResults) {
    245249
     250            if (BuiltinCallUtil.isAssertZero(snode)) {
     251               
     252                Locator locator = Generators.makeToken(snode.getToken());
     253                ASTNode replacement = makeAssert0Call(locator, childResults);
     254           
     255                return replacement;
     256            }
     257           
    246258            if(BuiltinCallUtil.isMask(snode)) { // translates pablo.Mask(fw,constant) to an IDISA call
    247 
    248                 pabloS.tokens.LextantToken lAngleToken = toolchain.pabloS.ast.Generators.makeLextantToken(snode, pabloS.lexicalAnalyzer.Lextant.LANGLE);
    249 
    250                 pabloB.ast.ASTNode replacment = new pabloB.ast.IdisaFuncCallNode(Generators.makeToken(lAngleToken)); //
    251 
    252                 @SuppressWarnings("unused")
    253                 pabloS.tokens.LextantToken dotToken
    254                 = toolchain.pabloS.ast.Generators.makeLextantToken(snode, pabloS.lexicalAnalyzer.Lextant.DOT);
    255 
    256                 pabloB.ast.ASTNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(replacment, "simd", "constant");
    257 
    258                 // field width integer constant
    259                 int fieldWidthValue
    260                 = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 0).getToken().getLexeme());
    261 
    262                 pabloS.tokens.IntConstantToken fieldWidthConstantToken
    263                 = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(snode.getToken(), fieldWidthValue);
    264 
    265                 pabloB.ast.ASTNode fieldWidthConstantNode
    266                 = new pabloB.ast.IntegerConstantNode(Generators.makeToken(fieldWidthConstantToken));
    267 
    268                 pabloB.ast.ASTNode fieldWidthNode
    269                 = new pabloB.ast.FieldWidthNode(Generators.makeToken(fieldWidthConstantToken));
    270 
    271                 fieldWidthNode.appendChild(fieldWidthConstantNode);
    272 
    273                 // mask integer constant
    274                 int maskValue
    275                 = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 1).getToken().getLexeme());
    276 
    277                 pabloS.tokens.IntConstantToken maskToken
    278                 = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(snode.getToken(), maskValue);
    279 
    280                 pabloB.ast.ASTNode maskConstantNode
    281                 = new pabloB.ast.IntegerConstantNode(Generators.makeToken(maskToken));
    282 
    283                 ((pabloB.ast.IntegerConstantNode)maskConstantNode).setValue(maskValue);
    284 
    285                 // argument list
    286                 pabloB.ast.IdisaFuncCallArgListNode idisaFuncCallArgListNode
    287                 = new pabloB.ast.IdisaFuncCallArgListNode(Generators.makeToken(maskToken));
    288 
    289                 idisaFuncCallArgListNode.appendChild(maskConstantNode);
    290 
    291                 replacment.appendChild(compoundIdentifierNode);
    292                 replacment.appendChild(fieldWidthNode);
    293                 replacment.appendChild(idisaFuncCallArgListNode);
     259                Locator locator = Generators.makeToken(snode.getToken());
    294260               
    295                 return replacment;
     261             
     262              int fw            = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 0).getToken().getLexeme());
     263              int value         = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 1).getToken().getLexeme());
     264              IntegerConstantNode valueNode = Generators.makeIntegerConstantNode(locator, value);
     265             
     266              ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, IDISABuiltin.SIMD_CONSTANT.pckageName(), IDISABuiltin.SIMD_CONSTANT.baseName(), fw, valueNode);
     267              return replacement;
    296268
    297269            } else {
     270               
    298271                pabloB.ast.ASTNode replacment  = new pabloB.ast.FuncCallNode(Generators.makeToken(snode.getToken()));
    299272                appendChildResults(replacment, childResults);
     
    302275            }
    303276        }
     277
     278        private pabloB.ast.ASTNode makeAssert0Call(
     279                Locator locator,
     280                List<pabloB.ast.ASTNode> childResults) {
     281           
     282            String assert0CallName                  = builtinEncoder.getName(PabloSBuiltin.ASSERT_ZERO);
     283            pabloB.ast.ASTNode errorStream          = childResults.get(1).deepCopy();
     284            pabloB.ast.ASTNode errorMsg             = childResults.get(2).deepCopy();
     285           
     286            pabloB.ast.ASTNode assert0Call          = Generators.makeFuncCallNode(locator,
     287                                                                                    assert0CallName,
     288                                                                                    errorStream,             
     289                                                                                    errorMsg);
     290         
     291            BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
     292            pabloB.ast.ASTNode replacement          = Generators.makeIfStmtNode(locator,
     293                                                              errorStream.deepCopy(),
     294                                                              blockStmt);
     295            return replacement;
     296        }
     297       
     298        /*       
     299        private pabloB.ast.ASTNode makeSIMDConstantCall(
     300                String assert0CallName                  = builtinEncoder.getName(PabloSBuiltin.ASSERT_ZERO);
     301                pabloB.ast.ASTNode errorStream          = childResults.get(1).deepCopy();
     302                pabloB.ast.ASTNode errorMsg             = childResults.get(2).deepCopy();
     303
     304                pabloB.ast.ASTNode assert0Call          = Generators.makeFuncCallNode(locator,
     305                        assert0CallName,
     306                        errorStream,             
     307                        errorMsg);
     308
     309                BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
     310                pabloB.ast.ASTNode replacement          = Generators.makeIfStmtNode(locator,
     311                        errorStream.deepCopy(),
     312                        blockStmt);
     313                return replacement;
     314        }*/
     315       
     316       
     317       
    304318
    305319        public pabloB.ast.ASTNode visitLeave(pabloS.ast.IntegerConstantNode snode, List<pabloB.ast.ASTNode> childResults) {
     
    372386        }
    373387
     388        public pabloB.ast.ASTNode visitLeave(pabloS.ast.IfStmtNode snode, List<pabloB.ast.ASTNode> childResults) {
     389
     390            pabloB.tokens.Token pabloBToken = Generators.makeToken(snode.getToken());
     391            pabloB.ast.IfStmtNode replacement = new pabloB.ast.IfStmtNode(pabloBToken);
     392            appendChildResults(replacement, childResults);
     393
     394           
     395           
     396           
     397           
     398           
     399           
     400            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     401            return replacement;
     402        }
     403       
     404        public pabloB.ast.ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<pabloB.ast.ASTNode> childResults) {
     405
     406            pabloB.tokens.Token pabloBToken = Generators.makeToken(snode.getToken());
     407            pabloB.ast.WhileStmtNode replacement = new pabloB.ast.WhileStmtNode(pabloBToken);
     408            appendChildResults(replacement, childResults);
     409           
     410           
     411            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     412            return replacement;
     413        }
     414       
    374415    }   
    375 
    376     static private pabloB.ast.FuncCallNode makeIDISACall(Locator locator, IDISASIMDBitwiseBuiltins idisaBuiltin, pabloB.ast.ASTNode ... arguments) {
     416   
     417    private static void surroundConditionWithBitBlockAny(ASTNode node, pabloB.ast.ASTNode condition) {
     418        Locator locator = node;
     419        FuncCallNode funcCallNode = makeIDISACall(locator, IDISABitBlockBuiltins.ANY, Generators.arguments(condition.deepCopy()));
     420        node.replaceChild(condition, funcCallNode);
     421    }
     422
     423    private static FuncCallNode makeIDISACall(Locator locator, IDISASIMDBitwiseBuiltins idisaBuiltin, pabloB.ast.ASTNode ... arguments) {
    377424        return Generators.makeFuncCallNode(locator, idisaBuiltin.Name(), arguments);
    378425    }
    379 
    380     //  @SuppressWarnings("unused")
    381     //  private static pabloS.ast.FuncDefNode searchForFuncDefByName(pabloS.ast.ASTNode node, String name) {
    382     // 
    383     //          if(node instanceof pabloS.ast.FuncDefNode) {
    384     //                  if(toolchain.pabloS.ast.Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(name)) {
    385     //                          return (pabloS.ast.FuncDefNode)node;
    386     //                  }
    387     //          }
    388     //         
    389     //          pabloS.ast.FuncDefNode result = null;
    390     //         
    391     //          for(pabloS.ast.ASTNode child : node.getChildren()) {
    392     //                  result = searchForFuncDefByName(child, name);
    393     //                  if (result != null) {
    394     //                          break;
    395     //                  }
    396     //          }
    397     //         
    398     //          return result; 
    399     //  }
    400 
     426   
     427    private static FuncCallNode makeIDISACall(Locator locator, IDISABitBlockBuiltins idisaBuiltin, ASTNode[] arguments) {
     428        return Generators.makeFuncCallNode(locator, idisaBuiltin.IDISALexeme(), arguments);
     429    }
     430
     431   
     432/*     
     433        @SuppressWarnings("unused")
     434        private static pabloS.ast.FuncDefNode searchForFuncDefByName(pabloS.ast.ASTNode node, String name) {
     435
     436                if(node instanceof pabloS.ast.FuncDefNode) {
     437                        if(toolchain.pabloS.ast.Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(name)) {
     438                                return (pabloS.ast.FuncDefNode)node;
     439                        }
     440                }
     441               
     442                pabloS.ast.FuncDefNode result = null;
     443               
     444                for(pabloS.ast.ASTNode child : node.getChildren()) {
     445                        result = searchForFuncDefByName(child, name);
     446                        if (result != null) {
     447                                break;
     448                        }
     449                }
     450               
     451                return result; 
     452        }
     453*/
    401454}
     455
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/SurroundConditionsWithBitBlockAny.java

    r3364 r3368  
    11/*
     2 * Deprecated - Moved to pabloS2pabloB translation.
     3 *
    24 * Surrounds if and while conditions with IDISA BitBlock::any() calls.
    35 *
Note: See TracChangeset for help on using the changeset viewer.