RPCS3/archived-llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2026-01-31 01:35:20 +01:00
Code Issues Packages Projects Releases Wiki Activity
17,062 Commits 6 Branches 7 Tags
67deea9d05b9da170299526dbdf7ef15830a651c
Commit Graph

309 Commits

Author SHA1 Message Date
Chris Lattner
151c8e6390 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
5a9660aa71 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
3402945d52 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
de6b1ca556 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
708ff662ba 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
13fd87be57 Fix a compile crash on spiff 
llvm-svn: 19552
 2005-01-14 17:17:59 +00:00
Chris Lattner
6b519e3314 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
283b7d9809 Do not overrun iterators. This fixes a 176.gcc crash 
llvm-svn: 19541
 2005-01-13 23:26:48 +00:00
Chris Lattner
b3dfd0aecd 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
e59c6d1cbe 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
ee469241c3 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
aebad4db9a Fix a crash compiling 129.compress 
llvm-svn: 19533
 2005-01-13 20:14:25 +00:00
Chris Lattner
131ada2668 Fix uint64_t -> unsigned VS warnings. 
llvm-svn: 19381
 2005-01-08 19:42:22 +00:00
Chris Lattner
14d51ed06a 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
763e852e7a 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
2be8c4a870 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
f5962a7d6c note to self: Do not check in debugging code! 
llvm-svn: 18693
 2004-12-09 07:15:52 +00:00
Chris Lattner
1e2b3fd343 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
8529319568 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
fe549f46e1 Fix this regression and remove the XFAIL from this test. 
llvm-svn: 18674
 2004-12-08 23:10:30 +00:00
Chris Lattner
62e3f533f3 Fix Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll 
llvm-svn: 18670
 2004-12-08 22:20:34 +00:00
Reid Spencer
dd287f7758 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
2c4161fc57 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
ce8249f570 Delete stoppoints that occur for the same source line. 
llvm-svn: 17970
 2004-11-18 21:41:39 +00:00
Chris Lattner
20a9efa189 Quiet warnings on the persephone tester 
llvm-svn: 17821
 2004-11-15 05:54:07 +00:00
Chris Lattner
3d61b688a9 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
1e4cad9176 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
fdd41995d8 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
70e351fb1c 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
Chris Lattner
7a8d26a581 Fold: 
(X + (X << C2)) --> X * ((1 << C2) + 1)
   ((X << C2) + X) --> X * ((1 << C2) + 1)

This means that we now canonicalize "Y+Y+Y" into:

        %tmp.2 = mul long %Y, 3         ; <long> [#uses=1]

instead of:

        %tmp.10 = shl long %Y, ubyte 1          ; <long> [#uses=1]
        %tmp.6 = add long %Y, %tmp.10               ; <long> [#uses=1]

llvm-svn: 17701
 2004-11-13 19:31:40 +00:00
Chris Lattner
064071600d Fix some warnings on VC++ 
llvm-svn: 17481
 2004-11-05 04:45:43 +00:00
Chris Lattner
33ed2c8984 * Rearrange code slightly 
* Disable broken transforms for simplifying (setcc (cast X to larger), CI)
  where CC is not != or ==

llvm-svn: 17422
 2004-11-02 03:50:32 +00:00
Chris Lattner
000424b69e Hrm, this code was severely botched. As it turns out, this patch: 
http://mail.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20041018/019708.html

exposed ANOTHER latent bug in this xform, which caused Prolangs-C/bison to fill
the zion nightly tester disk up and make the tester barf.

This is obviously not a good thing, so lets fix this bug shall we? :)

llvm-svn: 17276
 2004-10-27 05:57:15 +00:00
Chris Lattner
6321852143 Fix a bug Nate noticed, where we miscompiled a simple testcase 
llvm-svn: 17157
 2004-10-22 04:53:16 +00:00
Chris Lattner
18333c64de Turn things with obviously undefined semantics into 'store -> null' 
llvm-svn: 17110
 2004-10-18 02:59:09 +00:00
Chris Lattner
dbfa9a5e9c My friend the invoke instruction does not dominate all basic blocks if it 
occurs in the entry node of a function

llvm-svn: 17109
 2004-10-18 01:48:31 +00:00
Chris Lattner
795ae57cde Remove printout, realize that instructions in the entry block dominate all 
other blocks.

llvm-svn: 17099
 2004-10-17 21:31:34 +00:00
Chris Lattner
ef0888e493 hasConstantValue will soon return instructions that don't dominate the PHI node, 
so prepare for this.

llvm-svn: 17095
 2004-10-17 21:22:38 +00:00
Chris Lattner
68f14bc09c Fix a type violation 
llvm-svn: 17069
 2004-10-16 23:28:04 +00:00
Chris Lattner
d12442c206 Kill the bogon that slipped into my buffer before I committed. 
llvm-svn: 17067
 2004-10-16 19:46:33 +00:00
Chris Lattner
b55574181d Implement InstCombine/getelementptr.ll:test9, which is the source of many 
ugly and giant constnat exprs in some programs.

llvm-svn: 17066
 2004-10-16 19:44:59 +00:00
Chris Lattner
3ebca6fb19 Optimize instructions involving undef values. For example X+undef == undef. 
llvm-svn: 17047
 2004-10-16 18:11:37 +00:00
Chris Lattner
63f15158f4 Transform memmove -> memcpy when the source is obviously constant memory. 
llvm-svn: 16932
 2004-10-12 04:52:52 +00:00
Chris Lattner
f9e79568c2 Reenable the transform, turning X/-10 < 1 into X > -10 
llvm-svn: 16918
 2004-10-11 19:40:04 +00:00
Chris Lattner
c5085d212c Implement sub.ll:test17, -X/C -> X/-C 
llvm-svn: 16863
 2004-10-09 02:50:40 +00:00
Chris Lattner
816a8a5e1e Temporarily disable a buggy transformation until it can be fixed. This fixes 
254.gap.

llvm-svn: 16853
 2004-10-08 19:15:44 +00:00
Chris Lattner
5839d93b51 Instcombine (X & FF00) + xx00 -> (X+xx00) & FF00, implementing and.ll:test27 
This comes up when doing adds to bitfield elements.

llvm-svn: 16836
 2004-10-08 05:07:56 +00:00
Chris Lattner
87259c3ce9 Little patch to turn (shl (add X, 123), 4) -> (add (shl X, 4), 123 << 4) 
This triggers in cases of bitfield additions, opening opportunities for
future improvements.

llvm-svn: 16834
 2004-10-08 03:46:20 +00:00
Chris Lattner
ff8cbd01e7 Instcombine: -(X sdiv C) -> (X sdiv -C), tested by sub.ll:test16 
llvm-svn: 16769
 2004-10-06 15:08:25 +00:00
Chris Lattner
8341306cba Hrm, debugging printouts do not need to be in here 
llvm-svn: 16598
 2004-09-29 21:21:14 +00:00