llvm-svn: 11129

llvm-svn: 11128

llvm-svn: 11127

llvm-svn: 11126

operand of the instruction and thus simplify the register allocation.

llvm-svn: 11124

llvm-svn: 11123

slightly slower, but I think we can handle it, especially if it means
BytecodeLibs are correctly regenerated.

llvm-svn: 11122

Take away the default iostream argument of createMachineFunctionPrinterPass(),
at Chris's request.

llvm-svn: 11121

at Chris's request.

llvm-svn: 11120

llvm-svn: 11119

  1. Don't scan to the end of alloca instructions in the caller function to
     insert inlined allocas, just insert at the top.  This saves a lot of
     time inlining into functions with a lot of allocas.
  2. Use splice to move the alloca instructions over, instead of remove/insert.
     This allows us to transfer a block at a time, and eliminates a bunch of
     silly symbol table manipulations.

This speeds up the inliner on the testcase in PR209 from 1.73s -> 1.04s (67%)

llvm-svn: 11118

to be the same (IOW they are not two address instructions).

llvm-svn: 11117

and that basic block ends with a return instruction.  In this case, we can just splice
the cloned "body" of the function directly into the source basic block, avoiding a lot
of rearrangement and splitBasicBlock's linear scan over the split block.  This speeds up
the inliner on the testcase in PR209 from 2.3s to 1.7s, a 35% reduction.

llvm-svn: 11116

llvm-svn: 11115

llvm-svn: 11114

llvm-svn: 11113

fails when the basic block points to the function->end.  Instead, require that
the client pass in the function AND the basicblock to insert into.

llvm-svn: 11112

llvm-svn: 11111

half.

llvm-svn: 11110

before we delete the original call site, allowing slight simplifications of
code, but nothing exciting.

llvm-svn: 11109

process.  The only optimization we did so far is to avoid creating a
PHI node, then immediately destroying it in the common case where the
callee has one return statement.  Instead, we just don't create the return
value.  This has no noticable performance impact, but paves the way for
future improvements.

llvm-svn: 11108

to add the cloned block to.  This allows the block to be added to the function
immediately, and all of the instructions to be immediately added to the function
symbol table, which speeds up the inliner from 3.7 -> 3.38s on the PR209.

llvm-svn: 11107

llvm-svn: 11106

instead of a loop that is really inefficient with large basic blocks.

This speeds up the inliner pass on the testcase in PR209 from 13.8s to 2.24s
which still isn't exactly speedy, but is a lot better.  :)

llvm-svn: 11105

llvm-svn: 11104

llvm-svn: 11103

See PR222.

llvm-svn: 11102

process them all as a group.  This speeds up SRoA/mem2reg from 28.46s to
0.62s on the testcase from PR209.

llvm-svn: 11100

SRoA/mem2reg from 41.2s to 27.5s on the testcase in PR209.

llvm-svn: 11099

llvm-svn: 11098

llvm-svn: 11097

llvm-svn: 11095

llvm-svn: 11094

spilled, A was loaded from its stack location twice. This fixes the bug.

llvm-svn: 11093

llvm-svn: 11091

llvm-svn: 11088

llvm-svn: 11087

TwoAddressInstructionPass can correctly update use/def information.

llvm-svn: 11086

outside of loops = 0.

llvm-svn: 11085

llvm-svn: 11084