docs/ChrisNotes.txt

   1 * Implement new tool: analyze whose job is solely to run an analysis phase
   2   and print out the results.
   3 * Fix DCE to elminate br <c>, %L1, %L1 so that it can optimize the main of
   4   fib.ll better.  Currently I have to do this to get best results:
   5      as < fib.ll | opt -inline -sccp -dce -sccp -dce |dis
   6 * Fix DCE to work better, so that SCCP can show it's true value.
   7 * Implement ADCE
   8 * Fix the const pool printer to print out constants in some sort of "sorted"
   9   order.  Then enable TestOptimizer.sh to diff -sccp output.  Currently it
  10   doesn't work because the diff fails because of ordering of the constant
  11   pool. :(
  12 * Enable DoConstantPoolMerging to do trivial DCE of constant values.
  13 * Should provide "castTerminator, castPHI, etc" functions in Instruction, and
  14   similar functions in other classes, that effectively do dynamic casts.  This
  15   would allow code like this:
  16     if (I->isTerminator()) {
  17       TerminatorInst *TI = (TerminatorInst*)I;
  18       ...
  19     }
  20   to be written as:
  21     if (TerminatorInst *TI = I->castTerminatorInst()) {
  22        ...
  23     }
  24 * Think about whether edge split SSA form would be useful to do.
  25 * Inlining should attempt to give block names the same name in the inlined
  26   method (using SymbolTable::getUniqueName)
  27 * The dropAllReferences code can be a noop when NDEBUG!!!
  28 * Finish xvcg output
  29 * pred/succ iterators on basic blocks don't handle switch statements correctly
  30 * Enhance BB to make predecessor handling easier (to update PHI nodes)
  31 * Provide a pass that eliminates critical edges from the CFG
  32 * Provide a print pass to print out xvcg format files for vis
  33 * I need to provide an option to the bytecode loader to ignore memory
  34   dependance edges.  Instead, the VM would just treat memory operations
  35   (load, store, getfield, putfield, call) as pinned instructions.
  36 * I need to have a way to prevent taking the address of a constant pool
  37   reference.  You should only be able to take the address of a variable.
  38   Maybe taking the address of a constant copies it?  What about virtual
  39   function tables?  Maybe a const pointer would be better...
  40 * Structures should be accessed something like this: ubyte is ok.  Limits
  41   structure size to 256 members.  This can be fixed later by either:
  42     1. adding varient that takes ushort
  43     2. Splitting structures into nested structures each of half size
  44   <float> %f = load *{int, {float}} Str, 1, 0
  45   store float %f, *{int, {float}} Str, 1, 0
  46 * I'm noticing me writing a lot of code that looks like this (dtor material here):
  47   ConstPool.dropAllReferences();
  48   ConstPool.delete_all();
  49   ConstPool.setParent(0);
  50   ~ConstPool
  51
  52 * Need a way to attach bytecode block info at various levels of asm code.
  53 * Rename "ConstantPool" to "ConstPool"
  54 * Maybe ConstantPool objects should keep themselves sorted as things are
  55   inserted.
  56 * Need to be able to inflate recursive types.  %x = { *%x }, %x = %x ()
  57 * Recognize and save comments in assembly and bytecode format
  58 * Encode line number table in bytecode (like #line), optional table
  59
  60 * Encode negative relative offsets in the bytecode file
  61
  62 * Implement switch to switch on a constant pool array of type:
  63   [{ label, int }] or [label]   (lookup vs index switch)
  64 * Apparently bison has a %pure_parser option.  Maybe useful for Assembly/Parser
  65
  66 * Implement a header file that can read either assembly or bytecode, implement
  67   a writer that can output either based on what is read with this reader..
  68 * Implement the following derived types:
  69   * structure/record               { int %foo, int %bar} or { %foo = int, int }
  70   * pointer                          int *
  71   * "packed format", like this:    [4 x sbyte]: Packed SIMD datatype
  72 * Maybe 'tailcall' also?
  73 * Include a method level bytecode block that defines a mapping between values
  74   and registers that defines a minimally register allocated code.  This can
  75   make me finally address how to encode extensions in assembly.
  76 * Bytecode reader should use extensions that may or may not be linked into the
  77   application to read blocks.  Thus an easy way to ignore symbol table info
  78   would be to not link in that reader into the app.