call and invoke instructions that are known to not write to memory.

llvm-svn: 12807

This transforms code like this:

   %C = or %A, %B
   %D = select %cond, %C, %A
into:
   %C = select %cond, %B, 0
   %D = or %A, %C

Since B is often a constant, the select can often be eliminated.  In any case,
this reduces the usage count of A, allowing subsequent optimizations to happen.

This xform applies when the operator is any of:
  add, sub, mul, or, xor, and, shl, shr

llvm-svn: 12800

  if (C)
    V1 |= V2;

into:
  Vx = V1 | V2;
  V1 = select C, V1, Vx

when the expression can be evaluated unconditionally and is *cheap* to
execute.  This limited form of if conversion is quite handy in lots of cases.
For example, it turns this testcase into straight-line code:

int in0 ; int in1 ; int in2 ; int in3 ;
int in4 ; int in5 ; int in6 ; int in7 ;
int in8 ; int in9 ; int in10; int in11;
int in12; int in13; int in14; int in15;
long output;

void mux(void) {
  output =
      (in0   ?  0x00000001 : 0) | (in1   ?  0x00000002 : 0) |
      (in2   ?  0x00000004 : 0) | (in3   ?  0x00000008 : 0) |
      (in4   ?  0x00000010 : 0) | (in5   ?  0x00000020 : 0) |
      (in6   ?  0x00000040 : 0) | (in7   ?  0x00000080 : 0) |
      (in8   ?  0x00000100 : 0) | (in9   ?  0x00000200 : 0) |
      (in10  ?  0x00000400 : 0) | (in11  ?  0x00000800 : 0) |
      (in12  ?  0x00001000 : 0) | (in13  ?  0x00002000 : 0) |
      (in14  ?  0x00004000 : 0) | (in15  ?  0x00008000 : 0) ;
}

llvm-svn: 12798

that have a constant operand.  This implements
add.ll:test19, shift.ll:test15*, and others that are not tested

llvm-svn: 12794

llvm-svn: 12793

llvm-svn: 12784

llvm-svn: 12779

Now we collect all of the call sites we are interested in inlining, then inline
them.  This entirely avoids issues with trying to inline a call site we got by
inlining another call site.  This also eliminates iterator invalidation issues.

llvm-svn: 12770

llvm-svn: 12769

llvm-svn: 12762

llvm-svn: 12659

llvm-svn: 12658

types and can have arbitrary 32- and 64-bit integer types indexing into
sequential types.

llvm-svn: 12653

This also implements some new features for the indvars pass, including
linear function test replacement, exit value substitution, and it works with
a much more general class of induction variables and loops.

llvm-svn: 12620

llvm-svn: 12618

This actually causes us to turn code like:

  return C ? A : B;

into a select instruction.

llvm-svn: 12617

llvm-svn: 12597

llvm-svn: 12595

Testcase: LoopSimplify/2004-04-01-IncorrectDomUpdate.ll

llvm-svn: 12592

llvm-svn: 12573

this and the other patches 253.perlbmk links again.

llvm-svn: 12565

llvm-svn: 12548

pass can eliminate many nasty cases of them, start generating them in the optimizers

llvm-svn: 12545

llvm-svn: 12544

llvm-svn: 12540

llvm-svn: 12520

#1 is to unconditionally strip constantpointerrefs out of
instruction operands where they are absolutely pointless and inhibit
optimization.  GRRR!

#2 is to implement InstCombine/getelementptr_const.ll

llvm-svn: 12519

llvm-svn: 12507

With this fix we now successfully extract all 149 loops from 256.bzip2 without
crashing or miscompiling the program!

llvm-svn: 12493

extracted all 63 loops for Olden/bh without crashing and without
miscompiling the program!!!

llvm-svn: 12491

exit nodes

llvm-svn: 12490

llvm-svn: 12489

llvm-svn: 12487

llvm-svn: 12486

1. Names were not put on the new arguments created (ok, this just helps sanity :)
2. Fix outgoing pointer values
3. Do not insert stores for values that had not been computed
4. Fix some wierd problems with the outset calculation

This fixes CodeExtractor/2004-03-14-DominanceProblem.ll, making the extractor
work on at least one simple case!

llvm-svn: 12484

llvm-svn: 12483

exposed the fact that the header was not self-contained.  There is a reason
we do things :)

llvm-svn: 12481

llvm-svn: 12465

llvm-svn: 12464

llvm-svn: 12458