Changeset 2662


Ignore:
Timestamp:
Nov 20, 2012, 10:37:43 AM (6 years ago)
Author:
ksherdy
Message:

Added andc support.

Location:
proto/pablo/src/compiler
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/ast/Accessors.java

    r2660 r2662  
    9696        // Binary Operators
    9797        ////////////////////////////////////////////////////////////////////////////           
    98         public static ASTNode rightOperand(BinaryOperatorNode node) {
     98        public static ASTNode lhs(BinaryOperatorNode node) {
     99                return node.child(0);
     100        }               
     101
     102        public static ASTNode rhs(BinaryOperatorNode node) {
    99103                return node.child(1);
    100104        }
    101 
    102         public static ASTNode leftOperand(BinaryOperatorNode node) {
    103                 return node.child(0);
    104         }               
    105 
     105       
    106106        public static String operator(BinaryOperatorNode node) {
    107107                return node.getToken().getLexeme();
  • proto/pablo/src/compiler/visitors/AdvanceCombinerXFormer.java

    r2661 r2662  
    3333
    3434                public void visitEnter(IfStmtNode node) {
    35                     // Additional carry logic req'd to support carry combine within If Stmts
     35                    // Additional carry logic req'd to support carry combine within If stmts
    3636                        node.skipChildren();
    3737                }
    3838                public void visitEnter(WhileStmtNode node) {
    39                     // Additional carry logic req'd to support carry combine within While Stmts
     39                    // Additional carry logic req'd to support carry combine within While stmts
    4040                        node.skipChildren();
    4141                }
  • proto/pablo/src/compiler/visitors/Bitwise2IDISAXFormer.java

    r2660 r2662  
    99
    1010public class Bitwise2IDISAXFormer {
    11         private ASTNode ASTree;
     11        private ASTNode ASTTree;
    1212       
    1313        public Bitwise2IDISAXFormer(ASTNode ASTree) {
    14                 this.ASTree = ASTree;
     14                this.ASTTree = ASTree;
    1515        }
    1616       
    17         public ASTNode XForm() {
    18                 Bitwise2IDISAVisitor visitor = new Bitwise2IDISAVisitor();
    19                 ASTree.accept(visitor);
    20                 return ASTree;
     17        public ASTNode XForm() { // Order AST tranversal Binary <- Unary <- General
     18               
     19                Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
     20                ASTTree.accept(binOpXformer);
     21               
     22                Bitwise2IDISAUnaryOperatorXFormer unOpXFormer = new Bitwise2IDISAUnaryOperatorXFormer();
     23                ASTTree.accept(unOpXFormer);
     24               
     25                Bitwise2IDISAGeneralXFormer xFormer = new Bitwise2IDISAGeneralXFormer();
     26                ASTTree.accept(xFormer);
     27               
     28                return ASTTree;
    2129        }
     30       
     31        private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
    2232
    23         private class Bitwise2IDISAVisitor extends VoidVisitor.Default {
     33                public void visitLeave(BinaryOperatorNode node) {
     34                        Token token = node.getToken();
     35                        if(token.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
     36                                FuncCallNode funcCallNode = null;
     37                                if(token.isLextant(Lextant.OR)) {
     38                                        funcCallNode = Generators.makeFuncCallNode(SIMD.OR.idisaName(),
     39                                                                                                                                token,
     40                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     41                                } else if(token.isLextant(Lextant.AND)) {
     42                                       
     43                                        if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
     44                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(),
     45                                                                                                                                        token,
     46                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
     47                                        } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
     48                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(),
     49                                                                                                                                        token,
     50                                                                                                                                        new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
     51                                        } else {
     52                                                funcCallNode = Generators.makeFuncCallNode(SIMD.AND.idisaName(),
     53                                                                                                                                        token,
     54                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
     55                                        }
     56                                       
     57                                } else if (token.isLextant(Lextant.XOR)){
     58                                        funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.idisaName(),
     59                                                                                                                                token,
     60                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     61                                }
     62                               
     63                                node.updateSelf(funcCallNode);
     64                        }
     65                }
     66        }       
     67
     68        private class Bitwise2IDISAUnaryOperatorXFormer extends VoidVisitor.Default {
    2469                public void visitLeave(UnaryOperatorNode node) {
    2570                        Token op = node.getToken();
     
    3378                        }
    3479                }               
    35                
    36                 public void visitLeave(BinaryOperatorNode node) {
    37                         Token op = node.getToken();
    38                         if(op.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
    39                                 String FuncName;
    40                                 if(op.isLextant(Lextant.AND)) {
    41                                         FuncName = SIMD.AND.idisaName();
    42                                 } else if(op.isLextant(Lextant.OR)) {
    43                                         FuncName = SIMD.OR.idisaName();
    44                                 } else {
    45                                         FuncName = SIMD.XOR.idisaName();
    46                                 }
    47                                
    48                                 FuncCallNode FuncCallNode =
    49                                                 Generators.makeFuncCallNode(FuncName,
    50                                                                                                                                 op,
    51                                                                                                                                 new ASTNode [] {Accessors.leftOperand(node), Accessors.rightOperand(node)});
    52                                 node.updateSelf(FuncCallNode);
    53                         }
    54                 }
    55                
    56                
    57                
     80        }       
     81       
     82        private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
    5883                /*
    5984                public void visitLeave(IntegerConstantNode node) {
     
    101126                }               
    102127               
    103                
    104 
    105128//          def visit_If_Node(self, ifNode):
    106129//        self.generic_visit(ifNode)
     
    110133                        ASTNode ifTest = Accessors.ifTest(node);                       
    111134                        String FuncName = BITBLOCK.ANY.IDISAName();
    112                         FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName,
    113                                                                                                                                                                                                 node.getToken(),
    114                                                                                                                                                                                                 new ASTNode [] {ifTest});
     135                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest});
    115136                        node.replaceChild(ifTest, FuncCallNode);
    116137                }
  • proto/pablo/src/compiler/visitors/CPPUnparser.java

    r2660 r2662  
    267267                StringBuffer resultVar = new StringBuffer();
    268268               
    269                 if(!Accessors.isTerminal(Accessors.leftOperand(node))) {
     269                if(!Accessors.isTerminal(Accessors.lhs(node))) {
    270270                        lhsCode = bracketExpressionCode(lhsCode);
    271271                }
     
    276276                resultVar.append(" ");
    277277               
    278                 if(!Accessors.isTerminal(Accessors.rightOperand(node))) {
     278                if(!Accessors.isTerminal(Accessors.rhs(node))) {
    279279                        rhsCode = bracketExpressionCode(rhsCode);
    280280                }
Note: See TracChangeset for help on using the changeset viewer.