Changeset 1282


Ignore:
Timestamp:
Aug 5, 2011, 12:20:30 AM (8 years ago)
Author:
shermer
Message:

Continued refactoring of Instruction.

Location:
proto/pebble/trunk/src
Files:
11 edited

Legend:

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

    r1281 r1282  
    170170                        Instruction i = block.lastInstruction();
    171171                        if(i.isJumpType()) {
    172                                 String blockName = i.getOperand(0);
    173                                 BasicBlock b = lookup(blockName);
    174                                 work.add(b, 0);
     172                                BasicBlock toBlock = lookup(i.extendedOperand(1));
     173                                work.add(toBlock, 0);
    175174                        }
    176175                        else if(i.getOperation() == Op.WHILE) {
    177                                 BasicBlock loopBlock = lookup(i.getOperand(0));
    178                                 BasicBlock exitBlock = lookup(i.getOperand(1));
     176                                BasicBlock loopBlock = lookup(i.extendedOperand(1));
     177                                BasicBlock exitBlock = lookup(i.extendedOperand(2));   
    179178                                assert loopBlock  != null;
    180179                                assert exitBlock != null;
     
    190189                        }
    191190                        else if(i.getOperation() == Op.TEST) {
    192                                 BasicBlock trueBlock  = lookup(i.getOperand(0));
    193                                 BasicBlock falseBlock = lookup(i.getOperand(1));
    194                                 BasicBlock joinBlock  = lookup(i.getOperand(2));
     191                                BasicBlock trueBlock  = lookup(i.extendedOperand(1));
     192                                BasicBlock falseBlock = lookup(i.extendedOperand(2));
     193                                BasicBlock joinBlock  = lookup(i.extendedOperand(3));
    195194                                assert trueBlock  != null;
    196195                                assert falseBlock != null;
     
    284283                Instruction i = lastInstruction();
    285284                if(i.isJumpType()) {
    286                         return lookup(i.getOperand(0));
     285                        return lookup(i.extendedOperand(1));
    287286                }
    288287                if(i.isTestType()) {
    289                         return lookup(i.getOperand(1)); // falseBlock for test or exitBlock for while
     288                        return lookup(i.extendedOperand(2));    // falseBlock for test or exitBlock for while
    290289                }
    291290                return null;
  • proto/pebble/trunk/src/incode/Fragment.java

    r1279 r1282  
    102102                        switchSuccessorOperandToCopy(instr, 0, copies);
    103103                        switchSuccessorOperandToCopy(instr, 1, copies);
    104                         if(instr.getOperand(2) != null) {
     104                        if(instr.extendedOperand(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.getOperand(operandNumber));
     110                BasicBlock oldSuccessor = BasicBlock.lookup(instr.extendedOperand(operandNumber+1));
    111111                BasicBlock newSuccessor = copies.get(oldSuccessor);
    112                 instr.setOperand(operandNumber, newSuccessor.getName());
     112                instr.setExtendedOperand(operandNumber+1, newSuccessor.getName());
    113113        }
    114114       
  • proto/pebble/trunk/src/incode/Instruction.java

    r1281 r1282  
    99        private String eoperand[];
    1010        private boolean toBeDeleted;
    11         private boolean notEqualsComparison;    // for testType instructions.  False means ==0, True means !=0.
    12 
    13        
    14         ///////////////////////////////////////////////////////////////////////////
    15         // constructors and helper
    16         ///////////////////////////////////////////////////////////////////////////
    17 
     11        private boolean notEqualsComparison;    // for test-type instructions. 
     12                                                                                        // False means ==0, True means !=0.
     13
     14       
     15        ///////////////////////////////////////////////////////////////////////////
     16        // constructor and helper
     17        ///////////////////////////////////////////////////////////////////////////
    1818        public Instruction(Op operation, String ... operands) {
    1919                super();
     
    7777                this.operation = op;
    7878        }
    79         public String getVariable() {
    80                 return eoperand[0];
    81         }
    82         public void setVariable(String string) {
    83                 eoperand[0] = string;
    84         }
    85         /**
    86          * Gets an operand of the instruction.
    87          * @param i zero-based index of operand to get.
    88          * This index must be smaller than numOperands().
    89          * @return
    90          */
    91         public String getOperand(int i) {
    92                 return eoperand[i+1];
    93         }
    94         public void setOperand(int i, String string) {
    95                 eoperand[i+1] = string;
    96         }
    97        
    98         public boolean containsOperand(String symbol) {
    99                 for(int i=0; i<numOperands(); i++) {
    100                         if(getOperand(i).equals(symbol))
    101                                 return true;
    102                 }
    103                 return false;
    104         }
    10579        public String extendedOperand(int eOpNumber) {
    10680                return eoperand[eOpNumber];
     
    10983                eoperand[eOpNumber] = symbol;
    11084        }
    111        
    112         ///////////////////////////////////////////////////////////////////////////
    113         // delegate property accessors
     85        public boolean containsOperandUse(String symbol) {
     86                return firstUsedOprIndex(symbol)!=-1;
     87        }
     88        /**
     89         * Returns the first index at which this symbol appears as a used operand.
     90         * @param symbol
     91         * @return the oprIndex at which symbol is first used, or -1 if it is not used.
     92         */
     93        public int firstUsedOprIndex(String symbol) {
     94                // this uses the sorted-order property of variableUseEIndices to get first index.
     95                for(int oprIndex: variableUseEIndices()) {
     96                        if(extendedOperand(oprIndex).equals(symbol))
     97                                return oprIndex;
     98                }
     99                return -1;
     100        }
     101
     102       
     103        ///////////////////////////////////////////////////////////////////////////
     104        // delegate property accessors (delegates to Op)
    114105        ///////////////////////////////////////////////////////////////////////////
    115106        public boolean isJumpType() {
     
    125116                return operation.isCommutable();
    126117        }
     118        /**
     119         *  Get the number of operands of this instruction.  This number includes
     120         *  operand[0]  (the variable set by this instruction, if any).
     121         *  </p>
     122         * Use this only when interested in the total number of operands of any type,
     123         * not when interested in number of uses of variables.
     124         * </p>
     125         * @return      the number of meaningful operand fields in this instruction.
     126         */
    127127        public int numOperands() {
    128                 return operation.numberOfOperands();
    129         }
     128                return operation.numberOfOperands()+1;
     129        }
     130       
     131       
     132        ///////////////////////////////////////////////////////////////////////////
     133        // eOperandNumbers and helper
     134        ///////////////////////////////////////////////////////////////////////////
    130135        public int[] variableDefEIndices() {
    131136                return operation.defEIndices();
     
    134139                return operation.blockNameEIndices();
    135140        }
     141        /**
     142         * Returns a list of the oprIndices that denote variable uses in this instrution.
     143         * This routine guarantees that the indices returned are in increasing order.
     144         *
     145         * @return an increasing, possibly empty, list of oprIndices for variable uses.
     146         */
    136147        public List<Integer> variableUseEIndices() {
    137148                List<Integer> result = new ArrayList<Integer>(4);
     
    163174        }
    164175       
    165        
    166         ///////////////////////////////////////////////////////////////////////////
    167         // string representation
    168         ///////////////////////////////////////////////////////////////////////////
    169         public String toString() {
    170                 return String.format(operation.format(), eoperand[0], eoperand[1], eoperand[2], eoperand[3], comparisonString());
    171         }
    172         public String toPython() {
    173                 return String.format(operation.pythonFormat(), eoperand[0], eoperand[1], eoperand[2], eoperand[3], comparisonString());
    174         }
    175         private String comparisonString() {
    176                 return isNotEqualsComparison() ? "!=" : "==";
    177         }
    178        
     176
    179177       
    180178        ///////////////////////////////////////////////////////////////////////////
     
    182180        //              varIgnoringHashCode     helps speed expression matching
    183181        //              copy
    184         //              commute                                 switches operands 0 and 1
     182        //              commute                                 switches operands 1 and 2
    185183        ///////////////////////////////////////////////////////////////////////////
    186184
     
    189187        public int varIgnoringHashCode() {
    190188                int result = operation.ordinal();
    191                 for(int i=0; i<numOperands(); i++) {
    192                         result = result + getOperand(i).hashCode();
     189                for(int i=1; i<numOperands(); i++) {
     190                        result = result + extendedOperand(i).hashCode();
    193191                }
    194192                return result;
     
    209207       
    210208       
     209        ///////////////////////////////////////////////////////////////////////////
     210        // string representation
     211        ///////////////////////////////////////////////////////////////////////////
     212        public String toString() {
     213                return String.format(operation.format(), eoperand[0], eoperand[1], eoperand[2], eoperand[3], comparisonString());
     214        }
     215        public String toPython() {
     216                return String.format(operation.pythonFormat(), eoperand[0], eoperand[1], eoperand[2], eoperand[3], comparisonString());
     217        }
     218        private String comparisonString() {
     219                return isNotEqualsComparison() ? "!=" : "==";
     220        }
     221
    211222
    212223        ///////////////////////////////////////////////////////////////////////////
  • proto/pebble/trunk/src/incode/global/CopyRemover.java

    r1279 r1282  
    9090
    9191                                Instruction defInstruction = block.instruction(defIndex);
    92                                 defInstruction.setVariable(copySymbol);
     92                                defInstruction.setExtendedOperand(0, copySymbol);
    9393                               
    9494                                Instruction copyInstruction = block.instruction(copyIndex);
     
    183183                Instruction instruction = block.instruction(index);
    184184                if(instruction.isAssignment())
    185                         return instruction.getVariable();
     185                        return instruction.extendedOperand(0);
    186186                return "";
    187187        }
     
    191191
    192192                Instruction definition = block.instruction(defIndex);
    193                 String defSymbol = definition.getVariable();
     193                String defSymbol = definition.extendedOperand(0);
    194194
    195195                int next = defUse.getNextUse(defIndex, 0);
  • proto/pebble/trunk/src/incode/global/DeadCodeEliminator.java

    r1279 r1282  
    5353                        }
    5454                       
    55                         String var = instruction.getVariable();
     55                        String var = instruction.extendedOperand(0);
    5656                        if(liveDown.contains(var)) {
    5757                                liveDown.remove(var);
  • proto/pebble/trunk/src/incode/global/LivenessProperty.java

    r1279 r1282  
    5555                for(Instruction instr : block.reverseInstructions()) {
    5656                        if(instr.isAssignment()) {
    57                                 kills.add(instr.getVariable());
    58                                 gens.remove(instr.getVariable());
     57                                kills.add(instr.extendedOperand(0));
     58                                gens.remove(instr.extendedOperand(0));
    5959                        }
    6060                        for(int eIndex: instr.variableUseEIndices()) {
  • proto/pebble/trunk/src/incode/global/MergeBlocks.java

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

    r1279 r1282  
    102102                        int nOperands = instr.numOperands();
    103103                       
    104                         for(int eOpNumber=0; eOpNumber<nOperands+1; eOpNumber++) {
     104                        for(int eOpNumber=0; eOpNumber<nOperands; eOpNumber++) {
    105105                                String operand = instr.extendedOperand(eOpNumber);
    106106                                int definingInstrIndex = getWithDefault(lastDef, operand, BEGINNING_OF_BLOCK);
     
    125125                        }
    126126                       
    127                         lastDef.put(instr.getVariable(), index);
    128                         lastUse.remove(instr.getVariable());
     127                        lastDef.put(instr.extendedOperand(0), index);
     128                        lastUse.remove(instr.extendedOperand(0));
    129129                }
    130130        }
     
    132132                InstructionDefUseIndices previousIndices = defsAndUses.get(defIndex);
    133133                int previousEOpNum = 0;
    134                 String symbol = block.instruction(defIndex).getVariable();
     134                String symbol = block.instruction(defIndex).extendedOperand(0);
    135135               
    136136                for(int index = defIndex; index < block.numInstructions(); index++) {
     
    193193        public int getNextUse(int index, String symbol) {
    194194                Instruction instr = block.instruction(index);
    195                 int eOpIndex = getFirstEOpIndex(instr, symbol);
     195                int eOpIndex = instr.firstUsedOprIndex(symbol);
    196196                int nextUse = getNextUse(index, eOpIndex);
    197197                return nextUse;
     
    204204        private void setNextUse(int index, String operand, int value) {
    205205                Instruction instr = block.instruction(index);
    206                 int eOpIndex = getFirstEOpIndex(instr, operand);
     206                int eOpIndex = instr.firstUsedOprIndex(operand);
    207207                setNextUse(index, eOpIndex, value);
    208208        }
    209         // returns eOpIndex of the FIRST use of symbol as an operand.
    210         private int getFirstEOpIndex(Instruction instr, String symbol) {
    211                 int eOpIndex;
    212                 for(eOpIndex=1; eOpIndex<instr.numOperands()+1; eOpIndex++) {
    213                         if(instr.getOperand(eOpIndex-1).equals(symbol))
    214                                 break;
    215                 }
    216                 return eOpIndex;
    217         }
    218 
    219 
    220209        @Override
    221210        public String getName() {
  • proto/pebble/trunk/src/incode/localOptimization/ReuseAvailableExpressions.java

    r1281 r1282  
    4343                                return false;
    4444                       
    45                         for(int i=0; i<instr.numOperands(); i++) {
    46                                 String thisOperand = instr.getOperand(i);
    47                                 String otherOperand = other.instruction().getOperand(i);
     45                        for(int i=1; i<instr.numOperands(); i++) {
     46                                String thisOperand = instr.extendedOperand(i);
     47                                String otherOperand = other.instruction().extendedOperand(i);
    4848                                if(!thisOperand.equals(otherOperand))
    4949                                        return false;
     
    5757                        return instr;
    5858                }
    59                 public boolean containsOperand(String symbol) {
    60                         return instr.containsOperand(symbol);
     59                public boolean containsOperandUse(String symbol) {
     60                        return instr.containsOperandUse(symbol);
    6161                }
    6262        }
     
    8484                        return;
    8585               
    86                 String symbol = instr.getVariable();
     86                String symbol = instr.extendedOperand(0);
    8787                removeFromReplacementValues(symbol);
    8888                removeAvailabilityWithArgument(symbol);
     
    9393                for(Entry<InstructionContainer, Integer> entry: availability.entrySet()) {
    9494                        InstructionContainer instructionContainer = entry.getKey();
    95                         if(instructionContainer.containsOperand(symbol)) {
     95                        if(instructionContainer.containsOperandUse(symbol)) {
    9696                                removals.add(instructionContainer);     // avoid mutating map underneath entrySet()
    9797                        }
     
    117117        private void killReplacementForVariable(Instruction currentI) {
    118118                if(currentI.isAssignment()) {
    119                         String variable = currentI.getVariable();
     119                        String variable = currentI.extendedOperand(0);
    120120                        replacements.remove(variable);
    121121                }
     
    132132                        makeAvailable(currentIC, index);
    133133                        if(currentI.getOperation()==Op.COPY) {
    134                                 replaceUses(currentI.getVariable(), currentI.getOperand(0));
     134                                replaceUses(currentI.extendedOperand(0), currentI.extendedOperand(1));
    135135                        }
    136136                }
    137137                else {
    138138                        String priorName = availableName(currentIC);
    139                         String currentName = currentI.getVariable();
     139                        String currentName = currentI.extendedOperand(0);
    140140                       
    141141                        Instruction copy = makeCopy(currentName, priorName);
     
    148148       
    149149        private void replaceArguments(Instruction instr) {
    150                 for(int a=0; a<instr.numOperands(); a++) {
    151                         if(replacements.containsKey(instr.getOperand(a))) {
    152                                 instr.setOperand(a, replacements.get(instr.getOperand(a)));
     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)));
    153153                        }
    154154                }
     
    172172        private String availableName(InstructionContainer container) {
    173173                int index = availableIndex(container);
    174                 return block.instruction(index).getVariable();
     174                return block.instruction(index).extendedOperand(0);
    175175        }
    176176
  • proto/pebble/trunk/src/incode/localOptimization/UseAndNot.java

    r1279 r1282  
    3939                       
    4040                        for(int r=0; r<2; r++) {
    41                                 String operand = current.getOperand(r);
     41                                String operand = current.extendedOperand(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.setOperand(1, source.getOperand(0));
     51                                        current.setExtendedOperand(2, source.extendedOperand(1));
    5252                                        break;
    5353                                }
     
    5858        private void makeDefinitions() {
    5959                for(int index=0; index<block.numInstructions(); index++) {
    60                         String variable = block.instruction(index).getVariable();
     60                        String variable = block.instruction(index).extendedOperand(0);
    6161                        definitions.put(variable, index);
    6262                }
  • proto/pebble/trunk/src/util/range/test/RangeComponentTest.java

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