Changeset 1306


Ignore:
Timestamp:
Aug 11, 2011, 3:09:00 AM (8 years ago)
Author:
shermer
Message:

Fixed a bug in DefUseProperty?, which was causing the CopyRemover? to choke.
Changed Pythonater back to producing the Basis_bit struct definition, and the RangeCompiler? to using bit names rather than a bit array.
Added MiscellaneousSemanticChecks? to ensure that there is one ExecutionBlock? per program.
Updated the jar.

Location:
proto/pebble/trunk
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/src/ast/nodes/BlockStatementASTN.java

    r1259 r1306  
    1717// or decls.
    1818//
    19 // if there are assumption children, they must be at the beginning of
    20 // the child list.
    2119//
    2220//
  • proto/pebble/trunk/src/incode/Pythonater.java

    r1279 r1306  
    2222        ///////////////////////////////////////////////////////////////
    2323        private static void printPythonStructs(SymbolTable symtab, PrintStream out) {
    24 //              out.println(Pythonater.buildBasisBitStruct());
     24                out.println(Pythonater.buildBasisBitStruct());
    2525                out.println(buildUserStructs(symtab));
    2626        }
    27         @SuppressWarnings("unused")
    2827        private static String buildBasisBitStruct() {
    2928                PStringBuilder builder = new PStringBuilder(0);
  • proto/pebble/trunk/src/incode/global/CopyRemover.java

    r1284 r1306  
    11package incode.global;
    2 
    3 import java.util.ArrayList;
    4 import java.util.List;
    5 import java.util.Set;
    6 
    72
    83import incode.BasicBlock;
     
    116import incode.Op;
    127import incode.localOptimization.DefUseProperty;
     8
     9import java.util.Set;
    1310
    1411public class CopyRemover {
     
    5754        }
    5855
     56       
    5957        private void processCopy(int copyIndex) {
    6058                int defIndex = defUse.getDef(copyIndex, 1);
     
    6361                }
    6462
    65 
    6663                String copySymbol = definedSymbol(copyIndex);
    67                 String defSymbol = definedSymbol(defIndex);
     64                String defSymbol = definedSymbol(defIndex);             
    6865               
    6966                boolean copyLiveOut = liveOut.contains(copySymbol);
    7067                boolean defLiveOut  = liveOut.contains(defSymbol);
    71 
    72 
     68               
    7369                if(copyLiveOut && defLiveOut) {
    7470                        return;                 // would need global analysis to improve this
     
    187183                return "";
    188184        }
    189         @SuppressWarnings("unused")
    190         private List<Integer> usesOf(int defIndex) {
    191                 List<Integer> result = new ArrayList<Integer>();
    192 
    193                 Instruction definition = block.instruction(defIndex);
    194                 String defSymbol = definition.operand(0);
    195 
    196                 int next = defUse.getNextUse(defIndex, 0);
    197                 addToListIfValidUse(result, defSymbol, next);
    198                
    199                 while(isLocalIndex(next)) {
    200                         int current = next;
    201                         next = defUse.getNextUse(current, defSymbol);
    202                         addToListIfValidUse(result, defSymbol, next);
    203                 }
    204                 return result;
    205         }
    206185
    207186        private boolean isLocalIndex(int next) {
    208187                return !DefUseProperty.notThisBlock(next);
    209188        }
    210         private boolean isLiveIndex(int instructionIndex) {
    211                 Instruction instruction = block.instruction(instructionIndex);
    212                 return !instruction.isToBeDeleted();
    213         }
    214 
    215         private void addToListIfValidUse(List<Integer> list, String symbol,
    216                         int instructionIndex) {
    217                 if(isLocalIndex(instructionIndex) &&
    218                    isLiveIndex(instructionIndex)) {
    219                         list.add(instructionIndex);
    220                 }
    221                 else {
    222                         if(instructionIndex == DefUseProperty.END_OF_BLOCK && liveOut.contains(symbol)) {
    223                                 list.add(instructionIndex);
    224                         }
    225                 }
    226         }
    227 
    228189}
  • proto/pebble/trunk/src/incode/localOptimization/DefUseProperty.java

    r1284 r1306  
    99import incode.Instruction;
    1010import util.PStringBuilder;
     11import util.error.ErrLog;
    1112import util.property.Property;
    1213import static incode.Instruction.MAX_NUMBER_OPERANDS;
     
    8586       
    8687        //
    87         // the def index for the variable of an instruction is its
     88        // the def index for the defined variable of an instruction is its
    8889        // previous definition.
    8990        //
    90         // we get spurious indices for string arguments to instructions,
    91         // such as in the comment or error instructions.  So one should
    92         // take care to not use the resulting values for these arguments.
    9391       
    9492        public void make() {
     
    10199                        InstructionDefUseIndices indices = defsAndUses.get(index);
    102100                       
    103                         for(int eOpNumber: instr.defAndUseOprIndices()) {
    104                                 String operand = instr.operand(eOpNumber);
     101                        // uses
     102                        for(int oprNumber: instr.useOprIndices()) {
     103                                String operand = instr.operand(oprNumber);
    105104                                int definingInstrIndex = getWithDefault(lastDef, operand, BEGINNING_OF_BLOCK);
    106                                 indices.setDef(eOpNumber, definingInstrIndex);
    107                                 indices.setNextUse(eOpNumber, END_OF_BLOCK);
     105                                indices.setDef(oprNumber, definingInstrIndex);
     106                                indices.setNextUse(oprNumber, END_OF_BLOCK);
    108107                               
    109108                               
    110                                 if(eOpNumber>0) {       // uses only
    111                                         if(lastUse.get(operand)==null) {
    112                                                 if(definingInstrIndex!=BEGINNING_OF_BLOCK) {
    113                                                         setNextUse(definingInstrIndex, 0, index);
    114                                                 }
     109                                if(lastUse.get(operand)==null) {        // previously unused
     110                                        if(definingInstrIndex!=BEGINNING_OF_BLOCK) {    //local defn
     111                                                setNextUse(definingInstrIndex, 0, index);       //TODO: deal with opr = 0 (rather than instr.defOprIndices() )here.
    115112                                        }
    116                                         else {
    117                                                 // in instruction lastUseIndex, "operand" may be used more
    118                                                 // than once.  This sets the first of those uses' nextUse value.
    119                                                 int lastUseIndex = lastUse.get(operand);
    120                                                 setNextUse(lastUseIndex, operand, index);       
     113                                }
     114                                else {
     115                                        // in instruction lastUseIndex, "operand" may be used more
     116                                        // than once.  This sets the first of those uses' nextUse value.
     117                                        // But if the last use was this instruction, then don't disturb
     118                                        // it (it's END_OF_BLOCK).
     119                                        int lastUseIndex = lastUse.get(operand);
     120                                        if(lastUseIndex != index) {
     121                                                setNextUse(lastUseIndex, operand, index);
    121122                                        }
    122                                         lastUse.put(operand, index);
    123123                                }
     124                                lastUse.put(operand, index);
    124125                        }
    125126                       
    126                         lastDef.put(instr.operand(0), index);
    127                         lastUse.remove(instr.operand(0));
     127                        // def, if any
     128                        for(int oprNumber: instr.defOprIndices()) {
     129                                String operand = instr.operand(oprNumber);
     130                                int definingInstrIndex = getWithDefault(lastDef, operand, BEGINNING_OF_BLOCK);
     131                                indices.setDef(oprNumber, definingInstrIndex);
     132                                indices.setNextUse(oprNumber, END_OF_BLOCK);                   
     133                               
     134                                lastDef.put(operand, index);
     135                                lastUse.remove(operand);
     136                        }
     137
    128138                }
    129139        }
     
    187197                return indices.getNextUse(eOpIndex);
    188198        }
     199       
    189200        // although instruction[index] may have more than one use of the symbol
    190201        // as an operand, the first of those uses has the real nextUse info.
     
    192203        public int getNextUse(int index, String symbol) {
    193204                Instruction instr = block.instruction(index);
    194                 int eOpIndex = instr.firstUseOf(symbol);
    195                 if(eOpIndex == Instruction.NO_INDEX) {
    196                         reportError("GetNextUse found unused operand " + symbol + " in instruction "+instr);
     205                int oprIndex = instr.firstUseOf(symbol);
     206                if(oprIndex == Instruction.NO_INDEX) {
     207                        ErrLog.reportError("GetNextUse found unused operand " + symbol + " in instruction "+instr);
    197208                        return DOES_NOT_USE;
    198209                }
    199                 int nextUse = getNextUse(index, eOpIndex);
     210                int nextUse = getNextUse(index, oprIndex);
    200211                return nextUse;
    201212        }
     
    209220                int eOpIndex = instr.firstUseOf(operand);
    210221                if(eOpIndex == Instruction.NO_INDEX) {
    211                         reportError("SetNextUse found unused operand " + operand + " in instruction "+instr);
     222                        ErrLog.reportError("SetNextUse found unused operand " + operand + " in instruction "+instr);
    212223                        return;
    213224                }
    214225                setNextUse(index, eOpIndex, value);
    215         }
    216         private void reportError(String string) {
    217                 System.err.println("error: " + string);
    218226        }
    219227        @Override
  • proto/pebble/trunk/src/main/Main.java

    r1287 r1306  
    1616import parser.PebbleLexer;
    1717import parser.PebbleParser;
     18import semantic.MiscellaneousSemanticChecks;
    1819import semantic.StructAnalyzer;
    1920
     
    4748
    4849        try {
     50                // scanning and parsing
    4951            PebbleParser g = new PebbleParser(tokens, null);
    5052            PebbleParser.prog_return parsed = g.prog();
    51             AST tree = parsed.asTree;
    52 
    53             MacroExpander.buildAndApply(tree);
    54 //          System.err.println("tree:\n"+tree);
     53            AST tree = parsed.asTree;           
     54           
     55            // ast restructuring
     56            MacroExpander.buildAndApply(tree);         
    5557            ParseStatementExpander.apply(tree);
     58            MoveLexdefsToBranchStarts.apply(tree);
     59            AssumptionIncorporator.apply(tree);
    5660           
    57 //          System.err.println("tree:\n"+tree);
    58             MoveLexdefsToBranchStarts.apply(tree);
    59             LexicalCollector headCollector = ((ProgramBlockASTN)tree).getCollector();
    6061 
    61             AssumptionIncorporator.apply(tree);
    6262//          System.err.println("tree:\n"+tree);
    6363           
     64            // semantic analysis
     65            LexicalCollector headCollector = ((ProgramBlockASTN)tree).getCollector();
    6466            headCollector.putStructsInSymbolTable(tree.getSymbolTable());
    6567            StructAnalyzer.apply(tree);
     68            MiscellaneousSemanticChecks.apply(tree);
    6669           
     70            // intermediate code generation
    6771            BasicBlock headBlock = ASTtoIncode.apply(tree);
     72           
     73            // optimization
    6874            Fragment fragment = Fragment.make(headBlock);
    6975            MergeBlocks.apply(fragment);
    70            
    7176            ReuseAvailableExpressions.apply(headBlock);         // make this global.
    72 
    7377            LivenessProperty.build(fragment);
    7478            DeadCodeEliminator.apply(fragment);
    75            
    7679            CopyRemover.apply(fragment);
    7780//xx            UseAndNot.apply(fragment);
     81           
     82           
     83            // output code generation
    7884            if(ErrLog.hasError()) {
    7985                ErrLog.reportError("Errors found.  No code produced.");
  • proto/pebble/trunk/src/parseStatement/steps/ComplaintStep.java

    r1305 r1306  
    33import static parseStatement.ASTCodeUtils.*;
    44import ast.AST;
    5 import ast.exprNodes.AndASTB;
    65import ast.exprNodes.StringConstantASTB;
    76import ast.exprNodes.TupleASTB;
  • proto/pebble/trunk/src/util/range/ASTRangeCompiler.java

    r1246 r1306  
    4040
    4141        private static final int NBITS = 8;
    42         private static final String BIT_VARIABLE_NAME_BASE = "bit[%d]";
    43 //      private static final String BIT_VARIABLE_NAME_BASE = "basis_bits.bit_%d";
     42//      private static final String BIT_VARIABLE_NAME_BASE = "bit[%d]";
     43        private static final String BIT_VARIABLE_NAME_BASE = "basis_bits.bit_%d";
    4444       
    4545       
Note: See TracChangeset for help on using the changeset viewer.