caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
31,724 Commits 1 Branch 0 Tags
da17029218cf0c19cf0341dda1ba557471e33871
Commit Graph

748 Commits

Author SHA1 Message Date
Reid Spencer
a299d6f701 Put the hack back in that removes features, causes regressions to fail, but 
allows test programs to succeed. Actual fix for this is forthcoming.

llvm-svn: 22213
 2005-06-15 18:25:30 +00:00
Reid Spencer
6d231e55fa Unbreak several InstCombine regression checks introduced by a hack to 
fix the bzip2 test. A better hack is needed.

llvm-svn: 22209
 2005-06-13 06:41:26 +00:00
Andrew Lenharth
ffe65458e7 hack to fix bzip2 (bug 571) 
llvm-svn: 22192
 2005-06-04 12:43:56 +00:00
Chris Lattner
05c703ea85 preserve calling conventions when hacking on code 
llvm-svn: 22024
 2005-05-14 12:25:32 +00:00
Chris Lattner
61d9d81770 calling a function with the wrong CC is undefined, turn it into an unreachable 
instruction.  This is useful for catching optimizers that don't preserve
calling conventions

llvm-svn: 21928
 2005-05-13 07:09:09 +00:00
Chris Lattner
b62f5082c5 implement and.ll:test33 
llvm-svn: 21809
 2005-05-09 04:58:36 +00:00
Chris Lattner
b18dbbfff5 Strength reduce SAR into SHR if there is no way sign bits could be shifted 
in.  This tends to get cases like this:

  X = cast ubyte to int
  Y = shr int X, ...

Tested by: shift.ll:test24

llvm-svn: 21775
 2005-05-08 17:34:56 +00:00
Chris Lattner
4294cec0f1 Fix a miscompilation of crafty by clobbering the "A" variable. 
llvm-svn: 21770
 2005-05-07 23:49:08 +00:00
Chris Lattner
6aacb0f9da Preserve tail marker 
llvm-svn: 21737
 2005-05-06 06:48:21 +00:00
Chris Lattner
ef298a3b8a Teach instcombine propagate zeroness through shl instructions, implementing 
and.ll:test31

llvm-svn: 21717
 2005-05-06 04:53:20 +00:00
Chris Lattner
873804168e Implement shift.ll:test23. If we are shifting right then immediately truncating 
the result, turn signed shift rights into unsigned shift rights if possible.

This leads to later simplification and happens *often* in 176.gcc.  For example,
this testcase:

struct xxx { unsigned int code : 8; };
enum codes { A, B, C, D, E, F };
int foo(struct xxx *P) {
  if ((enum codes)P->code == A)
     bar();
}

used to be compiled to:

int %foo(%struct.xxx* %P) {
        %tmp.1 = getelementptr %struct.xxx* %P, int 0, uint 0           ; <uint*> [#uses=1]
        %tmp.2 = load uint* %tmp.1              ; <uint> [#uses=1]
        %tmp.3 = cast uint %tmp.2 to int                ; <int> [#uses=1]
        %tmp.4 = shl int %tmp.3, ubyte 24               ; <int> [#uses=1]
        %tmp.5 = shr int %tmp.4, ubyte 24               ; <int> [#uses=1]
        %tmp.6 = cast int %tmp.5 to sbyte               ; <sbyte> [#uses=1]
        %tmp.8 = seteq sbyte %tmp.6, 0          ; <bool> [#uses=1]
        br bool %tmp.8, label %then, label %UnifiedReturnBlock

Now it is compiled to:

        %tmp.1 = getelementptr %struct.xxx* %P, int 0, uint 0           ; <uint*> [#uses=1]
        %tmp.2 = load uint* %tmp.1              ; <uint> [#uses=1]
        %tmp.2 = cast uint %tmp.2 to sbyte              ; <sbyte> [#uses=1]
        %tmp.8 = seteq sbyte %tmp.2, 0          ; <bool> [#uses=1]
        br bool %tmp.8, label %then, label %UnifiedReturnBlock

which is the difference between this:

foo:
        subl $4, %esp
        movl 8(%esp), %eax
        movl (%eax), %eax
        shll $24, %eax
        sarl $24, %eax
        testb %al, %al
        jne .LBBfoo_2

and this:

foo:
        subl $4, %esp
        movl 8(%esp), %eax
        movl (%eax), %eax
        testb %al, %al
        jne .LBBfoo_2

This occurs 3243 times total in the External tests, 215x in povray,
6x in each f2c'd program, 1451x in 176.gcc, 7x in crafty, 20x in perl,
25x in gap, 3x in m88ksim, 25x in ijpeg.

Maybe this will cause a little jump on gcc tommorow :)

llvm-svn: 21715
 2005-05-06 04:18:52 +00:00
Chris Lattner
7208616ec0 Implement xor.ll:test22 
llvm-svn: 21713
 2005-05-06 02:07:39 +00:00
Chris Lattner
4c2d3781aa implement and.ll:test30 and set.ll:test21 
llvm-svn: 21712
 2005-05-06 01:53:19 +00:00
Chris Lattner
dd1e562ec3 implement or.ll:test20 
llvm-svn: 21709
 2005-05-06 00:58:50 +00:00
Chris Lattner
809dfac421 Instcombine: cast (X != 0) to int, cast (X == 1) to int -> X iff X has only the low bit set. 
This implements set.ll:test20.

This triggers 2x on povray, 9x on mesa, 11x on gcc, 2x on crafty, 1x on eon,
6x on perlbmk and 11x on m88ksim.

It allows us to compile these two functions into the same code:

struct s { unsigned int bit : 1; };
unsigned foo(struct s *p) {
  if (p->bit)
    return 1;
  else
    return 0;
}
unsigned bar(struct s *p) { return p->bit; }

llvm-svn: 21690
 2005-05-04 19:10:26 +00:00
Chris Lattner
a816eee427 Implement getelementptr.ll:test11 
llvm-svn: 21647
 2005-05-01 04:42:15 +00:00
Chris Lattner
a9d84e3388 Check for volatile loads only once. 
Implement load.ll:test7

llvm-svn: 21645
 2005-05-01 04:24:53 +00:00
Chris Lattner
bd43b9db9d Fix the compile failures from last night. 
llvm-svn: 21565
 2005-04-26 14:40:41 +00:00
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