There may be a single outside predecessor and
still need a new loop-preheader if the predecessor has multiple
successors.

llvm-svn: 5656

  * Remove bogus assertion: there may be a single outside predecessor and
    still need a new loop-preheader if the predecessor has multiple
    successors.  See bug: LICM/2003-02-27-PreheaderProblem.ll

llvm-svn: 5655

llvm-svn: 5653

   - Now we perform loop exit-block splitting to ensure exit blocks are
     always dominated by the loop header.
   - We now preserve dominance frontier information
   - This fixes bug: LICM/2003-02-26-LoopExitNotDominated.ll

llvm-svn: 5652

llvm-svn: 5650

information for various accesses.  What a concept.

llvm-svn: 5647

llvm-svn: 5645

llvm-svn: 5643

llvm-svn: 5642

llvm-svn: 5641

llvm-svn: 5640

llvm-svn: 5638

llvm-svn: 5637

Convert to work with new AliasAnalysis interface by conservatively assuming all pointers are arbitrarily large accesses

llvm-svn: 5636

llvm-svn: 5635

Add tracking for Mod/Ref info

llvm-svn: 5634

    * Takes into account the size of the memory reference to determine aliasing.
    * Expose mod/ref information in a more consistent way
    * BasicAA can now disambiguate A[i][1] and A[j][2] for conservative request
      sizes

llvm-svn: 5633

llvm-svn: 5630

llvm-svn: 5624

llvm-svn: 5623

llvm-svn: 5620

a union-find based algorithm, is significantly faster, and is more general.
It will also scale to handle call instructions correctly, which is a nice
added bonus.

This includes a new pass -print-alias-sets which can be used to show how
alias sets are formed for a particular analysis.

llvm-svn: 5619

llvm-svn: 5613

a pass which wraps the function.  This allows other passes to use the functionality

llvm-svn: 5610

llvm-svn: 5608

was not correctly computed.

llvm-svn: 5606

llvm-svn: 5605

llvm-svn: 5604

llvm-svn: 5603

  * X*C + X --> X * (C+1)
  * X + X*C --> X * (C+1)
  * X - X*C --> X * (1-C)
  * X*C - X --> X * (C-1)

llvm-svn: 5592

  * A & ~A == 0
  * A / (2^c) == A >> c  if unsigned
  * 0 / A == 0
  * 1.0 * A == A
  * A * (2^c) == A << c
  * A ^ ~A == -1
  * A | ~A == -1
  * 0 % X = 0
  * A % (2^c) == A & (c-1) if unsigned
  * A - (A & B) == A & ~B
  * -1 - A == ~A

llvm-svn: 5587

llvm-svn: 5576

llvm-svn: 5572

llvm-svn: 5571

llvm-svn: 5567

This helps a lot of testcases, for example:
            New Time  New #Nodes     Old Time    Old #Nodes
254.gap:    91.1024     21605        91.1397     22657
povray31:    2.7807      8613         3.0152     10338
255.vortex:  1.2034      8153         1.2172     8822
moria:        .6756      3150          .7054     3877
300.twolf:    .1652      2010          .1851     3270

Typically, testcases which use long and ulong integers a lot get better, f.e. povray above.

llvm-svn: 5566

llvm-svn: 5565

This speeds stuff up by 10% on some tests, woot!

llvm-svn: 5564

llvm-svn: 5562

llvm-svn: 5555