Changeset 1284


Ignore:
Timestamp:
Aug 5, 2011, 2:57:34 AM (8 years ago)
Author:
shermer
Message:

v0.6.5
continued refactoring and straightening in the 'incode' package.
Mainly work on Instruction and Op.

Location:
proto/pebble/trunk
Files:
1 added
2 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/src/incode/BasicBlock.java

    r1282 r1284  
    170170                        Instruction i = block.lastInstruction();
    171171                        if(i.isJumpType()) {
    172                                 BasicBlock toBlock = lookup(i.extendedOperand(1));
     172                                BasicBlock toBlock = lookup(i.operand(1));
    173173                                work.add(toBlock, 0);
    174174                        }
    175175                        else if(i.getOperation() == Op.WHILE) {
    176                                 BasicBlock loopBlock = lookup(i.extendedOperand(1));
    177                                 BasicBlock exitBlock = lookup(i.extendedOperand(2));   
     176                                BasicBlock loopBlock = lookup(i.operand(1));
     177                                BasicBlock exitBlock = lookup(i.operand(2));   
    178178                                assert loopBlock  != null;
    179179                                assert exitBlock != null;
     
    189189                        }
    190190                        else if(i.getOperation() == Op.TEST) {
    191                                 BasicBlock trueBlock  = lookup(i.extendedOperand(1));
    192                                 BasicBlock falseBlock = lookup(i.extendedOperand(2));
    193                                 BasicBlock joinBlock  = lookup(i.extendedOperand(3));
     191                                BasicBlock trueBlock  = lookup(i.operand(1));
     192                                BasicBlock falseBlock = lookup(i.operand(2));
     193                                BasicBlock joinBlock  = lookup(i.operand(3));
    194194                                assert trueBlock  != null;
    195195                                assert falseBlock != null;
     
    268268                List<BasicBlock> result = new ArrayList<BasicBlock>(2);
    269269                Instruction i = lastInstruction();
    270                 for(int eOpNum: i.blockNameEIndices()) {
    271                         result.add(lookup(i.extendedOperand(eOpNum)));
     270                for(int eOpNum: i.blockNameOprIndices()) {
     271                        result.add(lookup(i.operand(eOpNum)));
    272272                }
    273273                return result;
     
    283283                Instruction i = lastInstruction();
    284284                if(i.isJumpType()) {
    285                         return lookup(i.extendedOperand(1));
     285                        return lookup(i.operand(1));
    286286                }
    287287                if(i.isTestType()) {
    288                         return lookup(i.extendedOperand(2));    // falseBlock for test or exitBlock for while
     288                        return lookup(i.operand(2));    // falseBlock for test or exitBlock for while
    289289                }
    290290                return null;
  • proto/pebble/trunk/src/incode/Fragment.java

    r1282 r1284  
    102102                        switchSuccessorOperandToCopy(instr, 0, copies);
    103103                        switchSuccessorOperandToCopy(instr, 1, copies);
    104                         if(instr.extendedOperand(3) != null) {
     104                        if(instr.operand(3) != null) {
    105105                                switchSuccessorOperandToCopy(instr, 2, copies);
    106106                        }
     
    108108        }
    109109        private void switchSuccessorOperandToCopy(Instruction instr, int operandNumber, Map<BasicBlock, BasicBlock> copies) {
    110                 BasicBlock oldSuccessor = BasicBlock.lookup(instr.extendedOperand(operandNumber+1));
     110                BasicBlock oldSuccessor = BasicBlock.lookup(instr.operand(operandNumber+1));
    111111                BasicBlock newSuccessor = copies.get(oldSuccessor);
    112                 instr.setExtendedOperand(operandNumber+1, newSuccessor.getName());
     112                instr.setOperand(operandNumber+1, newSuccessor.getName());
    113113        }
    114114       
  • proto/pebble/trunk/src/incode/Instruction.java

    r1283 r1284  
    99        public static final int MAX_NUMBER_OPERANDS = 4;
    1010        private Op operation;
    11         private String eoperand[];
     11        private String operand[];
    1212        private boolean toBeDeleted;
    1313        private boolean notEqualsComparison;    // for test-type instructions. 
     
    2626                this.operation = operation;
    2727               
    28                 eoperand = new String[MAX_NUMBER_OPERANDS];
     28                this.operand = new String[MAX_NUMBER_OPERANDS];
    2929                for(int i=0; i<operands.length; i++) {
    3030                        if(i<operands.length) {
    31                                 eoperand[i] = translateArrayIndices(operands[i]);
     31                                this.operand[i] = rewriteArrayIndices(operands[i]);
    3232                        }
    3333                        else {
    34                                 eoperand[i] = "placeholder operand";
     34                                this.operand[i] = "placeholder operand";
    3535                        }
    3636                }
     
    3939                notEqualsComparison = false;
    4040        }
    41         private String translateArrayIndices(String operand) {
    42                 if(operand == null)
     41        private String rewriteArrayIndices(String symbol) {
     42                if(symbol == null)
    4343                        return null;
    44                 int firstIndex = operand.indexOf('$');
     44                int firstIndex = symbol.indexOf('$');
    4545                if(firstIndex == NO_INDEX) {
    46                         return operand;
    47                 }
    48                
    49                 String base = operand.substring(0, firstIndex);
    50                 String index = operand.substring(firstIndex+1);
     46                        return symbol;
     47                }
     48               
     49                String base = symbol.substring(0, firstIndex);
     50                String index = symbol.substring(firstIndex+1);
    5151               
    5252                return base + '[' + index + ']';
    5353        }
    5454
     55       
    5556        ///////////////////////////////////////////////////////////////////////////
    5657        // property accessors / mutators
     
    7980                this.operation = op;
    8081        }
    81         public String extendedOperand(int eOpNumber) {
    82                 return eoperand[eOpNumber];
    83         }
    84         public void setExtendedOperand(int eOpNumber, String symbol) {
    85                 eoperand[eOpNumber] = symbol;
    86         }
    87         public boolean containsOperandUse(String symbol) {
    88                 return firstUsedOprIndex(symbol)!=NO_INDEX;
     82        public String operand(int oprIndex) {
     83                return operand[oprIndex];
     84        }
     85        public void setOperand(int oprIndex, String symbol) {
     86                operand[oprIndex] = symbol;
     87        }
     88        public boolean containsUseOf(String symbol) {
     89                return firstUseOf(symbol)!=NO_INDEX;
    8990        }
    9091        /**
     
    9394         * @return the oprIndex at which symbol is first used, or NO_INDEX if it is not used.
    9495         */
    95         public int firstUsedOprIndex(String symbol) {
     96        public int firstUseOf(String symbol) {
    9697                // this uses the sorted-order property of variableUseEIndices to get first index.
    97                 for(int oprIndex: variableUseEIndices()) {
    98                         if(extendedOperand(oprIndex).equals(symbol))
     98                for(int oprIndex: useOprIndices()) {
     99                        if(operand(oprIndex).equals(symbol))
    99100                                return oprIndex;
    100101                }
     
    128129         */
    129130        public int numOperands() {
    130                 return operation.numberOfOperands()+1;
     131                return operation.lastOprIndex()+1;
    131132        }
    132133       
     
    135136        // eOperandNumbers and helper
    136137        ///////////////////////////////////////////////////////////////////////////
    137         public int[] variableDefEIndices() {
    138                 return operation.defEIndices();
    139         }
    140         public int[] blockNameEIndices() {
    141                 return operation.blockNameEIndices();
     138        public int[] defOprIndices() {
     139                return operation.defOprIndices();
     140        }
     141        public int[] blockNameOprIndices() {
     142                return operation.blockNameOprIndices();
    142143        }
    143144        /**
    144          * Returns a list of the oprIndices that denote variable uses in this instrution.
     145         * Returns a list of the oprIndices that denote variable uses in this instruction.
    145146         * This routine guarantees that the indices returned are in increasing order.
    146147         *
    147148         * @return an increasing, possibly empty, list of oprIndices for variable uses.
    148149         */
    149         public List<Integer> variableUseEIndices() {
     150        public List<Integer> useOprIndices() {
    150151                List<Integer> result = new ArrayList<Integer>(MAX_NUMBER_OPERANDS);
    151                 int[] indices = operation.possibleUseEIndices();
     152                int[] indices = operation.possibleUseOprIndices();
    152153                for(int index: indices) {
    153                         if(denotesAVariable(extendedOperand(index))) {
     154                        if(denotesAVariable(operand(index))) {
    154155                                result.add(index);
    155156                        }
     
    157158                return result;
    158159        }
    159         public List<Integer> defAndUseEIndices() {
    160                 List<Integer> result = variableUseEIndices();
    161                 for(int i: variableDefEIndices()) {
     160        public List<Integer> defAndUseOprIndices() {
     161                List<Integer> result = useOprIndices();
     162                for(int i: defOprIndices()) {
    162163                        result.add(0, (Integer)i);
    163164                }
     
    165166        }
    166167        public boolean oprIsAVariable(int oprIndex) {
    167                 return denotesAVariable(extendedOperand(oprIndex));
     168                return denotesAVariable(operand(oprIndex));
    168169        }
    169170        // String is not T, F, starting with [-0..9], or "smallConstant("
     
    185186        }
    186187       
    187 
    188188       
    189189        ///////////////////////////////////////////////////////////////////////////
    190190        // other services:
    191         //              varIgnoringHashCode     helps speed expression matching
    192191        //              copy
    193192        //              commute                                 switches operands 1 and 2
    194193        ///////////////////////////////////////////////////////////////////////////
    195 
    196         // this hashcode ignores the variable name, and is invariant under
    197         // permutation of operands.
    198         public int varIgnoringHashCode() {
    199                 int result = operation.ordinal();
    200                 for(int i=1; i<numOperands(); i++) {
    201                         result = result + extendedOperand(i).hashCode();
    202                 }
    203                 return result;
    204         }
    205194        public Instruction copy() {
    206                 Instruction result = new Instruction(operation, eoperand[0], eoperand[1], eoperand[2], eoperand[3]);
     195                Instruction result = new Instruction(operation, operand[0], operand[1], operand[2], operand[3]);
    207196                if(isToBeDeleted())
    208197                        result.markForDeletion();
     
    212201        }
    213202        public void commute() {
    214                 String temp = eoperand[1];
    215                 eoperand[1] = eoperand[2];
    216                 eoperand[2] = temp;
     203                String temp = operand[1];
     204                operand[1] = operand[2];
     205                operand[2] = temp;
    217206        }
    218207       
     
    222211        ///////////////////////////////////////////////////////////////////////////
    223212        public String toString() {
    224                 return String.format(operation.format(), eoperand[0], eoperand[1], eoperand[2], eoperand[3], comparisonString());
     213                return String.format(operation.format(), operand[0], operand[1], operand[2], operand[3], comparisonString());
    225214        }
    226215        public String toPython() {
    227                 return String.format(operation.pythonFormat(), eoperand[0], eoperand[1], eoperand[2], eoperand[3], comparisonString());
     216                return String.format(operation.pythonFormat(), operand[0], operand[1], operand[2], operand[3], comparisonString());
    228217        }
    229218        private String comparisonString() {
  • proto/pebble/trunk/src/incode/Op.java

    r1279 r1284  
    1 /**
    2  *
    3  */
    41package incode;
    52
    63
    74public enum Op {
    8         AND("&", 2),                    // most ops:  Instruction.variable = Op(Instruction.operand[0]...)
    9         OR("|", 2),
    10         XOR("^", 2),
    11         NOT("~", 1),
    12         COPY(" ", 1),
    13         SEL("?", 3),
    14         ANDNOT("&~", 2),
    15         SHIFT(">>", 2),
    16         SCAN("+>", 2),
    17         SPAN("<>", 2),
     5        // Key for argument vectors:
     6        //
     7        // e: expression: either a constant or a variable name.
     8        // i: integer constant
     9        // m: message
     10        // b: block name
     11        // t: type(struct) name
     12        // d: defined variable name     
     13        // .: unused oprIndex
     14       
     15        AND("&", 2),                    // 0 = 1 & 2                            (d e e)
     16        OR("|", 2),                             // 0 = 1 | 2                            (d e e)
     17        XOR("^", 2),                    // 0 = 1 ^ 2                            (d e e)
     18        NOT("~", 1),                    // 0 = ~1                                       (d e)
     19        COPY(" ", 1),                   // 0 = 1                                        (d e)
     20        SEL("?", 3),                    // 0 = 1 ? 2 : 3                        (d e e e)
     21        ANDNOT("&~", 2),                // 0 = 1 &~ 2                           (d e e)
     22        SHIFT(">>", 2),                 // 0 = 1 shiftby 2                      (d e i)
     23        SCAN("+>", 2),                  // 0 = scanThrough(1, 2)        (d e e)
     24        SPAN("<>", 2),                  // 0 = span(1, 2)                       (d e e)
    1825       
    1926        // several flavors of do nothing
    20         NOP("nop", 0),
    21         COMMENT("#", 1),
    22         INVALID("null", 0),     // used by NullInstruction
    23        
    24         // make a struct:       "variable" is new struct name, arg[0] is structure type name.
    25         // use on main-line code only, not in branches or loops.  Otherwise it will confuse
    26         // optimizers.
    27         INSTANTIATE("new", 1),
     27        NOP("nop", 0),                  //                                                      ()
     28        COMMENT("#", 1),                //                                                      (. m)
     29        INVALID("null", 0),             // used by NullInstruction      ()
     30       
     31        // make a struct:       opr0 is new struct name, opr1 is structure type name.
     32        //
     33        // use on main-line code only, not in branches or loops.
     34        // Otherwise it will confuse optimizers. [is this still true?]
     35        INSTANTIATE("new", 1),  // 0 = new 1                            (d t)
    2836
    2937        // several flavors of test & branch are distinguished for pythonating purposes.
    30         // test instructions use the "Instruction.variable" as the variable to test.
     38        // test instructions use the "Instruction.operand[0]" as the variable to test.
    3139        // If the instruction's isEqualComparison field is true,
    32         //              the condition is "var==0"; otherwise,
    33         //              the condition is "var!=0".
    34         TEST("test", 3),        // if variable is true, jump to argument0, else argument1
    35                                                 // argument2 is used as the block where the "then" and "else"
     40        //              the condition is "opr0 == 0"; otherwise,
     41        //              the condition is "opr0 != 0".
     42        TEST("test", 3),        // if (cond(0)) goto 1                  (e b b b)
     43                                                // else goto 2
     44                                                // join goto 3
     45                                                //
     46                                                // opr 3 is used as the block where the "then" and "else"
    3647                                                // clauses join.
    37         WHILE("while", 2),      // same as TEST, but to distinguish loops.  no argument2.
     48       
     49        WHILE("while", 2),      // if (cond(0)) goto 1                  (e b b)
     50                                                // else goto 2
     51                                                //
     52                                                // same as TEST, but to distinguish loops.  no argument2.
     53       
    3854       
    3955        // several flavors of jump are distinguished, mainly for pythonating purposes.
    40         // jump instructions do not use the "Instruction.variable" field.
    41         JUMP("jump", 1),        //
    42         ITER("iter", 1),        // backwards jump at the end of a loop.
    43         JOIN("join", 1),        // jump from the end of an if/else branch
     56        // jump instructions do not use the "Instruction.operand[0]" field.
     57        JUMP("jump", 1),        //                                                                                      (. b)
     58        ITER("iter", 1),        // backwards jump at the end of a loop.         (. b)
     59        JOIN("join", 1),        // jump from the end of an if/else branch       (. b)
    4460       
    4561        // error is a branch that is grouped with the jumps, as one branch (report error and halt)
    4662        // is not elaborated as a basic block in incode. 
    47         ERROR("error", 2),      // if condition is true
     63        ERROR("error", 2),      // if condition(0)                                                      (e b m)
    4864                                                //     then jump to block operand0
    4965                                                // else message operand1 is issued, and we exit.
    5066        ;
    5167       
    52         private String symbol;
    53         private int numberOfOperands;
    54 
    55         Op(String symbol, int numberOfOperands) {
    56                 this.symbol = symbol;
    57                 this.numberOfOperands = numberOfOperands;
    58         }
    59         public String symbol() {
    60                 return symbol;
    61         }
    62         public int numberOfOperands() {
    63                 return numberOfOperands;
    64         }
     68        private String textRep;
     69        private int lastOperand;
     70
     71
     72        ///////////////////////////////////////////////////////////////////////////////
     73        // constructor and getters
     74        ///////////////////////////////////////////////////////////////////////////////
     75        Op(String textRep, int lastOperand) {
     76                this.textRep = textRep;
     77                this.lastOperand = lastOperand;
     78        }
     79        public String asText() {
     80                return textRep;
     81        }
     82        public int lastOprIndex() {
     83                return lastOperand;
     84        }
     85       
     86
     87        ///////////////////////////////////////////////////////////////////////////////
     88        // general properties and broad types
     89        //
     90        // think about deprecating isAssignment, isJumpType, and isTestType
     91        // in favor of the operand index type set functions.
     92        ///////////////////////////////////////////////////////////////////////////////
    6593        public boolean isCommutable() {
    6694                return this==AND || this==OR || this==XOR;
     
    81109
    82110        ///////////////////////////////////////////////////////////////////////////////
    83         // possibleUseEIndices: return an array of which extendedIndices possibly
     111        // Operand index type set functions:
     112        //
     113        // possibleUseOprIndices: return an array of which oprIndices possibly
    84114        //                              denote variable uses.  Whether these operands actually are uses
    85115        //                              of variables depends on whether the string for that operand
     
    87117        //                              a constant (T, F, or an integer/smallConstant).
    88118        //
    89         // defEIndices: returns an array of which extendedIndices are (definitely)
     119        // defOprIndices: returns an array of which oprIndices are (definitely)
    90120        //                              variable definitions.
    91         //
     121        //
     122        // blockNameOprIndices: returns an array of which oprIndices are (definitely)
     123        //                              block names.
     124        //
     125        // messageOprIndices: returns an array of which oprIndices are (definitely)
     126        //                              message strings.  Nonempty for both comments and errors.
     127        //
     128        // typeOprIndices: returns an array of which oprIndices are (definitely)
     129        //                              type names.
     130        //
     131        // possibleConstantOprIndices: returns an array of which oprIndices are possibly
     132        //                              integer constants.  Whether they are actually constants depends
     133        //                              on their string values.
    92134        ///////////////////////////////////////////////////////////////////////////////
    93135       
     
    97139        static final int[] three = {1, 2, 3};
    98140        static final int[] variable = {0};
    99 
    100         public final int[] possibleUseEIndices() {
     141        static final int[] justTwo = {2};
     142
     143        public final int[] possibleUseOprIndices() {
    101144                if(this==COMMENT)                       return empty;
    102145                if(this==INSTANTIATE)           return empty;
     
    105148                if(isJumpType())                        return empty;
    106149               
    107                 if(numberOfOperands==0)         return empty;
    108                 if(numberOfOperands==1)         return one;
    109                 if(numberOfOperands==2)         return two;
    110                 if(numberOfOperands==3)         return three;
    111                 return empty;
    112         }
    113         public final int[] defEIndices() {
     150                if(lastOperand==0)              return empty;
     151                if(lastOperand==1)              return one;
     152                if(lastOperand==2)              return two;
     153                if(lastOperand==3)              return three;
     154                return empty;
     155        }
     156        public final int[] defOprIndices() {
    114157                if(isAssignment())                      return variable;
    115158                return empty;
    116159        }
    117         public final int[] blockNameEIndices() {
     160        public final int[] blockNameOprIndices() {
    118161                if(this==ERROR)                         return one;
    119162                if(isTestType())                        return two;
     
    121164                return empty;
    122165        }
     166        public final int[] messageOprIndices() {
     167                if(this==ERROR)                         return justTwo;
     168                return empty;
     169        }
     170        public final int[] typeOprIndices() {
     171                if(this==INSTANTIATE)           return one;
     172                return empty;
     173        }
     174        public final int[] possibleConstantOprIndices() {
     175                if(this==SHIFT)                         return two;
     176                return possibleUseOprIndices();
     177        }
     178       
    123179        ///////////////////////////////////////////////////////////////////////////////
    124180        // Note: I chose to implement the following routines as switches rather than as a
     
    130186        //
    131187        // Format strings for use in a call with arguments as follows:
    132         //                                                        1$        2$          3$          4$          5$
    133         // String.format(Op.format(), variable, operand[0], operand[1], operand[2], comparisonString());
     188        //                                                        1$          2$          3$          4$          5$
     189        // String.format(Op.format(), operand[0], operand[1], operand[2], operand[3], comparisonString());
    134190        //
    135191        ///////////////////////////////////////////////////////////////////////////////
  • proto/pebble/trunk/src/incode/global/AllVariables.java

    r1279 r1284  
    3939                        Set<String> result) {
    4040                for(Instruction instr: block.instructions()) {
    41                         for(int eOpNum: instr.variableUseEIndices()) {
    42                                 String symbol = instr.extendedOperand(eOpNum);
     41                        for(int eOpNum: instr.useOprIndices()) {
     42                                String symbol = instr.operand(eOpNum);
    4343                                result.add(symbol);
    4444                        }
     
    4848                        Set<String> result) {
    4949                for(Instruction instr: block.instructions()) {
    50                         for(int eOpNum: instr.variableDefEIndices()) {
    51                                 String symbol = instr.extendedOperand(eOpNum);
     50                        for(int eOpNum: instr.defOprIndices()) {
     51                                String symbol = instr.operand(eOpNum);
    5252                                result.add(symbol);
    5353                        }
  • proto/pebble/trunk/src/incode/global/CopyRemover.java

    r1283 r1284  
    9191
    9292                                Instruction defInstruction = block.instruction(defIndex);
    93                                 defInstruction.setExtendedOperand(0, copySymbol);
     93                                defInstruction.setOperand(0, copySymbol);
    9494                               
    9595                                Instruction copyInstruction = block.instruction(copyIndex);
     
    129129
    130130        private boolean uses(Instruction instruction, String symbol) {
    131                 for(int eOpNum: instruction.variableUseEIndices()) {
    132                         if(instruction.extendedOperand(eOpNum).equals(symbol)) {
     131                for(int eOpNum: instruction.useOprIndices()) {
     132                        if(instruction.operand(eOpNum).equals(symbol)) {
    133133                                return true;
    134134                        }
     
    150150        private void replaceUsesBy(Instruction i, String defSymbol,
    151151                        String replacement) {
    152                 for(int eOpNum: i.variableUseEIndices()) {
    153                         if(i.extendedOperand(eOpNum).equals(defSymbol)) {
    154                                 i.setExtendedOperand(eOpNum, replacement);
     152                for(int eOpNum: i.useOprIndices()) {
     153                        if(i.operand(eOpNum).equals(defSymbol)) {
     154                                i.setOperand(eOpNum, replacement);
    155155                        }
    156156                }
     
    184184                Instruction instruction = block.instruction(index);
    185185                if(instruction.isAssignment())
    186                         return instruction.extendedOperand(0);
     186                        return instruction.operand(0);
    187187                return "";
    188188        }
     
    192192
    193193                Instruction definition = block.instruction(defIndex);
    194                 String defSymbol = definition.extendedOperand(0);
     194                String defSymbol = definition.operand(0);
    195195
    196196                int next = defUse.getNextUse(defIndex, 0);
  • proto/pebble/trunk/src/incode/global/DeadCodeEliminator.java

    r1282 r1284  
    5353                        }
    5454                       
    55                         String var = instruction.extendedOperand(0);
     55                        String var = instruction.operand(0);
    5656                        if(liveDown.contains(var)) {
    5757                                liveDown.remove(var);
     
    6565
    6666        private void addUses(Instruction instruction, Set<String> liveDown) {
    67                 for(int eOpNum: instruction.variableUseEIndices()) {
    68                         liveDown.add(instruction.extendedOperand(eOpNum));
     67                for(int eOpNum: instruction.useOprIndices()) {
     68                        liveDown.add(instruction.operand(eOpNum));
    6969                }
    7070        }
  • proto/pebble/trunk/src/incode/global/LivenessProperty.java

    r1282 r1284  
    5555                for(Instruction instr : block.reverseInstructions()) {
    5656                        if(instr.isAssignment()) {
    57                                 kills.add(instr.extendedOperand(0));
    58                                 gens.remove(instr.extendedOperand(0));
     57                                kills.add(instr.operand(0));
     58                                gens.remove(instr.operand(0));
    5959                        }
    60                         for(int eIndex: instr.variableUseEIndices()) {
    61                                 gens.add(instr.extendedOperand(eIndex));
     60                        for(int eIndex: instr.useOprIndices()) {
     61                                gens.add(instr.operand(eIndex));
    6262                        }
    6363                }
  • proto/pebble/trunk/src/incode/global/MergeBlocks.java

    r1282 r1284  
    9292                else {
    9393//                      BasicBlock succSuccessor = successor.primarySuccessor();
    94                         last.setExtendedOperand(1, "--next instruction--");
     94                        last.setOperand(1, "--next instruction--");
    9595                }
    9696               
  • proto/pebble/trunk/src/incode/localOptimization/DefUseProperty.java

    r1283 r1284  
    101101                        InstructionDefUseIndices indices = defsAndUses.get(index);
    102102                       
    103                         for(int eOpNumber: instr.defAndUseEIndices()) {
    104                                 String operand = instr.extendedOperand(eOpNumber);
     103                        for(int eOpNumber: instr.defAndUseOprIndices()) {
     104                                String operand = instr.operand(eOpNumber);
    105105                                int definingInstrIndex = getWithDefault(lastDef, operand, BEGINNING_OF_BLOCK);
    106106                                indices.setDef(eOpNumber, definingInstrIndex);
     
    124124                        }
    125125                       
    126                         lastDef.put(instr.extendedOperand(0), index);
    127                         lastUse.remove(instr.extendedOperand(0));
     126                        lastDef.put(instr.operand(0), index);
     127                        lastUse.remove(instr.operand(0));
    128128                }
    129129        }
     
    131131                InstructionDefUseIndices previousIndices = defsAndUses.get(defIndex);
    132132                int previousEOpNum = 0;
    133                 String symbol = block.instruction(defIndex).extendedOperand(0);
     133                String symbol = block.instruction(defIndex).operand(0);
    134134               
    135135                for(int index = defIndex; index < block.numInstructions(); index++) {
     
    145145       
    146146        private int usesSymbol(Instruction instruction, String symbol) {
    147                 for(int eOpNum: instruction.variableUseEIndices()) {
    148                         if(instruction.extendedOperand(eOpNum).equals(symbol)) {
     147                for(int eOpNum: instruction.useOprIndices()) {
     148                        if(instruction.operand(eOpNum).equals(symbol)) {
    149149                                return eOpNum;
    150150                        }
     
    192192        public int getNextUse(int index, String symbol) {
    193193                Instruction instr = block.instruction(index);
    194                 int eOpIndex = instr.firstUsedOprIndex(symbol);
     194                int eOpIndex = instr.firstUseOf(symbol);
    195195                if(eOpIndex == Instruction.NO_INDEX) {
    196196                        reportError("GetNextUse found unused operand " + symbol + " in instruction "+instr);
     
    207207        private void setNextUse(int index, String operand, int value) {
    208208                Instruction instr = block.instruction(index);
    209                 int eOpIndex = instr.firstUsedOprIndex(operand);
     209                int eOpIndex = instr.firstUseOf(operand);
    210210                if(eOpIndex == Instruction.NO_INDEX) {
    211211                        reportError("SetNextUse found unused operand " + operand + " in instruction "+instr);
  • proto/pebble/trunk/src/incode/localOptimization/ReuseAvailableExpressions.java

    r1282 r1284  
    4444                       
    4545                        for(int i=1; i<instr.numOperands(); i++) {
    46                                 String thisOperand = instr.extendedOperand(i);
    47                                 String otherOperand = other.instruction().extendedOperand(i);
     46                                String thisOperand = instr.operand(i);
     47                                String otherOperand = other.instruction().operand(i);
    4848                                if(!thisOperand.equals(otherOperand))
    4949                                        return false;
    5050                        }
    5151                        return true;
    52                 }
     52                }       
     53               
     54                // this hashcode ignores the variable name, and is invariant under
     55                // permutation of operands.  Bad hash for non-variable-using instructions.
    5356                public int hashCode() {
    54                         return instr.varIgnoringHashCode();
     57                        int result = instr.getOperation().ordinal();
     58                        for(int i: instr.useOprIndices()) {
     59                                result = result + instr.operand(i).hashCode();
     60                        }
     61                        return result;
    5562                }
    5663                private Instruction instruction() {
    5764                        return instr;
    5865                }
    59                 public boolean containsOperandUse(String symbol) {
    60                         return instr.containsOperandUse(symbol);
     66                public boolean containsUseOf(String symbol) {
     67                        return instr.containsUseOf(symbol);
    6168                }
    6269        }
     
    8491                        return;
    8592               
    86                 String symbol = instr.extendedOperand(0);
     93                String symbol = instr.operand(0);
    8794                removeFromReplacementValues(symbol);
    8895                removeAvailabilityWithArgument(symbol);
     
    93100                for(Entry<InstructionContainer, Integer> entry: availability.entrySet()) {
    94101                        InstructionContainer instructionContainer = entry.getKey();
    95                         if(instructionContainer.containsOperandUse(symbol)) {
     102                        if(instructionContainer.containsUseOf(symbol)) {
    96103                                removals.add(instructionContainer);     // avoid mutating map underneath entrySet()
    97104                        }
     
    117124        private void killReplacementForVariable(Instruction currentI) {
    118125                if(currentI.isAssignment()) {
    119                         String variable = currentI.extendedOperand(0);
     126                        String variable = currentI.operand(0);
    120127                        replacements.remove(variable);
    121128                }
     
    132139                        makeAvailable(currentIC, index);
    133140                        if(currentI.getOperation()==Op.COPY) {
    134                                 replaceUses(currentI.extendedOperand(0), currentI.extendedOperand(1));
     141                                replaceUses(currentI.operand(0), currentI.operand(1));
    135142                        }
    136143                }
    137144                else {
    138145                        String priorName = availableName(currentIC);
    139                         String currentName = currentI.extendedOperand(0);
     146                        String currentName = currentI.operand(0);
    140147                       
    141148                        Instruction copy = makeCopy(currentName, priorName);
     
    148155       
    149156        private void replaceArguments(Instruction instr) {
    150                 for(int a=1; a<instr.numOperands(); a++) {
    151                         if(replacements.containsKey(instr.extendedOperand(a))) {
    152                                 instr.setExtendedOperand(a, replacements.get(instr.extendedOperand(a)));
     157                for(int oprIndex: instr.useOprIndices()) {
     158                        String opr = instr.operand(oprIndex);
     159                        if(replacements.containsKey(opr)) {
     160                                instr.setOperand(oprIndex, replacements.get(opr));
    153161                        }
    154162                }
     
    172180        private String availableName(InstructionContainer container) {
    173181                int index = availableIndex(container);
    174                 return block.instruction(index).extendedOperand(0);
     182                return block.instruction(index).operand(0);
    175183        }
    176184
  • proto/pebble/trunk/src/incode/localOptimization/UseAndNot.java

    r1282 r1284  
    3939                       
    4040                        for(int r=0; r<2; r++) {
    41                                 String operand = current.extendedOperand(r+1);
     41                                String operand = current.operand(r+1);
    4242                                Integer defnIndex = definitions.get(operand);
    4343                                if(defnIndex == null) {   // from outside of block.
     
    4949                                                current.commute();
    5050                                        current.setOperation(Op.ANDNOT);
    51                                         current.setExtendedOperand(2, source.extendedOperand(1));
     51                                        current.setOperand(2, source.operand(1));
    5252                                        break;
    5353                                }
     
    5858        private void makeDefinitions() {
    5959                for(int index=0; index<block.numInstructions(); index++) {
    60                         String variable = block.instruction(index).extendedOperand(0);
     60                        String variable = block.instruction(index).operand(0);
    6161                        definitions.put(variable, index);
    6262                }
  • proto/pebble/trunk/src/incode/readme.txt

    r1242 r1284  
    1313        Instruction             The instruction class.  Place is provided for
    1414                                        three arguments and a variable to which to store
    15                                         the results.  Several other small pieces of
     15                                        the results.  A few other small pieces of
    1616                                        information are stored here.  A null object
    17                                         is provided, as are factories for each instruction.
     17                                        is provided.
     18        InstructionFacotries     Factories for instructions of each Op type.
     19       
    1820        BasicBlock              A storage unit for basic blocks of code (sequences
    19                                         of instructions ending in a jump or branch).  [note
    20                                         other conditions on basic blocks in any compiler book]
     21                                        of instructions ending in a jump or branch).  See
     22                                        other conditions on basic blocks in any compiler book.
    2123        Fragment                A lightweight wrapper for a BasicBlock that deals
    2224                                        with the set of all BasicBlocks reachable from the
     
    3537        package
    3638        localOptimization       a few local optimizations.  This is older code, and
    37                                         the plan is to evolve it into global optimizations.
     39                                        some of it is not working.  The plan is to evolve these
     40                                        into global optimizations.
     41       
     42        package
     43        global                  A few global optimizations.
     44
    3845
    3946------------------
     
    4653"Local" means dealing with only one basic block.  "Global" means dealing
    4754with an entire compilation unit (either subroutine or program).
    48 These are standard terms.
     55These are standard terms.  I find I'm having some trouble figuring out whether
     56optimization classes should go into local or global...the local ones seem to
     57either use some global analysis or at least have an apply(fragment) method
     58that applies them globally.
     59
    4960
    5061
     
    6071notion.
    6172
    62 Fragment, BasicBlock, Instruction, and Op need to be sorted out.  Op should take
    63 more responsibility as should Instruction.  The code dealing with the number of
    64 args for an instruction and with printing an instruction is where to start.
     73I use the prefix "opr" for operand; this is most apparent when dealing with
     74the index of operands in instructions.  (oprIndex is a common variable name.)
     75Note that the variable defined by an instruction has an oprIndex of 0.  Instruction's
     76getOperand() and setOperand() give uniform access to the instruction's operands
     77and result.
    6578
    6679
    67 
  • proto/pebble/trunk/src/util/range/test/RangeComponentTest.java

    r1282 r1284  
    3030                        BasicBlock block = range.toIncode();
    3131//                      System.err.println(" " + begin + " " + end);
    32                         String variableName = block.lastInstruction().extendedOperand(0);
     32                        String variableName = block.lastInstruction().operand(0);
    3333                        writePythonFunction(block, variableName, functionName(begin, end), begin, end);
    3434                }
Note: See TracChangeset for help on using the changeset viewer.