Changeset 1283


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

Fixed bug uncovered by last modification: DefUseProperty? was looking for defs and uses of non-variable operands.

Location:
proto/pebble/trunk/src/incode
Files:
3 edited

Legend:

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

    r1282 r1283  
    55
    66public class Instruction {
     7        public static final int NO_INDEX = -1;  // returned by index-finding methods
     8       
    79        public static final int MAX_NUMBER_OPERANDS = 4;
    810        private Op operation;
     
    4143                        return null;
    4244                int firstIndex = operand.indexOf('$');
    43                 if(firstIndex == -1) {
     45                if(firstIndex == NO_INDEX) {
    4446                        return operand;
    4547                }
     
    8486        }
    8587        public boolean containsOperandUse(String symbol) {
    86                 return firstUsedOprIndex(symbol)!=-1;
     88                return firstUsedOprIndex(symbol)!=NO_INDEX;
    8789        }
    8890        /**
    8991         * Returns the first index at which this symbol appears as a used operand.
    9092         * @param symbol
    91          * @return the oprIndex at which symbol is first used, or -1 if it is not used.
     93         * @return the oprIndex at which symbol is first used, or NO_INDEX if it is not used.
    9294         */
    9395        public int firstUsedOprIndex(String symbol) {
     
    9799                                return oprIndex;
    98100                }
    99                 return -1;
     101                return NO_INDEX;
    100102        }
    101103
     
    146148         */
    147149        public List<Integer> variableUseEIndices() {
    148                 List<Integer> result = new ArrayList<Integer>(4);
     150                List<Integer> result = new ArrayList<Integer>(MAX_NUMBER_OPERANDS);
    149151                int[] indices = operation.possibleUseEIndices();
    150152                for(int index: indices) {
     
    155157                return result;
    156158        }
    157        
     159        public List<Integer> defAndUseEIndices() {
     160                List<Integer> result = variableUseEIndices();
     161                for(int i: variableDefEIndices()) {
     162                        result.add(0, (Integer)i);
     163                }
     164                return result;
     165        }
     166        public boolean oprIsAVariable(int oprIndex) {
     167                return denotesAVariable(extendedOperand(oprIndex));
     168        }
    158169        // String is not T, F, starting with [-0..9], or "smallConstant("
    159170        private boolean denotesAVariable(String s) {
  • proto/pebble/trunk/src/incode/global/CopyRemover.java

    r1282 r1283  
    5151                for(int i=numInstructions-1; i>=0; i--) {
    5252                        Instruction instruction = block.instruction(i);
    53                         if(instruction.getOperation()==Op.COPY) {
     53                        if(instruction.getOperation()==Op.COPY && instruction.oprIsAVariable(1)) {
    5454                                processCopy(i);
    5555                        }
     
    6262                        return;
    6363                }
     64
    6465
    6566                String copySymbol = definedSymbol(copyIndex);
  • proto/pebble/trunk/src/incode/localOptimization/DefUseProperty.java

    r1282 r1283  
    1717        @SuppressWarnings("unused")
    1818        private static final int IS_DEAD = -4;
    19        
    20         private static final int DOES_NOT_USE = -5;     
     19        public static final int DOES_NOT_USE = -5;
     20       
    2121        public static boolean notThisBlock(int index) {
    2222                return index < 0;
     
    100100                        Instruction instr = block.instruction(index);
    101101                        InstructionDefUseIndices indices = defsAndUses.get(index);
    102                         int nOperands = instr.numOperands();
    103102                       
    104                         for(int eOpNumber=0; eOpNumber<nOperands; eOpNumber++) {
     103                        for(int eOpNumber: instr.defAndUseEIndices()) {
    105104                                String operand = instr.extendedOperand(eOpNumber);
    106105                                int definingInstrIndex = getWithDefault(lastDef, operand, BEGINNING_OF_BLOCK);
     
    190189        // although instruction[index] may have more than one use of the symbol
    191190        // as an operand, the first of those uses has the real nextUse info.
    192         // thus we may use getEOpIndex and get the correct information.
     191        // thus we may use firstUsedOprIndex and get the correct information.
    193192        public int getNextUse(int index, String symbol) {
    194193                Instruction instr = block.instruction(index);
    195194                int eOpIndex = instr.firstUsedOprIndex(symbol);
     195                if(eOpIndex == Instruction.NO_INDEX) {
     196                        reportError("GetNextUse found unused operand " + symbol + " in instruction "+instr);
     197                        return DOES_NOT_USE;
     198                }
    196199                int nextUse = getNextUse(index, eOpIndex);
    197200                return nextUse;
     
    201204                indices.setNextUse(eOpIndex, value);
    202205        }
    203         // works only for operands, not for variable.
     206       
    204207        private void setNextUse(int index, String operand, int value) {
    205208                Instruction instr = block.instruction(index);
    206209                int eOpIndex = instr.firstUsedOprIndex(operand);
     210                if(eOpIndex == Instruction.NO_INDEX) {
     211                        reportError("SetNextUse found unused operand " + operand + " in instruction "+instr);
     212                        return;
     213                }
    207214                setNextUse(index, eOpIndex, value);
     215        }
     216        private void reportError(String string) {
     217                System.err.println("error: " + string);
    208218        }
    209219        @Override
Note: See TracChangeset for help on using the changeset viewer.