maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
18,434 Commits 23 Branches 0 Tags 2.2 GiB
Commit Graph

330 Commits

Author SHA1 Message Date
Chris Lattner a21bf8d1be implement getelementptr.ll:test10 
llvm-svn: 21541
 2005-04-25 20:17:30 +00:00
Chris Lattner 2f1457fd83 Eliminate cases where we could << by 64, which is undefined in C. 
llvm-svn: 21500
 2005-04-24 17:46:05 +00:00
Chris Lattner d6f636a340 Implement xor.ll:test21: select (not C), A, B -> select C, B, A 
llvm-svn: 21495
 2005-04-24 07:30:14 +00:00
Chris Lattner d1f46d3bf9 Use getPrimitiveSizeInBits() instead of getPrimitiveSize()*8 
Completely rework the 'setcc (cast x to larger), y' code.  This code has
the advantage of implementing setcc.ll:test19 (being more general than
the previous code) and being correct in all cases.

This allows us to unxfail 2004-11-27-SetCCForCastLargerAndConstant.ll,
and close PR454.

llvm-svn: 21491
 2005-04-24 06:59:08 +00:00
Jeff Cohen 82639853c0 Eliminate tabs and trailing spaces 
llvm-svn: 21480
 2005-04-23 21:38:35 +00:00
Chris Lattner 77c32c34d7 Generalize the setcc -> PHI and Select folding optimizations to work with 
any constant RHS, not just a constant integer RHS.  This implements
select.ll:test17

llvm-svn: 21470
 2005-04-23 15:31:55 +00:00
Misha Brukman b1c9317bb4 Remove trailing whitespace 
llvm-svn: 21427
 2005-04-21 23:48:37 +00:00
