Changeset 3347


Ignore:
Timestamp:
Jun 21, 2013, 3:24:11 PM (6 years ago)
Author:
ksherdy
Message:

Centralized CarrySet? generation calls in PabloS and PabloB generators.

Location:
proto/pabloj/trunk/src
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3345 r3347  
    107107                        }
    108108                       
    109                         PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(streamFunctionPropertySetMap, carrySetEncoder);
     109                        PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(streamFunctionPropertySetMap, pabloSbuiltinsEncoder, carrySetEncoder);
    110110                        pabloBAST = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    111111                       
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3313 r3347  
    1313import pabloB.lexicalAnalyzer.Lextant;
    1414import toolchain.pabloB.ast.Accessors;
     15import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
     16import toolchain.pabloS.transformer.visitors.carry.Context;
    1517
    1618public class Generators {
     
    316318        return StringConstantToken.make(LexicalType.STRING, locator, string);
    317319    }
     320   
     321    public static FuncCallNode makeCarryFlipCall(Locator locator, int index, Context context) {
     322       
     323        IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, index);
     324       
     325       
     326        FuncCallNode carryFlipFuncCall = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
     327                                                                        context.getCode(CarrySetBuiltin.CARRYFLIP),
     328                                                                        Generators.arguments(indexNode));
     329       
     330        FuncCallNode setCarryFuncCall  = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
     331                                                                        context.getCode(CarrySetBuiltin.SETCARRY),
     332                                                                        Generators.arguments(carryFlipFuncCall,
     333                                                                        indexNode));
     334        return setCarryFuncCall;
     335    }
     336   
     337    public static FuncCallNode makeCarryDeclareCall(Locator locator, int carry1Count, int carryNCount, Context context) {
     338       
     339        IdentifierNode carrySetIdentifier       =   Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier());
     340        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
     341        IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
     342     
     343        FuncCallNode carryDeclareFuncCall       = Generators.makeFuncCallNode(locator,
     344                                                                                context.getCode(CarrySetBuiltin.CARRYDECLARE),
     345                                                                                Generators.arguments(carrySetIdentifier,
     346                                                                                                     carry1CountNode,
     347                                                                                                     carryNCountNode));       
     348       
     349       
     350       
     351                                                                                   
     352        return carryDeclareFuncCall;
     353    }
     354
     355   
     356    public static ASTNode[] arguments(ASTNode...astNodes) {
     357        return astNodes;
     358    }
    318359}
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3345 r3347  
    472472                return result;
    473473        }
    474        
    475         public static ASTNode[] arguments(ASTNode...astNodes) {
    476         return astNodes;
    477     }
    478474           
    479475}
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3345 r3347  
    1515import pabloS.lexicalAnalyzer.*;
    1616import pabloS.tokens.*;
    17 import toolchain.pabloB.lang.idisa.*;
     17
     18import toolchain.pabloB.lang.idisa.*; // TODO - IDISA builtins
    1819import toolchain.pabloS.lang.*;
    1920import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
     21
    2022import toolchain.pabloS.transformer.visitors.carry.Context;
    2123
     
    301303    }
    302304       
     305    public static FuncCallNode makeCarryDeclare(Locator location, int carry1Count,
     306            int carryNCount, Context localContext) {
     307       
     308        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
     309       
     310        FuncCallNode carryDeclare = Generators.makeFuncCallNode(
     311                            location,
     312                            localContext.getCode(CarrySetBuiltin.CARRYDECLARE),
     313                            localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
     314        return carryDeclare;
     315    }
     316    public static FuncCallNode makeLocalCarryCombine(Locator locator, int carryBase,
     317            int carry1Count, Context localContext) {
     318
     319        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
     320        ASTNode carryBaseNode = leaf(carryBase, locator);
     321        ASTNode carry1CountNode = leaf(carry1Count, locator);
     322       
     323        return Generators.makeFuncCallNode(
     324                    locator,
     325                    localContext.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
     326                    Generators.arguments(localContext.carrySetIdentifierNode(locator),
     327                              localCarrySetIdentifierNode,
     328                              carryBaseNode,
     329                              carry1CountNode));
     330
     331    }
     332    public static FuncCallNode makeLocalCarryDeclare(Locator location, int carry1Count,
     333            int carryNCount, Context localContext, Context context) {
     334       
     335        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
     336       
     337        FuncCallNode carryDeclare = Generators.makeFuncCallNode(
     338                            location,
     339                            context.getCode(CarrySetBuiltin.CARRYDECLARE),
     340                            localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
     341        return carryDeclare;
     342    }
     343    public static FuncCallNode makeLocalCarryCombine(Locator locator, int carryBase,
     344            int carry1Count, Context localContext, Context context) {
     345
     346        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
     347        ASTNode carryBaseNode = leaf(carryBase, locator);
     348        ASTNode carry1CountNode = leaf(carry1Count, locator);
     349       
     350        return Generators.makeFuncCallNode(
     351                    locator,
     352                    context.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
     353                    Generators.arguments(context.carrySetIdentifierNode(locator),
     354                              localCarrySetIdentifierNode,
     355                              carryBaseNode,
     356                              carry1CountNode));
     357
     358    }
     359    public static FuncCallNode makeCarryFlip(Locator locator, int index, Context context) {
     360       
     361        ASTNode indexNode = Generators.makeIntegerConstantNode(locator, index);
     362       
     363        return Generators.makeFuncCallNode(locator,
     364                                            context.getCode(CarrySetBuiltin.CARRYFLIP),
     365                                            Generators.arguments(context.carrySetIdentifierNode(locator),
     366                                            indexNode));
     367    }
     368   
     369    public static IntegerConstantNode leaf(int n, Locator locator) {
     370        return Generators.makeIntegerConstantNode(locator, n);
     371    }   
     372   
     373   
    303374    ///////////////////////////////////////////////////////////////////
    304375    // Helpers
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/CombineAdvances.java

    r3271 r3347  
    1212
    1313import pabloS.ast.*;
     14import pabloS.inputHandler.Locator;
    1415
    1516import pabloS.tokens.*;
     
    8687                        node.replaceChild(oldArgumentList, newArgumentList);
    8788                       
    88                         ASTNode amount = integerConstant(combinedAmount, node);
     89                        Locator locator = node;
     90                        ASTNode amount = Generators.makeIntegerConstantNode(locator, combinedAmount);
    8991                       
    9092                        // the following could be extracted, and maybe the line above, too.
     
    101103                        }
    102104                }
    103                 private IntegerConstantNode integerConstant(int n, ASTNode locationReference) {
    104                         return Generators.makeIntegerConstantNode(locationReference.getToken(), n);
    105                 }
    106105        }
    107106}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/ConvertBitwiseBooleanToIDISACalls.java

    r3327 r3347  
    5454                        ASTNode rhs = rhs(node);
    5555                        if(token.isLextant(Lextant.OR)) {
    56                                 return makeIDISACall(OR,
    57                                                                          Accessors.arguments(lhs, rhs),
    58                                                                          locator);
     56                                return makeIDISACall(locator,
     57                                                                         OR,
     58                                                                         Generators.arguments(lhs, rhs));
    5959                        }
    6060                        if(token.isLextant(Lextant.AND)) {
    6161                                // TS: this optimization seems inappropriate for pabloS to handle.
    6262                                if (rhs.getToken().isLextant(Lextant.NOT)) {                                           
    63                                         return  makeIDISACall(ANDC,
    64                                                                 Accessors.arguments(lhs, rhs.child(0)),
    65                                                                 locator);
     63                                        return  makeIDISACall(locator,
     64                                                                ANDC,
     65                                                                Generators.arguments(lhs, rhs.child(0)));
    6666                                }
    6767                                else if(lhs.getToken().isLextant(Lextant.NOT)) {
    68                                         return  makeIDISACall(ANDC,
    69                                                                 Accessors.arguments(rhs, lhs.child(0)),
    70                                                                 locator);
     68                                        return  makeIDISACall(locator,
     69                                                                ANDC,
     70                                                                Generators.arguments(rhs, lhs.child(0)));
    7171                                }
    7272                                else {
    73                                         return  makeIDISACall(AND,
    74                                                                 Accessors.arguments(lhs, rhs),
    75                                                                 locator);                                               
     73                                        return  makeIDISACall(locator,
     74                                                                AND,
     75                                                                Generators.arguments(lhs, rhs));                                               
    7676                                }
    7777                        }
    7878                        else {  // if (token.isLextant(Lextant.XOR)){
    79                                 return makeIDISACall(XOR,
    80                                                         Accessors.arguments(lhs, rhs),
    81                                                         token);
     79                                return makeIDISACall(token,
     80                                                        XOR,
     81                                                        Generators.arguments(lhs, rhs));
    8282                        }
    8383                }
     
    9999                        Token token = node.getToken();
    100100                        if(token.isLextant(Lextant.NOT)) {
    101                                 ASTNode replacement =
    102                                                 makeIDISACall(NOT, Accessors.arguments(Accessors.operand(node)), token);                       
     101                            Locator locator = node;
     102                                ASTNode replacement = makeIDISACall(locator, NOT, Generators.arguments(Accessors.operand(node)));
    103103                                node.updateSelf(replacement);
    104104                        }
     
    106106        }
    107107       
    108         static private FuncCallNode makeIDISACall(IDISASIMDBitwiseBuiltins idisaName, ASTNode[] arguments, Locator locator) {
    109                 return Generators.makeFuncCallNode(locator, idisaName.Name(), arguments);
     108        static private FuncCallNode makeIDISACall(Locator locator, IDISASIMDBitwiseBuiltins idisaBuiltin, ASTNode[] arguments) {
     109                return Generators.makeFuncCallNode(locator, idisaBuiltin.Name(), arguments);
    110110        }
    111111
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3345 r3347  
    1717import pabloS.lexicalAnalyzer.Lextant;
    1818
     19import toolchain.pabloB.lang.BuiltinEncoder;
    1920import toolchain.pabloB.lang.KernelState;
    2021import toolchain.pabloS.lang.BuiltinCallUtil;
     22import toolchain.pabloS.lang.PabloSBuiltinEncoder;
    2123import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    2224import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
     25import toolchain.pabloS.transformer.visitors.carry.Context;
    2326
    2427public class PabloS2PabloBXFormer {
     
    3437       
    3538        private Map<String, StreamFunctionPropertySet> streamFunctionPropertySetMap;
     39        private PabloSBuiltinEncoder builtinEncoder;
    3640        private CarrySetEncoder carrySetEncoder;
    3741 
    38     public PabloS2PabloBXFormer(Map<String, StreamFunctionPropertySet> streamFunctionPropertySetMap, CarrySetEncoder carrySetEncoder) {
     42    public PabloS2PabloBXFormer(Map<String, StreamFunctionPropertySet> streamFunctionPropertySetMap, PabloSBuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder) {
    3943        this.decoratedASTTree = null;
    4044        this.optDecoratedASTTree = null;
    4145        this.streamFunctionPropertySetMap = streamFunctionPropertySetMap;
     46        this.builtinEncoder = builtinEncoder;
    4247        this.carrySetEncoder = carrySetEncoder;
    4348    }
     
    126131            ////////////////////////////////////////////////////////////           
    127132            // Add CarryFlip call to Kernel init           
     133                       
     134                        // Default context
     135                       
     136                   
     137                        Context context = new Context(builtinEncoder,carrySetEncoder);
     138                       
    128139                Integer [] carry1InitValue = streamFunctionPropertySet.getCarry1InitValues();
    129140            for(int i = 0; i < carry1InitValue.length; i++) {   
    130141                if(carry1InitValue[i] > 0) {
    131                     FuncCallNode setCarryFuncCall = makeCarryFlipCall(i, locator);
     142                    FuncCallNode setCarryFuncCall = Generators.makeCarryFlipCall(locator, i, context);
    132143                    stateDefNode.appendChild(setCarryFuncCall);
    133144                }
     
    136147            ////////////////////////////////////////////////////////////           
    137148            // Add CarryDeclare call to Kernel   
    138             FuncCallNode carryDeclareCall = makeCarryDeclareCall(streamFunctionPropertySet.carry1Count(),
    139                                                                  streamFunctionPropertySet.carryNCount(),
    140                                                                  locator);
     149            FuncCallNode carryDeclareCall = Generators.makeCarryDeclareCall(locator,
     150                                                                 streamFunctionPropertySet.carry1Count(),
     151                                                                 streamFunctionPropertySet.carryNCount(),
     152                                                                 context);
    141153            kernelDefNode.appendChild(carryDeclareCall);
    142154           
     
    148160                return bASTTree;
    149161    }
    150 
    151     private FuncCallNode makeCarryFlipCall(int index, Locator locator) {
    152        
    153         pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, index);
    154            
    155         FuncCallNode carryFlipFuncCall  = Generators.makeFuncCallNode(locator,
    156                                                                     CarrySetEncoder.CARRYSETBASENAME,
    157                                                                     carrySetEncoder.getName(CarrySetBuiltin.CARRYFLIP),
    158                                                                     indexNode);
    159        
    160         FuncCallNode setCarryFuncCall   = Generators.makeFuncCallNode(locator,
    161                                                                     CarrySetEncoder.CARRYSETBASENAME,
    162                                                                     carrySetEncoder.getName(CarrySetBuiltin.SETCARRY),
    163                                                                     carryFlipFuncCall,
    164                                                                     indexNode);
    165         return setCarryFuncCall;
    166     }
    167 
    168     private FuncCallNode makeCarryDeclareCall(int carry1Count, int carryNCount, Locator locator) {
    169        
    170         IdentifierNode carrySetBaseName         =   Generators.makeIdentifierNode(locator, CarrySetEncoder.CARRYSET_NAME_PREFIX + 0);
    171         IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
    172         IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
    173      
    174         FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(locator,
    175                                                                                    carrySetEncoder.getName(CarrySetBuiltin.CARRYDECLARE), carrySetBaseName, carry1CountNode, carryNCountNode);
    176         return carryDeclareFuncCall;
    177     }
    178 
    179162   
    180163    /*
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/StreamFunctionPropertySetFactory.java

    r3261 r3347  
    3737                }
    3838               
    39                 // KH: TODO - Add logic for LookAhead, LookBehind ...
     39                // KH: TODO - add logic for additional properties such as lookahead, lookbehind, ...
    4040        }
    4141    }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/SurroundAssert0sWithIfs.java

    r3346 r3347  
    1818
    1919//
    20 // assert_0(errorStream, errorMsg) ->
     20// assert_0(errorStream, errorMsg) =>
    2121//
    2222// if(errorStream) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/SurroundConditionsWithBitBlockAny.java

    r3327 r3347  
    3939                    node, // TODO Update to IDISA syntax
    4040                    IDISABitBlockBuiltins.ANY.IDISALexeme(),
    41                     Accessors.arguments(condition.deepCopy()));               
     41                    Generators.arguments(condition.deepCopy()));               
    4242           
    4343            node.replaceChild(condition, FuncCallNode);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3345 r3347  
    424424                                int carryNCount, Context localContext, Locator location) {
    425425                       
    426                         FuncCallNode carryDeclare = makeCarryDeclare(carry1Count, carryNCount, localContext, location);
     426                        FuncCallNode carryDeclare = Generators.makeLocalCarryDeclare(location, carry1Count, carryNCount, localContext, context);
    427427                        body.insertChild(carryDeclare);
    428428                }
     
    430430                                int carry1Count, Context localContext, Locator location) {
    431431                       
    432                         FuncCallNode localCarryCombine = makeLocalCarryCombine(carryBase, carry1Count, localContext, location);
     432                        FuncCallNode localCarryCombine = Generators.makeLocalCarryCombine(location, carryBase, carry1Count, localContext, context);
    433433                        body.appendChild(localCarryCombine);
    434434                }
    435                 private FuncCallNode makeCarryDeclare(int carry1Count, int carryNCount,
    436                                 Context localContext, Locator location) {
    437                        
    438                         IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
    439                        
    440                         FuncCallNode carryDeclare = Generators.makeFuncCallNode(
    441                                                                 location,
    442                                                                 context.getCode(CarrySetBuiltin.CARRYDECLARE),
    443                                                                 localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
    444                         return carryDeclare;
    445                 }
    446                 private FuncCallNode makeLocalCarryCombine(int carryBase, int carry1Count,
    447                                 Context localContext, Locator locator) {
    448 
    449                         IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
    450                         ASTNode carryBaseNode = leaf(carryBase, locator);
    451                         ASTNode carry1CountNode = leaf(carry1Count, locator);
    452                        
    453                         return Generators.makeFuncCallNode(
    454                                                 locator,
    455                                                 context.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
    456                                                 Generators.arguments(context.carrySetIdentifierNode(locator),
    457                                                                   localCarrySetIdentifierNode,
    458                                                                   carryBaseNode,
    459                                                                   carry1CountNode));
    460 
    461                 }
    462 
    463435               
    464436                /*
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarrySetBuiltinCalls.java

    r3345 r3347  
    121121            public void visitLeave(WhileStmtNode node) {
    122122
    123                 appendTempDeclsToWhileBody(node);      // WARNING: append calls must precede bind calls in this method
     123                appendTempDeclsToWhileBody(node);      // WARNING: appendTemp calls must precede bindTemp calls
    124124            appendTempAssignsToWhileBody(node);
    125125               
    126126                bindTempDeclsToBlockStmt(node);
    127127            bindTempAssignToBlockStmt(node);
    128            
    129128            }
    130129
Note: See TracChangeset for help on using the changeset viewer.