Changeset 3372 for proto/pabloj/trunk


Ignore:
Timestamp:
Jun 28, 2013, 12:32:40 PM (6 years ago)
Author:
ksherdy
Message:

Refactored surroundWithSRLI

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3360 r3372  
    11package toolchain.pabloS.lang;
     2
     3import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_CONSTANT;
    24
    35import java.util.ArrayList;
    46import java.util.List;
    57
    6 import pabloS.ast.ASTNode;
     8import pabloB.ast.*;
     9import pabloB.inputHandler.*;
     10import pabloB.ast.IntegerConstantNode;
     11//import pabloS.ast.ASTNode;
    712import pabloS.ast.FuncCallNode;
    8 import pabloS.inputHandler.Locator;
     13//import pabloS.inputHandler.Locator;
    914import toolchain.pabloB.lang.idisa.IDISABitBlockBuiltins;
    1015import toolchain.pabloS.ast.Accessors;
     
    2025
    2126public enum PabloSBuiltinTranslator {
     27   
     28    ASSERT_ZERO_TRANSLATION {
     29        public void  translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context) {
     30           
     31        }
     32    },
     33   
    2234        CARRY_TRANSLATION {     
    23                 public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
    24             List<ASTNode> arguments = Accessors.argsList(node);
    25             Locator locator = node;
    26             replaceCallWithPabloBlkCall(node,
     35                public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     36            List<pabloS.ast.ASTNode> arguments = Accessors.argsList(snode);
     37            pabloS.inputHandler.Locator locator = snode;
     38            replaceCallWithPabloBlkCall(snode,
    2739                                        context.getCode(builtin),
    2840                                        arguments,
    2941                                        Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context),
    3042                                        returnValue);
     43            //surroundWithIDISASRLI(snode, locator, snode);
    3144                }
    3245        },
    3346
    3447        ADVANCEN_TRANSLATION {
    35                 public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
    36                     ASTNode formatValue = Accessors.argument(node, 1);
     48                public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     49                    pabloS.ast.ASTNode formatValue = Accessors.argument(snode, 1);
    3750                    String value = Accessors.lexeme(formatValue);
    38                     List<ASTNode> arguments = removeAdvanceNConstantArg(node);
     51                    List<pabloS.ast.ASTNode> arguments = removeAdvanceNConstantArg(snode);
    3952
    4053                    String templateCode = context.getCode(builtin);
    4154                    String formattedAdvanceN = String.format(templateCode, value);         
    42                     Locator locator = node;
     55                    pabloS.inputHandler.Locator locator = snode;
    4356                   
    44                     replaceCallWithPabloBlkCall(node,
     57                    replaceCallWithPabloBlkCall(snode,
    4558                                                formattedAdvanceN,
    4659                                                arguments,
    4760                                                Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context), 
    4861                                                returnValue);
     62                    //surroundWithIDISASRLI(snode, locator, snode);
    4963                }
    5064
    51         private List<ASTNode> removeAdvanceNConstantArg(FuncCallNode node) {
    52             List<ASTNode> arguments = Accessors.argsList(node);
     65        private List<pabloS.ast.ASTNode> removeAdvanceNConstantArg(pabloS.ast.FuncCallNode node) {
     66            List<pabloS.ast.ASTNode> arguments = Accessors.argsList(node);
    5367                    arguments.remove(arguments.size()-1);
    5468            return arguments;
     
    5771       
    5872        SCANTO_TRANSLATION {
    59         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
    60             scanToTranslate(PabloSBuiltin.SCAN_THRU, node, counter, context, returnValue);
     73        public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     74            scanToTranslate(PabloSBuiltin.SCAN_THRU, snode, counter, context, returnValue);
    6175        }
    6276    },
    6377
    6478    ADVANCE_THEN_SCANTO_TRANSLATION {
    65         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
    66             scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context, returnValue);
     79        public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     80            scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, counter, context, returnValue);
    6781        }
    6882    },
    6983   
    7084    ATEOF_TRANSLATION {
    71         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     85        public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context) {
    7286            if(context.isFinalBlockMode()) {
    73                 ASTNode arg = Accessors.argument(node, 0);
    74                 ASTNode replacement = Generators.makeSIMDAndCEOFMaskFuncCall(arg, context.getBuiltinEncoder());
    75                 node.updateSelf(replacement);
     87                pabloS.ast.ASTNode arg = Accessors.argument(snode, 0);
     88                pabloS.ast.ASTNode replacement = Generators.makeSIMDAndCEOFMaskFuncCall(arg, context.getBuiltinEncoder());
     89                snode.updateSelf(replacement);
    7690            }
    7791            else {             
    78                 Locator locator = node;
    79                 ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
    80                 node.updateSelf(maskCall);         
     92                pabloS.inputHandler.Locator locator = snode;
     93                pabloS.ast.ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
     94                snode.updateSelf(maskCall);         
    8195            }
    8296        }
     
    8498
    8599    INFILE_TRANSLATION {
    86         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     100        public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context) {
    87101            if(context.isFinalBlockMode()) {                   
    88                 ASTNode arg = Accessors.argument(node, 0);
    89                 ASTNode replacement = Generators.makeSIMDAndEOFMaskFuncCall(arg, context.getBuiltinEncoder());
    90                 node.updateSelf(replacement);
     102                pabloS.ast.ASTNode arg = Accessors.argument(snode, 0);
     103                pabloS.ast.ASTNode replacement = Generators.makeSIMDAndEOFMaskFuncCall(arg, context.getBuiltinEncoder());
     104                snode.updateSelf(replacement);
    91105            } else {
    92                 node.updateSelf(Accessors.argument(node,0));
     106                snode.updateSelf(Accessors.argument(snode,0));
    93107            }
    94108        }       
     
    96110
    97111    MASK_TRANSLATION {
    98         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    99             Locator locator = node;
    100             ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
    101             node.updateSelf(maskCall);     
     112        public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context) {
     113            pabloS.inputHandler.Locator locator = snode;
     114            pabloS.ast.ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
     115            snode.updateSelf(maskCall);     
    102116        }
    103117    };
    104118   
    105     private static void scanToTranslate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
    106         ASTNode argument = Accessors.argument(node, 1);
     119    private static void scanToTranslate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     120        pabloS.ast.ASTNode argument = Accessors.argument(snode, 1);
    107121        translateArgument(context, argument);
    108         ASTNode replacement = Generators.makeCompoundIdentifierNode(node,
     122        pabloS.ast.ASTNode replacement = Generators.makeCompoundIdentifierNode(snode,
    109123                BuiltinCallUtil.BUILTIN_PACKAGE_NAME, translatedBuiltin.pabloSName());
    110124
    111         node.replaceChild(Accessors.nameNode(node), replacement);
    112         CARRY_TRANSLATION.translate(translatedBuiltin, node, counter, context, returnValue);
    113     }
    114    
    115     private static void translateArgument(Context context, ASTNode argument) {
     125        snode.replaceChild(Accessors.nameNode(snode), replacement);
     126        CARRY_TRANSLATION.translate(translatedBuiltin, snode, counter, context, returnValue);
     127    }
     128   
     129    private static void translateArgument(Context context, pabloS.ast.ASTNode argument) {
    116130        if(context.isFinalBlockMode()) {
    117             ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     131            pabloS.ast.ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    118132            argument.updateSelf(replacement);
    119133        }
    120134        else {
    121             ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     135            pabloS.ast.ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    122136            argument.updateSelf(replacement);           
    123137        }
     
    125139   
    126140    // TODO - KH: Added to support multiple 'translate' signatures. May be a poor use of Java.
    127     public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
     141    public void translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Context context) {
    128142        assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    129143    }
    130144   
    131         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
     145    public void translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Counter counter, Context context) {
     146        assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     147    }
     148   
     149        public void translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    132150            assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    133151        }
    134152
    135153        // helper methods
     154       
     155    private ASTNode makeAllZeroesCall(pabloS.ast.FuncCallNode snode) {
     156       
     157        String idisaPackage = SIMD_CONSTANT.packageName();
     158        String idisaOperation = SIMD_CONSTANT.baseName();
     159
     160        int fw            = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 0).getToken().getLexeme());
     161        int value         = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(snode, 1).getToken().getLexeme());
     162       
     163        Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     164        IntegerConstantNode valueNode = toolchain.pabloB.ast.Generators.makeIntegerConstantNode(locator, value);
     165       
     166        ASTNode replacement = toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, idisaPackage, idisaOperation, fw, valueNode);
     167        return replacement;
     168    }
     169       
    136170    private static void replaceCallWithPabloBlkCall (
    137             FuncCallNode node,
     171            pabloS.ast.FuncCallNode snode,
    138172            String carryBuiltin,                           
    139             List<ASTNode> arguments,                       
    140             ASTNode call,                                   
    141             ASTNode returnValue) {
    142        
    143         ASTNode [] args = makePabloBlkCallArgs(arguments, call, returnValue.deepCopy());
    144        
    145         Locator locator = node;
     173            List<pabloS.ast.ASTNode> arguments,                       
     174            pabloS.ast.ASTNode call,                                   
     175            pabloS.ast.ASTNode returnValue) {
     176       
     177        pabloS.ast.ASTNode [] args = makePabloBlkCallArgs(arguments, call, returnValue.deepCopy());
     178       
     179        pabloS.inputHandler.Locator locator = snode;
    146180        FuncCallNode pabloBlkFuncCall = Generators.makeFuncCallNode(
    147181                locator,
    148182                carryBuiltin,
    149183                args);
    150 
    151         surroundWithIDISASRLI(node, locator, pabloBlkFuncCall);
    152     }
    153 
    154     private static void surroundWithIDISASRLI(FuncCallNode node,
    155             Locator locator, FuncCallNode pabloBlkFuncCall) {
    156         FuncCallNode replacementNode    = Generators.makeFuncCallNode(locator,
    157                                                                         IDISABitBlockBuiltins.SRLI.IDISALexeme(),
    158                                                                         pabloBlkFuncCall); // TODO - KH: IDISA
    159        
    160         node.updateSelf(replacementNode);
     184       
     185               
     186        FuncCallNode idisaSRLI = makeIDISASRLI(locator, pabloBlkFuncCall);
     187        snode.updateSelf(idisaSRLI);
     188       
     189    }
     190
     191    private static FuncCallNode makeIDISASRLI( pabloS.inputHandler.Locator locator, FuncCallNode snode) {
     192        return Generators.makeFuncCallNode(locator,
     193                IDISABitBlockBuiltins.SRLI.IDISALexeme(),
     194                snode.deepCopy()); // TODO - KH: IDISA
    161195    }   
    162196       
    163     private static ASTNode [] makePabloBlkCallArgs(List<ASTNode> arguments,
    164             ASTNode call, ASTNode returnValue) {
    165         List<ASTNode> args = new ArrayList<ASTNode>(arguments);
     197    private static pabloS.ast.ASTNode [] makePabloBlkCallArgs(List<pabloS.ast.ASTNode> arguments,
     198            pabloS.ast.ASTNode call, pabloS.ast.ASTNode returnValue) {
     199        List<pabloS.ast.ASTNode> args = new ArrayList<pabloS.ast.ASTNode>(arguments);
    166200        args.add(call);
    167201        args.add(returnValue);
    168         return args.toArray(new ASTNode [args.size()]);
     202        return args.toArray(new pabloS.ast.ASTNode [args.size()]);
    169203    }   
    170204   
Note: See TracChangeset for help on using the changeset viewer.