Changeset 3348


Ignore:
Timestamp:
Jun 21, 2013, 5:33:03 PM (6 years ago)
Author:
ksherdy
Message:

Updated PabloSBuiltinTranslation organization.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
2 deleted
3 edited
1 moved

Legend:

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

    r3325 r3348  
    55
    66import toolchain.pabloS.lang.signatures.FunctionSignature;
     7import static toolchain.pabloS.lang.PabloSBuiltinTranslator.*;
    78import static toolchain.pabloS.lang.signatures.SignatureShorthand.*;
    8 import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
    9 import static toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator.*;
    10 import static toolchain.pabloS.transformer.visitors.carry.CarryBuiltinTranslator.*;
    119
    1210public enum PabloSBuiltin {
     
    3634        private final String name;
    3735        private final FunctionSignature signature;
    38         private final BuiltinTranslator translator;
     36        private final PabloSBuiltinTranslator translator;
    3937
    4038       
    41         private PabloSBuiltin(String name, CarryType carryType, BuiltinTranslator translator, FunctionSignature signature, InitialValue initialValue) {
     39        private PabloSBuiltin(String name, CarryType carryType, PabloSBuiltinTranslator translator, FunctionSignature signature, InitialValue initialValue) {
    4240                this.name = name;
    4341                this.carryType = carryType;
     
    4745        }
    4846
    49         private PabloSBuiltin(String name, CarryType carryType, BuiltinTranslator translator, FunctionSignature signature) {
     47        private PabloSBuiltin(String name, CarryType carryType, PabloSBuiltinTranslator translator, FunctionSignature signature) {
    5048                this(name, carryType, translator, signature, InitialValue.Zero);
    5149        }
     
    7876        public final boolean isCarry1() { return carryType == CarryType.One; }
    7977        public final boolean isCarryN() { return carryType == CarryType.N; }
    80         public final BuiltinTranslator getTranslator() { return translator; }
     78        public final PabloSBuiltinTranslator getTranslator() { return translator; }
    8179        public final InitialValue getInitialValue() { return initialValue; }
    8280        public final int intInitialValue() { return (initialValue == InitialValue.One) ? 1 : 0; }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3345 r3348  
    1 package toolchain.pabloS.transformer.visitors.carry;
     1package toolchain.pabloS.lang;
    22
    33import java.util.ArrayList;
     
    1010import toolchain.pabloS.ast.Accessors;
    1111import toolchain.pabloS.ast.Generators;
    12 import toolchain.pabloS.lang.PabloSBuiltin;
    13 import toolchain.pabloS.lang.BuiltinCallUtil;
    14 import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
     12import toolchain.pabloS.transformer.visitors.carry.Context;
     13import toolchain.pabloS.transformer.visitors.carry.Counter;
    1514
    1615// BuiltinTranslators translate a builtin call from pabloS to pabloB during the
     
    2019// having to instantiate the commands.
    2120
    22 public enum CarryBuiltinTranslator implements BuiltinTranslator {
     21public enum PabloSBuiltinTranslator {
    2322        CARRY_TRANSLATION {     
    2423                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
     
    6766            scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context, returnValue);
    6867        }
     68    },
     69   
     70    ATEOF_TRANSLATION {
     71        public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     72            if(context.isFinalBlockMode()) {
     73                ASTNode arg = Accessors.argument(node, 0);
     74                ASTNode replacement = Generators.makeSIMDAndCEOFMaskFuncCall(arg, context.getBuiltinEncoder());
     75                node.updateSelf(replacement);
     76            }
     77            else {             
     78                Locator locator = node;
     79                ASTNode maskCall = Generators.makeMaskFuncCall(locator, 1, 0);
     80                node.updateSelf(maskCall);         
     81            }
     82        }
     83    },
     84
     85    INFILE_TRANSLATION {
     86        public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     87            if(context.isFinalBlockMode()) {                   
     88                ASTNode arg = Accessors.argument(node, 0);
     89                ASTNode replacement = Generators.makeSIMDAndEOFMaskFuncCall(arg, context.getBuiltinEncoder());
     90                node.updateSelf(replacement);
     91            } else {
     92                node.updateSelf(Accessors.argument(node,0));
     93            }
     94        }       
     95    },
     96
     97    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);     
     102        }
    69103    };
    70104   
     
    89123        }
    90124    }   
    91 
    92         abstract public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue);
     125   
     126    // 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) {
     128        assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     129    }
     130   
     131        public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context, ASTNode returnValue) {
     132            assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     133        }
    93134
    94135        // helper methods
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3347 r3348  
    1111import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    1212import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    13 import toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator;
    1413
    1514/*
     
    153152                }
    154153                private FuncCallNode makeCarryAdjustmentCall(Locator location, int carry1Count) {
    155                         IntegerConstantNode carry1CountNode =  leaf(carry1Count, location);
     154                        IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, location);
    156155                       
    157156                        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
     
    175174                PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    176175                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    177                 CarryBuiltinTranslator translator = (CarryBuiltinTranslator) builtin.getTranslator();
     176                PabloSBuiltinTranslator translator = builtin.getTranslator();
    178177                IdentifierNode returnValue = lhs.deepCopy();
    179                 translator.translate(builtin, funcCall, counter, context, returnValue.deepCopy());
     178                translator.translate(builtin, funcCall, counter, context, returnValue);
    180179               
    181180                Locator locator = node;
     
    185184                    }
    186185                }
    187                
    188                 ///////////////////////////////////////////////////////////////////
    189                 // LocalVarDeclNode
    190                 public void visitLeave(VarDeclNode node) {
    191                     if(Accessors.hasInitializationExpr(node)) {
    192 
    193                         ASTNode rhs = Accessors.rhs(node);
    194                         if(BuiltinCallUtil.isCarry(rhs)) {
    195                             IdentifierNode lhs = (IdentifierNode) Accessors.identifier(node);
    196 
    197                             FuncCallNode funcCall = (FuncCallNode) rhs;
    198 
    199                             PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    200                             Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    201                             CarryBuiltinTranslator translator = (CarryBuiltinTranslator) builtin.getTranslator();
    202                             IdentifierNode returnValue = lhs;
    203                             translator.translate(builtin, funcCall, counter, context, returnValue);
    204 
    205                             Locator locator = node;
    206                             node.replaceChild(lhs, Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context));
    207                            
    208                             counter.increment();
    209                         }
    210                     }
    211                 }
    212186           
    213187                ///////////////////////////////////////////////////////////////////
     
    218192                                PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    219193                                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    220                                 CarryNoneBuiltinTranslator translator = (CarryNoneBuiltinTranslator) builtin.getTranslator();
     194                                PabloSBuiltinTranslator translator = builtin.getTranslator();
    221195                                translator.translate(builtin, node, counter, context);
    222196                        }       
     
    261235                private FuncCallNode makeCarryDequeueEnqueue(Locator location,
    262236                                int carryBase, int carry1Count) {
    263                         IntegerConstantNode carryBaseNode = leaf(carryBase, location);
    264                         IntegerConstantNode carryCountNode = leaf(carry1Count, location);
     237                        IntegerConstantNode carryBaseNode = Generators.leaf(carryBase, location);
     238                        IntegerConstantNode carryCountNode = Generators.leaf(carry1Count, location);
    265239                       
    266240                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
     
    442416                        Locator location = (Locator)condition;
    443417                       
    444                         ASTNode carryBaseNode  = leaf(carryBase, location);
    445                         ASTNode carryCountNode = leaf(carryCount, location);
     418                        ASTNode carryBaseNode  = Generators.leaf(carryBase, location);
     419                        ASTNode carryCountNode = Generators.leaf(carryCount, location);
    446420                        ASTNode carryRange = Generators.makeFuncCallNode(
    447421                                                                        location,
     
    453427                        return Generators.makeBinaryOperatorNode(condition, carryRange, or);
    454428                }
    455                
    456                
    457                
    458                 ///////////////////////////////////////////////////////////////////
    459                 // Utilities
    460                 public IntegerConstantNode leaf(int n, Locator locator) {
    461                         return Generators.makeIntegerConstantNode(locator, n);
    462                 }               
     429                       
    463430        }
    464431}       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarrySetBuiltinCalls.java

    r3347 r3348  
    135135        public void visitLeave(FuncCallNode node) {
    136136            if(BuiltinCallUtil.isCarry(node)) {
    137 
     137               
    138138                BlockStmtNode blockStmt          = getEnclosingBlockStmt(node);
    139139                Locator locator                  = blockStmt;
     
    142142                VarDeclNode varDecl              = Generators.makeVarDeclNode(locator, type, name.deepCopy());
    143143                AssignNode assignStmt            = Generators.makeAssignNode(locator, name.deepCopy(), node.deepCopy());
    144                
     144
    145145                addValueToList(enclBlockStmtTempDecls, blockStmt, varDecl);
    146146                addValueToList(enclBlockStmtTempAssigns, blockStmt, assignStmt);
     
    228228                return NO_ENCLOSING_BLOCK_STMT;
    229229            }
     230
     231            // TODO KH: test method isNonNestedCarryCall before use
     232/*        private boolean isNonNestedCarryCall(FuncCallNode node) {
     233            if(BuiltinCallUtil.isCarry(node)) {
     234                return isNonNestedTest(Accessors.argsListNode(node));
     235            }
     236           
     237            return true;
     238        }
     239       
     240        private boolean isNonNestedTest(ASTNode node) {
     241           
     242            if(BuiltinCallUtil.isCarry(node)) {
     243                return false;
     244            }
     245           
     246            boolean result = true;
     247            for(ASTNode child: node.getChildren()) {
     248                result = result && isNonNestedTest(child);
     249            }
     250            return result;
     251        }           
     252*/         
     253           
    230254    }
    231255}
Note: See TracChangeset for help on using the changeset viewer.