Chris Lattner 374e659466 Instcombine this: 
%shortcirc_val = select bool %tmp.1, bool true, bool %tmp.4             ; <bool> [#uses=1]
        %tmp.6 = cast bool %shortcirc_val to int                ; <int> [#uses=1]

into this:

        %shortcirc_val = or bool %tmp.1, %tmp.4         ; <bool> [#uses=1]
        %tmp.6 = cast bool %shortcirc_val to int                ; <int> [#uses=1]

not this:

        %tmp.4.cast = cast bool %tmp.4 to int           ; <int> [#uses=1]
        %tmp.6 = select bool %tmp.1, int 1, int %tmp.4.cast             ; <int> [#uses=1]

llvm-svn: 21389
 2005-04-21 05:43:13 +00:00
Chris Lattner 5c219469a0 Eliminate a broken transformation, fixing PR548 
llvm-svn: 21354
 2005-04-19 06:04:18 +00:00
Chris Lattner 4236261930 Fix bug: InstCombine/2005-05-07-UDivSelectCrash.ll 
llvm-svn: 21152
 2005-04-08 04:03:26 +00:00
Chris Lattner 4706046e68 Implement the following xforms: 
(X-Y)-X --> -Y
A + (B - A) --> B
(B - A) + A --> B

llvm-svn: 21138
 2005-04-07 17:14:51 +00:00
Chris Lattner c7f3c1a00e Implement InstCombine/add.ll:test28, transforming C1-(X+C2) --> (C1-C2)-X. 
This occurs several dozen times in specint2k, particularly in crafty and gcc
apparently.

llvm-svn: 21136
 2005-04-07 16:28:01 +00:00
Chris Lattner a9be4490d8 Transform X-(X+Y) == -Y and X-(Y+X) == -Y 
llvm-svn: 21134
 2005-04-07 16:15:25 +00:00
Chris Lattner ecfa9b5810 disable this transformation in the one obscure case that really pessimizes 
pointer analysis.

llvm-svn: 20916
 2005-03-29 06:37:47 +00:00
Chris Lattner cfe2822cdf Do not compute 1ULL << 64, which is undefined. This fixes Ptrdist/ks on the 
sparc, and testcase Regression/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll

llvm-svn: 20445
 2005-03-04 23:21:33 +00:00
Chris Lattner 72684fecf8 Implement InstCombine/cast.ll:test25, a case that occurs many times 
in spec

llvm-svn: 19953
 2005-01-31 05:51:45 +00:00
Chris Lattner 31f486c775 Implement the trivial cases in InstCombine/store.ll 
llvm-svn: 19950
 2005-01-31 05:36:43 +00:00
Chris Lattner fe1b0b8b24 Implement Transforms/InstCombine/cast-load-gep.ll, which allows us to devirtualize 
11 indirect calls in perlbmk.

llvm-svn: 19947
 2005-01-31 04:50:46 +00:00
Chris Lattner d8e20188c6 Adjust to changes in instruction interfaces. 
llvm-svn: 19900
 2005-01-29 00:39:08 +00:00
Chris Lattner cd517ff0c7 * add some DEBUG statements 
* Properly compile this:

struct a {};
int test() {
  struct a b[2];
  if (&b[0] != &b[1])
    abort ();
  return 0;
}

to 'return 0', not abort().

llvm-svn: 19875
 2005-01-28 19:32:01 +00:00
Chris Lattner 9e2c7facb2 Get rid of a several dozen more and instructions in specint. 
llvm-svn: 19786
 2005-01-23 20:26:55 +00:00
Chris Lattner fc4429e7c1 Handle comparisons of gep instructions that have different typed indices 
as long as they are the same size.

llvm-svn: 19734
 2005-01-21 23:06:49 +00:00
Chris Lattner 411336fe04 Add two optimizations. The first folds (X+Y)-X -> Y 
The second folds operations into selects, e.g. (select C, (X+Y), (Y+Z))
-> (Y+(select C, X, Z)

This occurs a few times across spec, e.g.

         select    add/sub
mesa:    83        0
povray:  5         2
gcc      4         2
parser   0         22
perlbmk  13        30
twolf    0         3

llvm-svn: 19706
 2005-01-19 21:50:18 +00:00
Chris Lattner 715364364b Delete PHI nodes that are not dead but are locked in a cycle of single 
useness.

llvm-svn: 19629
 2005-01-17 05:10:15 +00:00
Chris Lattner 03f06f11aa Move code out of indentation one level to make it easier to read. 
Disable the xform for < > cases.  It turns out that the following is being
miscompiled:

bool %test(sbyte %S) {
        %T = cast sbyte %S to uint
        %V = setgt uint %T, 255
        ret bool %V
}

llvm-svn: 19628
 2005-01-17 03:20:02 +00:00
Chris Lattner 51726c47fe Fix some bugs in an xform added yesterday. This fixes Prolangs-C/allroots. 
llvm-svn: 19553
 2005-01-14 17:35:12 +00:00
Chris Lattner 7aa41cfa88 Fix a compile crash on spiff 
llvm-svn: 19552
 2005-01-14 17:17:59 +00:00
Chris Lattner 4fa89827e2 if two gep comparisons only differ by one index, compare that index directly. 
This allows us to better optimize begin() -> end() comparisons in common cases.

llvm-svn: 19542
 2005-01-14 00:20:05 +00:00
Chris Lattner d35d210ea0 Do not overrun iterators. This fixes a 176.gcc crash 
llvm-svn: 19541
 2005-01-13 23:26:48 +00:00
Chris Lattner a04c904c4c Turn select C, (X+Y), (X-Y) --> (X+(select C, Y, (-Y))). This occurs in 
the 'sim' program and probably elsewhere.  In sim, it comes up for cases
like this:

#define round(x) ((x)>0.0 ? (x)+0.5 : (x)-0.5)
double G;
void T(double X) { G = round(X); }

(it uses the round macro a lot).  This changes the LLVM code from:

        %tmp.1 = setgt double %X, 0.000000e+00          ; <bool> [#uses=1]
        %tmp.4 = add double %X, 5.000000e-01            ; <double> [#uses=1]
        %tmp.6 = sub double %X, 5.000000e-01            ; <double> [#uses=1]
        %mem_tmp.0 = select bool %tmp.1, double %tmp.4, double %tmp.6
        store double %mem_tmp.0, double* %G

to:

        %tmp.1 = setgt double %X, 0.000000e+00          ; <bool> [#uses=1]
        %mem_tmp.0.p = select bool %tmp.1, double 5.000000e-01, double -5.000000e-01
        %mem_tmp.0 = add double %mem_tmp.0.p, %X
        store double %mem_tmp.0, double* %G
        ret void

llvm-svn: 19537
 2005-01-13 22:52:24 +00:00
Chris Lattner 81e8417614 Implement an optimization for == and != comparisons like this: 
_Bool test2(int X, int Y) {
  return &arr[X][Y] == arr;
}

instead of generating this:

bool %test2(int %X, int %Y) {
        %tmp.3.idx = mul int %X, 160            ; <int> [#uses=1]
        %tmp.3.idx1 = shl int %Y, ubyte 2               ; <int> [#uses=1]
        %tmp.3.offs2 = sub int 0, %tmp.3.idx            ; <int> [#uses=1]
        %tmp.7 = seteq int %tmp.3.idx1, %tmp.3.offs2            ; <bool> [#uses=1]
        ret bool %tmp.7
}


generate this:

bool %test2(int %X, int %Y) {
        seteq int %X, 0         ; <bool>:0 [#uses=1]
        seteq int %Y, 0         ; <bool>:1 [#uses=1]
        %tmp.7 = and bool %0, %1                ; <bool> [#uses=1]
        ret bool %tmp.7
}

This idiom occurs in C++ programs when iterating from begin() to end(),
in a vector or array.  For example, we now compile this:

void test(int X, int Y) {
  for (int *i = arr; i != arr+100; ++i)
    foo(*i);
}

to this:

no_exit:                ; preds = %entry, %no_exit
	...
        %exitcond = seteq uint %indvar.next, 100                ; <bool> [#uses=1]
        br bool %exitcond, label %return, label %no_exit



instead of this:

no_exit:                ; preds = %entry, %no_exit
	...
        %inc5 = getelementptr [100 x [40 x int]]* %arr, int 0, int 0, int %inc.rec              ; <int*> [#uses=1]
        %tmp.8 = seteq int* %inc5, getelementptr ([100 x [40 x int]]* %arr, int 0, int 100, int 0)              ; <bool> [#uses=1]
        %indvar.next = add uint %indvar, 1              ; <uint> [#uses=1]
        br bool %tmp.8, label %return, label %no_exit

llvm-svn: 19536
 2005-01-13 22:25:21 +00:00
Chris Lattner 4cb9fa373b Fix some bugs in code I didn't mean to check in. 
llvm-svn: 19534
 2005-01-13 20:40:58 +00:00
Chris Lattner 0798af33a5 Fix a crash compiling 129.compress 
llvm-svn: 19533
 2005-01-13 20:14:25 +00:00
Chris Lattner fdfe3e49fe Fix uint64_t -> unsigned VS warnings. 
llvm-svn: 19381
 2005-01-08 19:42:22 +00:00
Chris Lattner 86102b8ad5 This is a bulk commit that implements the following primary improvements: 
* We can now fold cast instructions into select instructions that
    have at least one constant operand.
  * We now optimize expressions more aggressively based on bits that are
    known to be zero.  These optimizations occur a lot in code that uses
    bitfields even in simple ways.
  * We now turn more cast-cast sequences into AND instructions.  Before we
    would only do this if it if all types were unsigned.  Now only the
    middle type needs to be unsigned (guaranteeing a zero extend).
  * We transform sign extensions into zero extensions in several cases.

This corresponds to these test/Regression/Transforms/InstCombine testcases:
  2004-11-22-Missed-and-fold.ll
  and.ll: test28-29
  cast.ll: test21-24
  and-or-and.ll
  cast-cast-to-and.ll
  zeroext-and-reduce.ll

llvm-svn: 19220
 2005-01-01 16:22:27 +00:00
Chris Lattner 9ad0d55025 Constant exprs are not efficiently negatable in practice. This disables 
turning X - (constantexpr) into X + (-constantexpr) among other things.

llvm-svn: 18935
 2004-12-14 20:08:06 +00:00
Chris Lattner bf5b7cf638 Optimize div/rem + select combinations more. 
In particular, implement div.ll:test10 and rem.ll:test4.

llvm-svn: 18838
 2004-12-12 21:48:58 +00:00
Chris Lattner 36d39cecb4 note to self: Do not check in debugging code! 
llvm-svn: 18693
 2004-12-09 07:15:52 +00:00
Chris Lattner f17a2fb849 Implement trivial sinking for load instructions. This causes us to sink 567 loads in spec 
llvm-svn: 18692
 2004-12-09 07:14:34 +00:00
Chris Lattner 39c98bb31c Do extremely simple sinking of instructions when they are only used in a 
successor block.  This turns cases like this:

x = a op b
if (c) {
  use x
}

into:

if (c) {
  x = a op b
  use x
}

This triggers 3965 times in spec, and is tested by
Regression/Transforms/InstCombine/sink_instruction.ll

This appears to expose a bug in the X86 backend for 177.mesa, which I'm
looking in to.

llvm-svn: 18677
 2004-12-08 23:43:58 +00:00
Alkis Evlogimenos a1291a0679 Fix this regression and remove the XFAIL from this test. 
llvm-svn: 18674
 2004-12-08 23:10:30 +00:00
Chris Lattner 8f30caf549 Fix Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll 
llvm-svn: 18670
 2004-12-08 22:20:34 +00:00
Reid Spencer 279fa256a2 Fix for PR454: 
* Make sure we handle signed to unsigned conversion correctly
* Move this visitSetCondInst case to its own method.

llvm-svn: 18312
 2004-11-28 21:31:15 +00:00
Chris Lattner 14f3cdc227 Implement Regression/Transforms/InstCombine/getelementptr_cast.ll, which 
occurs many times in crafty

llvm-svn: 18273
 2004-11-27 17:55:46 +00:00
Chris Lattner 953075442d Delete stoppoints that occur for the same source line. 
llvm-svn: 17970
 2004-11-18 21:41:39 +00:00
Chris Lattner 97013636cd Quiet warnings on the persephone tester 
llvm-svn: 17821
 2004-11-15 05:54:07 +00:00
Chris Lattner 46dd5a6304 This optimization makes MANY phi nodes that all have the same incoming value. 
If this happens, detect it early instead of relying on instcombine to notice
it later.  This can be a big speedup, because PHI nodes can have many
incoming values.

llvm-svn: 17741
 2004-11-14 19:29:34 +00:00
Chris Lattner 7515cabe2a Implement instcombine/phi.ll:test6 - pulling operations through PHI nodes. 
This exposes subsequent optimization possiblities and reduces code size.
This triggers 1423 times in spec.

llvm-svn: 17740
 2004-11-14 19:13:23 +00:00
Chris Lattner 15ff1e1885 Transform this: 
%X = alloca ...
  %Y = alloca ...
    X == Y

into false.  This allows us to simplify some stuff in eon (and probably
many other C++ programs) where operator= was checking for self assignment.
Folding this allows us to SROA several additional structs.

llvm-svn: 17735
 2004-11-14 07:33:16 +00:00
Chris Lattner 8c3e7b92af Simplify handling of shifts to be the same as we do for adds. Add support 
for (X * C1) + (X * C2) (where * can be mul or shl), allowing us to fold:

   Y+Y+Y+Y+Y+Y+Y+Y

into
         %tmp.8 = shl long %Y, ubyte 3           ; <long> [#uses=1]

instead of

        %tmp.4 = shl long %Y, ubyte 2           ; <long> [#uses=1]
        %tmp.12 = shl long %Y, ubyte 2          ; <long> [#uses=1]
        %tmp.8 = add long %tmp.4, %tmp.12               ; <long> [#uses=1]

This implements add.ll:test25

Also add support for (X*C1)-(X*C2) -> X*(C1-C2), implementing sub.ll:test18

llvm-svn: 17704
 2004-11-13 19:50:12 +00:00