Changeset 3098 for proto/pabloj


Ignore:
Timestamp:
Apr 30, 2013, 2:20:55 AM (6 years ago)
Author:
ksherdy
Message:

Added support to translate PabloS builtin pablo.mask(fw, int) to PabloB IDISA function call.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3010 r3098  
    1414import java.util.ArrayList;
    1515import java.util.List;
    16 
    1716import pabloS.lexicalAnalyzer.*;
    1817import pabloS.tokens.*;
     
    5049
    5150        // Make function Call variants
     51        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, ASTNode ...args) {
     52               
     53                FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
     54                Generators.addFuncCallArgs(node, args);
     55                return node;
     56        }       
     57
     58        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, List<ASTNode> args) {
     59               
     60                FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
     61                Generators.addFuncCallArgs(node, args);
     62                return node;
     63        }       
     64       
    5265        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken) {
    5366                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);       
     
    5568        }
    5669
    57         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
    58                
     70        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode ...args) {
     71                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     72                Generators.addFuncCallArgs(node, args);
     73                return node;
     74        }
     75
     76        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken,  List<ASTNode> args) {
     77               
     78                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     79                Generators.addFuncCallArgs(node, args);
     80                return node;
     81        }               
     82       
     83        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {               
    5984                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
    6085                return Generators.makeFuncCallNode(identifierNode, locationToken);
    6186        }
    6287
    63         public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, ASTNode ...args) {
    64                
    65                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
    66                 Generators.addFuncCallArgs(node, args);
    67                 return node;
    68         }       
    69 
    70         public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, List<ASTNode> args) {
    71                
    72                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
    73                 Generators.addFuncCallsArgs(node, args);
    74                 return node;
    75         }       
    76        
     88        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
     89                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
     90
     91                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     92                FuncCallNode FuncCallNode = new FuncCallNode(token);
     93                FuncCallNode.appendChild(identifier);
     94                FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
     95
     96                return FuncCallNode;
     97        }       
     98               
    7799        private static void addFuncCallArgs(FuncCallNode node, ASTNode[] args) {
    78100                if(args.length > 0) {
     
    82104                        Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
    83105                }       
    84         }
    85 
    86         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode ...args) {
    87        
    88                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
    89                 List<ASTNode> list = new ArrayList<ASTNode>();
    90                 for(ASTNode arg: args) {
    91                         list.add(arg);
    92                 }
    93                 Generators.addFuncCallsArgs(node, list);
    94                 return node;
    95         }
    96 
    97         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken,  List<ASTNode> args) {
    98                
    99                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
    100                 Generators.addFuncCallsArgs(node, args);
    101                 return node;
    102         }       
    103        
    104         private static void addFuncCallsArgs(FuncCallNode node, List<ASTNode> args) {
     106        }       
     107
     108        private static void addFuncCallArgs(FuncCallNode node, List<ASTNode> args) {
    105109               
    106110                if(args.size() > 0) {
     
    110114                        Accessors.funcCallArgsListNode(node).setToken(args.get(0).getToken());
    111115                }               
    112         }
    113        
    114         private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
    115                 assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    116 
    117                 LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
    118                 FuncCallNode FuncCallNode = new FuncCallNode(token);
    119                 FuncCallNode.appendChild(identifier);
    120                 FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
    121 
    122                 return FuncCallNode;
    123         }       
    124                
     116        }       
     117                       
    125118        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from token.
    126119         * Currently, no special consideration with only one identifier in the array.
     
    199192        }
    200193       
     194        public static IntConstantToken makeIntegerConstantToken(int n, Token locationToken) {
     195                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
     196        }       
     197       
    201198        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token locationToken) {
    202199                BinaryOperatorNode node = new BinaryOperatorNode(locationToken);
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins.java

    r3010 r3098  
    66public enum PabloSBuiltins {
    77
     8        // // TODO - Update explicit arg types
    89    ADVANCE("Advance", CarryType.One, 1),
    910    SCANTOFIRST("ScanToFirst", CarryType.One, 1),
     
    1516    INCLUSIVESPAN("InclusiveSpan", CarryType.One, 2),
    1617    EXCLUSIVESPAN("ExclusiveSpan", CarryType.One, 2),   
    17 
     18   
     19    ADVANCEN("Advance", CarryType.N, 2),   
    1820    ADVANCE32("Advance32", CarryType.N, 1),
    19     ADVANCEN("Advance", CarryType.N, 2),
    2021
    2122    MASK("Mask", CarryType.None, 2),   
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinsUtil.java

    r3010 r3098  
    1111    public static final String BUILTIN_PACKAGE_NAME = "pablo";
    1212       
    13     public static boolean isAdvance(ASTNode node) {
    14         if(node == null) {
    15                 return false;
    16         }
     13   
     14    public static boolean isMask(FuncCallNode node) { // Advance(X) || Advance(X,n)
     15               
     16                if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.MASK.pabloSName(), PabloSBuiltins.MASK.argCount())) {
     17                    return true;
     18                }       
     19        return false;       
     20    }   
     21   
     22    public static boolean isAdvance(FuncCallNode node) { // Advance(X) || Advance(X,n)
    1723       
    18         if (!(node instanceof FuncCallNode)) {
    19             return false;
    20         }
    21        
    22         FuncCallNode fNode = (FuncCallNode)node;
    23         ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
    24         ASTNode ArgsListNode = (ASTNode)Accessors.funcCallArgsListNode(fNode);
    25    
    26         // Advance(X)
    27         if (isQualifiedName(nameNode, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName())
    28                 && ArgsListNode.nChildren() == 1) { // TODO - update this check to include argument types, refactor to drop arg count
     24        if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName(), PabloSBuiltins.ADVANCE.argCount()) ||
     25                        isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName(), PabloSBuiltins.ADVANCEN.argCount())) {
    2926            return true;
    3027        }
    31 
    32         // Advance(X,n)
    33         if (isQualifiedName(nameNode, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName())
    34                 && ArgsListNode.nChildren() == 2) {     // TODO - update this check to include argument types, refactor to drop arg count
    35                         return true;
    36         }
    37        
    3828        return false;       
    3929    }
    4030
     31    public static boolean isAdvanceN(FuncCallNode node) { // Advance(X) || Advance(X,n)
     32       
     33        if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName(), PabloSBuiltins.ADVANCEN.argCount())) {
     34            return true;
     35        }
     36        return false;       
     37    }   
     38   
    4139    public static boolean isBuiltinOperations(ASTNode node) {
    4240       
     
    4947    }
    5048     
    51    
    52     public static boolean isCarryOne(ASTNode node) {
     49    public static boolean isCarryOne(FuncCallNode node) {
    5350       
    5451                for (PabloSBuiltins carryOneOperation : PabloSBuiltins.carryOneOperations()) {                         
    55                                
    56                         ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
    5752                        int argCount = Accessors.funcCallArgCount((FuncCallNode)node);
    58                        
    59                         if (isQualifiedName(identifier, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloSName())
    60                                 && argCount == carryOneOperation.argCount()) {
    61                     return true;
     53                if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloSName(), carryOneOperation.argCount())){
     54                                return true;
    6255                }               
    6356                }
     
    6558    }
    6659   
    67     public static boolean isCarryN(ASTNode node) {
    68                
    69                 for (PabloSBuiltins carryNOperation : PabloSBuiltins.carryNOperations()) {
    70                         ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
    71                         int argCount = Accessors.funcCallArgCount((FuncCallNode) node);
    72                        
    73                 if (isQualifiedName(identifier, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloSName())
    74                         && argCount == carryNOperation.argCount()) {
     60    public static boolean isCarryN(FuncCallNode node) {
     61
     62        for (PabloSBuiltins carryNOperation : PabloSBuiltins.carryNOperations()) {
     63                    if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloSName(), carryNOperation.argCount())){
    7564                        return true;
    7665                }               
     
    8473                return value;
    8574        }
    86    
    87     /** Returns true if the node represents a call to the
    88      *  given built-in Func.
    89      * 
    90      * @param node                  node to be checked
    91      * @return                      whether the node is a call of the Func
    92      */
    93     public static boolean isBuiltInCallNoArgCount(ASTNode node) {
    94         if(!(node instanceof FuncCallNode)) {
    95             return false;
    96         }
    9775       
    98         FuncCallNode fNode = (FuncCallNode)node;
    99         ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
    100 
    101         for (PabloSBuiltins builtin : PabloSBuiltins.values()) {
    102             if (isQualifiedName(nameNode, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
    103                 return true;
    104             }
    105         }
    106                
    107         return false;
    108     }
    109    
    110     /** Returns true if the node represents a call to the
    111      *  given built-in Func with the given number of Args.
    112      * 
    113      * @param node                  node to be checked
    114      * @return                      whether the node is a call of the Func with argNumToMatch Args
    115      */
    116     public static boolean isBuiltInCall(ASTNode node) {
    117        
     76    public static boolean isBuiltInCall(FuncCallNode node) {
    11877        for (PabloSBuiltins builtin : PabloSBuiltins.values()) {   
    11978            if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName(), builtin.argCount())) {
     
    12180            }
    12281        }       
    123 
    12482        return false;
    12583    }
    12684   
    127     /** Returns true if the node represents a call to the
    128      *  given Func with the given number of Args.
     85    /** Returns true if the node represents a call to the given function with the given number of args.
    12986     *  If node does not have a packageName attached, it is assumed to match the given packageName.
    13087     * 
    13188     * @param node                  node to be checked
    13289     * @param packageName           package name that must be matched.
    133      * @param FuncName          name of Func to be matched
     90     * @param FuncName                   name of Func to be matched
    13491     * @param numArgs               number of Args to be matched
    13592     * @return                      whether the node is a call of the Func with argNumToMatch Args
    13693     */
    137     public static boolean isCall(ASTNode node, String packageName, String FuncName, int numArgs) {
     94    public static boolean isCall(FuncCallNode node, String packageName, String FuncName, int numArgs) {
    13895        if(!(node instanceof FuncCallNode)) {
    13996            return false;
    14097        }
    14198       
    142         FuncCallNode fNode = (FuncCallNode)node;
    143         ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
     99        FuncCallNode funcNode = (FuncCallNode)node;
     100        ASTNode nameNode = Accessors.funcCallIdentifier(funcNode);
    144101
    145102        boolean nameMatches = isQualifiedName(nameNode, packageName, FuncName);
    146         boolean numArgsMatches = Accessors.funcCallArgsListNode(fNode).nChildren() == numArgs;
     103        boolean numArgsMatches = Accessors.funcCallArgsListNode(funcNode).nChildren() == numArgs;
    147104       
    148105        return nameMatches && numArgsMatches;
    149106    }
    150107   
    151     /** Determines if node represents the name of the Func described by packageName, FuncName.
     108    /** Returns true if node represents the name of the function described by packageName, FuncName.
    152109     *  In particular, if node represents a simple (non-qualified) name, then it is compared with FuncName.
    153110     *  (Essentially, this assumes that the packageName is correct.)
     
    156113     * @param node
    157114     * @param packageName
    158      * @param FuncName
     115     * @param funcName
    159116     * @return True if the node matches packageName.FuncName.
    160117     */
    161     public static boolean isQualifiedName(ASTNode node, String packageName, String FuncName) {
     118    public static boolean isQualifiedName(ASTNode node, String packageName, String funcName) {
    162119        if(node instanceof IdentifierNode) {           
    163             return Accessors.name(node) == FuncName;
     120            return Accessors.name(node) == funcName;
    164121        }
    165122        else if (node instanceof CompoundIdentifierNode) {
     
    168125           
    169126            return   (Accessors.name(pckage) == packageName) &&
    170                      (Accessors.name(member) == FuncName);
     127                     (Accessors.name(member) == funcName);
    171128        }
    172129        return false;
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/AdvanceCombinerXFormer.java

    r3010 r3098  
    7474       
    7575        private boolean isAdvanceOfAdvance(ASTNode node) {
    76                 if(!PabloSBuiltinsUtil.isAdvance(node)) {
     76               
     77                if(!(node instanceof FuncCallNode)) {
     78                        return false;
     79                }
     80               
     81                if(!PabloSBuiltinsUtil.isAdvance((FuncCallNode) node)) {
    7782                        return false;
    7883                }                       
     
    8085                ASTNode argsList = Accessors.funcCallArgsListNode((FuncCallNode) node);
    8186               
    82                 return PabloSBuiltinsUtil.isAdvance(argsList.child(0));
     87                if(argsList.child(0) instanceof FuncCallNode) {
     88                        return PabloSBuiltinsUtil.isAdvance((FuncCallNode)argsList.child(0));
     89                } else {
     90                        return false;
     91                }
     92               
     93               
    8394        }
    8495       
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/AdvanceNCounterVisitor.java

    r3010 r3098  
    3131
    3232                public void visitLeave(FuncCallNode node) {
    33                         if(PabloSBuiltinsUtil.isCarryN(node)) {
     33                        if(PabloSBuiltinsUtil.isAdvanceN(node)) {
    3434                            this.advNCount += 1;
    3535                        }
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/CarryInfoSetVisitor.java

    r3010 r3098  
    4848                        }
    4949                       
    50                         if(PabloSBuiltinsUtil.isCarryN(node)) {
     50                        //      if(PabloSBuiltinsUtil.isCarryN(node)) {
    5151                        //      List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    5252                        //      String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
    5353                        //      ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
    54                         }
    55                        
     54                        //      }
    5655                }
    57 
    5856        }
    5957}
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r3010 r3098  
    99import toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
    1010import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
     11import toolchain.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins;
    1112import toolchain.pabloB.lang.idisa.IDISASIMDBuiltins;
    1213import toolchain.pabloS.ast.Accessors;
    1314import toolchain.pabloS.ast.Generators;
    1415import toolchain.pabloS.lang.*;
    15 
     16/*
     17 * WARNING: Optimizes on final block. Explicit translation to PabloB IDISA constant. Mask
     18 */
    1619
    1720/*
     
    138141                //private int lastStmtCarries;
    139142       
    140                 @SuppressWarnings("static-access")
    141143                XFormer(/*boolean finalBlockModeboolean ciMode , boolean coMode */) {
    142144                       
     
    190192                               
    191193                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    192                                                 new String [] { getCarrySetIdentifier(),
    193                                                                                 carrySet2Lang.getCode(CarrySetBuiltins.CARRYADJUST)},
     194                                                new String [] { getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYADJUST)},
    194195                                                                                node.getToken(),
    195196                                                                                carry1CountNode);
     
    232233                        ASTNode replacementNode;
    233234                       
    234                         ASTNode carryAtCallOrConstant;
     235                        ASTNode carryAtCallOrMask;
    235236                        IntegerConstantNode currentCarry = Generators.makeIntegerConstantNode(this.currentCarry, node.getToken());
    236237                       
    237                         ASTNode pending64CallOrConstant;
     238                        ASTNode pending64CallOrMask;
    238239                        IntegerConstantNode currentAdvN = Generators.makeIntegerConstantNode(this.currentAdvN, node.getToken());
    239240
     
    246247                       
    247248                        if(isCiMode()) {
    248                                 carryAtCallOrConstant = Generators.makeFuncCallNode(
    249                                                 new String [] {getCarrySetIdentifier(),
    250                                                                 carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
     249                                carryAtCallOrMask = Generators.makeFuncCallNode(
     250                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
    251251                                                node.getToken(),
    252252                                                currentCarry);
    253253                               
    254                                 pending64CallOrConstant = Generators.makeFuncCallNode(
    255                                                 new String [] {getCarrySetIdentifier(),
    256                                                                 carrySet2Lang.getCode(CarrySetBuiltins.PENDING64)},
     254                                pending64CallOrMask = Generators.makeFuncCallNode(
     255                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.PENDING64)},
    257256                                                node.getToken(),
    258257                                                currentAdvN);
    259258                        } else {
    260                                 carryAtCallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1", "0"), node.getToken());
    261                                 pending64CallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1", "0"), node.getToken());
     259                               
     260                                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
     261                                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, node.getToken());
     262                               
     263                                carryAtCallOrMask = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
     264                                                node.getToken(),
     265                                                fieldWidthNode, zeroConstantNode);
     266                               
     267                                pending64CallOrMask = carryAtCallOrMask.deepCopy();
    262268                        }
    263269                                               
     
    280286                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCE),
    281287                                                arguments,
    282                                                 carryAtCallOrConstant,
     288                                                carryAtCallOrMask,
    283289                                                currentCarry);
    284290                               
     
    303309                                                builtins2Lang.getCode(PabloSBuiltins.SCANTHRU),
    304310                                                arguments,
    305                                                 carryAtCallOrConstant,
     311                                                carryAtCallOrMask,
    306312                                                currentCarry);
    307313                                this.currentCarry += 1;
     
    326332                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCETHENSCANTHRU),
    327333                                                arguments,
    328                                                 carryAtCallOrConstant,
     334                                                carryAtCallOrMask,
    329335                                                currentCarry);
    330336                                this.currentCarry += 1;
     
    349355                                                builtins2Lang.getCode(PabloSBuiltins.SPANUPTO),
    350356                                                arguments,
    351                                                 carryAtCallOrConstant,
     357                                                carryAtCallOrMask,
    352358                                                currentCarry);                         
    353359                                this.currentCarry += 1;
     
    382388                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCETHENSCANTHRU),
    383389                                                arguments,
    384                                                 carryAtCallOrConstant,
     390                                                carryAtCallOrMask,
    385391                                                currentCarry);
    386392                                this.currentCarry += 1;
     
    406412                                                builtins2Lang.getCode(PabloSBuiltins.INCLUSIVESPAN),
    407413                                                arguments,
    408                                                 carryAtCallOrConstant,
     414                                                carryAtCallOrMask,
    409415                                                currentCarry);
    410416                                this.currentCarry += 1;
     
    430436                                                builtins2Lang.getCode(PabloSBuiltins.EXCLUSIVESPAN),
    431437                                                arguments,
    432                                                 carryAtCallOrConstant,
     438                                                carryAtCallOrMask,
    433439                                                currentCarry);
    434440                                this.currentCarry += 1;
     
    465471                                                builtins2Lang.getCode(PabloSBuiltins.SCANTHRU),
    466472                                                arguments,
    467                                                 carryAtCallOrConstant,
     473                                                carryAtCallOrMask,
    468474                                                currentCarry);
    469475                                this.currentCarry += 1;
     
    499505                                                builtins2Lang.getCode(PabloSBuiltins.SCANTOFIRST),
    500506                                                arguments,
    501                                                 carryAtCallOrConstant,
     507                                                carryAtCallOrMask,
    502508                                                currentCarry);
    503509                                this.currentCarry += 1;
     
    524530                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCE32),
    525531                                                arguments,
    526                                                 pending64CallOrConstant,
     532                                                pending64CallOrMask,
    527533                                                currentAdvN);
    528534                                this.currentAdvN += 1;
     
    551557                                                formattedAdvanceN,
    552558                                                arguments.subList(0, arguments.size()-1),
    553                                                 pending64CallOrConstant,
     559                                                pending64CallOrMask,
    554560                                                currentAdvN);           
    555561                                this.currentAdvN += 1;                 
     
    564570                                        ASTNode argNode = Accessors.funcCallArg(node, 0);
    565571                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    566                                 } else {                                       
    567                                         replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1", "0"), node.getToken());                                     
     572                                } else {                               
     573                                       
     574                                        IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
     575                                        IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, node.getToken());
     576                                       
     577                                        replacementNode = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
     578                                                                                node.getToken(),
     579                                                                                fieldWidthNode, zeroConstantNode);                                     
    568580                                }
    569581                                node.updateSelf(replacementNode);
     
    618630                                        PabloSBuiltins.MASK.argCount())) {
    619631                               
    620                                         replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1","0"), node.getToken());                               
     632                                        IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
     633                                        IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, node.getToken());
     634                                       
     635                                        replacementNode = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
     636                                                node.getToken(),
     637                                                fieldWidthNode, zeroConstantNode);
    621638                                       
    622639                                        node.updateSelf(replacementNode);
     
    751768
    752769                        FuncCallNode carryLocalCombine = (FuncCallNode) Generators.makeFuncCallNode(
    753                                         new String [] {carrySet2Lang.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE)},
     770                                        carrySet2Lang.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
    754771                                        node.getToken(),
    755772                                        carrySetIdentifierNode, localCarrySetIdentifierNode, carryBaseNode, carry1CountNode);
     
    837854                       
    838855                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    839                                         new String [] {getCarrySetIdentifier(),
    840                                                                         carrySet2Lang.getCode(CarrySetBuiltins.CARRYRANGE)},
     856                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYRANGE)},
    841857                                                                        lhs.getToken(),
    842858                                                                        carryBaseNode, carryCountNode);
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r3033 r3098  
    1313import pabloB.ast.ASTNode;
    1414import pabloB.ast.FuncCallNode;
     15import pabloB.ast.IdentifierNode;
    1516import pabloS.ast.ASTVisitor.Default;
     17import pabloS.lexicalAnalyzer.LexicalType;
     18import pabloS.lexicalAnalyzer.Lextant;
     19import pabloS.tokens.IntConstantToken;
     20import pabloS.tokens.Token;
    1621import toolchain.pabloB.ast.Generators;
    1722import toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
     
    1924import toolchain.pabloB.symbols.CarryInfoSetSymbol;
    2025import toolchain.pabloB.symbols.SymbolTable;
     26import toolchain.pabloS.ast.Accessors;
     27import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    2128
    2229public class PabloS2PabloBXFormer {
     
    275282               
    276283                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallNode node, List<pabloB.ast.ASTNode> childResults) {
    277                         pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallNode(Generators.makePabloBToken(node.getToken()));
    278                         appendChildResults(bNode, childResults);
     284                       
     285                        pabloB.ast.ASTNode bNode = null;
     286                       
     287                        if(PabloSBuiltinsUtil.isMask(node)) { // translate Mask(fw,constant) tp IDISA call
     288                               
     289                                pabloS.tokens.LextantToken lAngleToken
     290                                = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.LANGLE, node.getToken());
     291               
     292                                bNode = new pabloB.ast.IdisaFuncCallNode(Generators.makePabloBToken(lAngleToken)); //
     293                               
     294                                pabloS.tokens.LextantToken dotToken
     295                                        = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.DOT, node.getToken());
     296                                                       
     297                                pabloB.ast.ASTNode compoundIdentifierNode
     298                                        = Generators.makeCompoundIdentifierNode(new String [] {"simd","constant"},
     299                                                                                                                                Generators.makePabloBToken(dotToken));
     300                               
     301                                // field width integer constant
     302                                int fieldWidthValue
     303                                        = Integer.valueOf(Accessors.funcCallArg(node, 0).getToken().getLexeme());
     304                               
     305                                pabloS.tokens.IntConstantToken fieldWidthConstantToken
     306                                        = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(fieldWidthValue, node.getToken());
     307                               
     308                                pabloB.ast.ASTNode fieldWidthConstantNode
     309                                        = new pabloB.ast.IntegerConstantNode(Generators.makePabloBToken(fieldWidthConstantToken));
     310                                                               
     311                                pabloB.ast.ASTNode fieldWidthNode
     312                                        = new pabloB.ast.FieldWidthNode(Generators.makePabloBToken(fieldWidthConstantToken));
     313                               
     314                                fieldWidthNode.appendChild(fieldWidthConstantNode);
     315                               
     316                                // mask integer constant
     317                                int maskValue
     318                                        = Integer.valueOf(Accessors.funcCallArg(node, 1).getToken().getLexeme());
     319                               
     320                                pabloS.tokens.IntConstantToken maskToken
     321                                        = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(maskValue, node.getToken());
     322
     323                                pabloB.ast.ASTNode maskConstantNode
     324                                        = new pabloB.ast.IntegerConstantNode(Generators.makePabloBToken(maskToken));
     325                               
     326                                ((pabloB.ast.IntegerConstantNode)maskConstantNode).setValue(maskValue);
     327                               
     328                                // argument list
     329                                pabloB.ast.IdisaFuncCallArgListNode idisaFuncCallArgListNode
     330                                        = new pabloB.ast.IdisaFuncCallArgListNode(Generators.makePabloBToken(maskToken));
     331                               
     332                                idisaFuncCallArgListNode.appendChild(maskConstantNode);
     333                               
     334                                bNode.appendChild(compoundIdentifierNode);
     335                                bNode.appendChild(fieldWidthNode);
     336                                bNode.appendChild(idisaFuncCallArgListNode);
     337                                                               
     338                        } else {
     339                                bNode = new pabloB.ast.FuncCallNode(Generators.makePabloBToken(node.getToken()));
     340                                appendChildResults(bNode, childResults);
     341                        }
     342                       
    279343                        return bNode;
    280344                }
Note: See TracChangeset for help on using the changeset viewer.