RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-30 15:32:52 +01:00
Code Issues Projects Releases Wiki Activity
17,291 Commits 4 Branches 5 Tags 704 MiB
5f8b7b03b0
Commit Graph

9193 Commits

Author SHA1 Message Date
Chris Lattner
891aa537f7 Teach legalize to promote SetCC results. 
llvm-svn: 19657
 2005-01-18 02:59:52 +00:00
Chris Lattner
95307053ec Allow setcc operations to have nonbool types. 
llvm-svn: 19656
 2005-01-18 02:52:03 +00:00
Chris Lattner
b3edb09ede Rely on the code in MatchAddress to do this work. Otherwise we fail to 
match (X+Y)+(Z << 1), because we match the X+Y first, consuming the index
register, then there is no place to put the Z.

llvm-svn: 19652
 2005-01-18 02:25:52 +00:00
Chris Lattner
906541da95 Fix the completely broken FP constant folds for setcc's. 
llvm-svn: 19651
 2005-01-18 02:11:55 +00:00
Chris Lattner
ce2e0125dc Fix a problem where probing for addressing modes caused expressions to be 
emitted too early.  In particular, this fixes
Regression/CodeGen/X86/regpressure.ll:regpressure3.

This also improves the 2nd basic block in 164.gzip:flush_block, which went from

.LBBflush_block_1:      # loopentry.1.i
        movzx %EAX, WORD PTR [dyn_ltree + 20]
        movzx %ECX, WORD PTR [dyn_ltree + 16]
        mov DWORD PTR [%ESP + 32], %ECX
        movzx %ECX, WORD PTR [dyn_ltree + 12]
        movzx %EDX, WORD PTR [dyn_ltree + 8]
        movzx %EBX, WORD PTR [dyn_ltree + 4]
        mov DWORD PTR [%ESP + 36], %EBX
        movzx %EBX, WORD PTR [dyn_ltree]
        add DWORD PTR [%ESP + 36], %EBX
        add %EDX, DWORD PTR [%ESP + 36]
        add %ECX, %EDX
        add DWORD PTR [%ESP + 32], %ECX
        add %EAX, DWORD PTR [%ESP + 32]
        movzx %ECX, WORD PTR [dyn_ltree + 24]
        add %EAX, %ECX
        mov %ECX, 0
        mov %EDX, %ECX

to

.LBBflush_block_1:      # loopentry.1.i
        movzx %EAX, WORD PTR [dyn_ltree]
        movzx %ECX, WORD PTR [dyn_ltree + 4]
        add %ECX, %EAX
        movzx %EAX, WORD PTR [dyn_ltree + 8]
        add %EAX, %ECX
        movzx %ECX, WORD PTR [dyn_ltree + 12]
        add %ECX, %EAX
        movzx %EAX, WORD PTR [dyn_ltree + 16]
        add %EAX, %ECX
        movzx %ECX, WORD PTR [dyn_ltree + 20]
        add %ECX, %EAX
        movzx %EAX, WORD PTR [dyn_ltree + 24]
        add %ECX, %EAX
        mov %EAX, 0
        mov %EDX, %EAX

... which results in less spilling in the function.

This change alone speeds up 164.gzip from 37.23s to 36.24s on apoc.  The
default isel takes 37.31s.

llvm-svn: 19650
 2005-01-18 01:06:26 +00:00
Chris Lattner
a78f9ced61 Fix indentation. 
llvm-svn: 19649
 2005-01-17 23:25:45 +00:00
Chris Lattner
dff1e3e86f Don't bother using max here. 
llvm-svn: 19647
 2005-01-17 23:02:13 +00:00
Chris Lattner
2d86b43318 Do not give token factor nodes outrageous weights 
llvm-svn: 19645
 2005-01-17 22:56:09 +00:00
Chris Lattner
c0aca0d13c Non-volatile loads can be freely reordered against each other. This fixes 
X86/reg-pressure.ll again, and allows us to do nice things in other cases.
For example, we now codegen this sort of thing:

int %loadload(int *%X, int* %Y) {
  %Z = load int* %Y
  %Y = load int* %X      ;; load between %Z and store
  %Q = add int %Z, 1
  store int %Q, int* %Y
  ret int %Y
}

Into this:

loadload:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EAX, DWORD PTR [%EAX]
        mov %ECX, DWORD PTR [%ESP + 8]
        inc DWORD PTR [%ECX]
        ret

where we weren't able to form the 'inc [mem]' before.  This also lets the
instruction selector emit loads in any order it wants to, which can be good
for register pressure as well.

llvm-svn: 19644
 2005-01-17 22:19:26 +00:00
Chris Lattner
f2878ce8ba Two changes: 
1. Fold  [mem] += (1|-1) into inc [mem]/dec [mem] to save some icache space.
 2. Do not let token factor nodes prevent forming '[mem] op= val' folds.

llvm-svn: 19643
 2005-01-17 22:10:42 +00:00
Chris Lattner
49291c4d96 Don't call SelectionDAG.getRoot() directly, go through a forwarding method. 
llvm-svn: 19642
 2005-01-17 19:43:36 +00:00
Chris Lattner
40c0fca632 Refactor load/op/store folding into it's own method, no functionality changes. 
llvm-svn: 19641
 2005-01-17 19:25:26 +00:00
Chris Lattner
88bbcfc893 Implement a target independent optimization to codegen arguments only into 
the basic block that uses them if possible.  This is a big win on X86, as it
lets us fold the argument loads into instructions and reduce register pressure
(by not loading all of the arguments in the entry block).

For this (contrived to show the optimization) testcase:

int %argtest(int %A, int %B) {
        %X = sub int 12345, %A
        br label %L
L:
        %Y = add int %X, %B
        ret int %Y
}

we used to produce:

argtest:
        mov %ECX, DWORD PTR [%ESP + 4]
        mov %EAX, 12345
        sub %EAX, %ECX
        mov %EDX, DWORD PTR [%ESP + 8]
.LBBargtest_1:  # L
        add %EAX, %EDX
        ret


now we produce:

argtest:
        mov %EAX, 12345
        sub %EAX, DWORD PTR [%ESP + 4]
.LBBargtest_1:  # L
        add %EAX, DWORD PTR [%ESP + 8]
        ret

This also fixes the FIXME in the code.

BTW, this occurs in real code.  164.gzip shrinks from 8623 to 8608 lines of
.s file.  The stack frame in huft_build shrinks from 1644->1628 bytes,
inflate_codes shrinks from 116->108 bytes, and inflate_block from 2620->2612,
due to fewer spills.

Take that alkis. :-)

llvm-svn: 19639
 2005-01-17 17:55:19 +00:00
Chris Lattner
2348abc421 Fix a major regression last night that prevented us from producing [mem] op= reg 
operations.

The body of the if is less indented but unmodified in this patch.

llvm-svn: 19638
 2005-01-17 17:49:14 +00:00
Chris Lattner
49a1f3a109 Refactor code into a new method. 
llvm-svn: 19635
 2005-01-17 17:15:02 +00:00
Chris Lattner
adb669ab1f Codegen this: 
int %foo(int %X) {
        %T = add int %X, 13
        %S = mul int %T, 3
        ret int %S
}

as this:

        mov %ECX, DWORD PTR [%ESP + 4]
        lea %EAX, DWORD PTR [%ECX + 2*%ECX + 39]
        ret

instead of this:

        mov %ECX, DWORD PTR [%ESP + 4]
        mov %EAX, %ECX
        add %EAX, 13
        imul %EAX, %EAX, 3
        ret

llvm-svn: 19633
 2005-01-17 06:48:02 +00:00
Tanya Lattner
5a10531cf8 Added tmp instructions to preserve ssa. 
llvm-svn: 19632
 2005-01-17 06:47:26 +00:00
Chris Lattner
51590b615c Fix test/Regression/CodeGen/X86/2005-01-17-CycleInDAG.ll and 132.ijpeg. 
Do not fold a load into an operation if it will induce a cycle in the DAG.

Repeat after me: dAg.

llvm-svn: 19631
 2005-01-17 06:26:58 +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
f1e85bec5a Do not fold a load into a comparison that is used by more than one place. 
The comparison will probably be folded, so this is not ok to do.
This fixed 197.parser.

llvm-svn: 19624
 2005-01-17 01:34:14 +00:00
Chris Lattner
1b8c8fe020 Do not codegen 'xor bool, true' as 'not reg'. not reg inverts the upper bits 
of the bytereg.  This fixes yacr2, 300.twolf and probably others.

llvm-svn: 19622
 2005-01-17 00:23:16 +00:00
Chris Lattner
46dac4394c Set up the shift and setcc types. 
If we emit a load because we followed a token chain to get to it, try to
fold it into its single user if possible.

llvm-svn: 19620
 2005-01-17 00:00:33 +00:00
Chris Lattner
4c88cc95ee Shift and setcc types default to the pointer type. 
llvm-svn: 19619
 2005-01-16 23:59:48 +00:00
Chris Lattner
ec55e3e529 Implement legalize of call nodes. 
llvm-svn: 19617
 2005-01-16 19:46:48 +00:00
Tanya Lattner
fea188af7e Added paramters to a few functions in order to allow me to change the functions to preserve SSA 
llvm-svn: 19615
 2005-01-16 08:51:10 +00:00
Chris Lattner
9ffc59287e * Adjust to changes in TargetLowering interfaces. 
* Remove custom promotion for bool and byte select ops.  Legalize now
  promotes them for us.
* Allow folding ConstantPoolIndexes into EXTLOAD's, useful for float immediates.
* Declare which operations are not supported better.
* Add some hacky code for TRUNCSTORE to pretend that we have truncstore
  for i16 types.  This is useful for testing promotion code because I can
  just remove 16-bit registers all together and verify that programs work.

llvm-svn: 19614
 2005-01-16 07:34:08 +00:00
Chris Lattner
0eca430af1 Revamp supported ops. Instead of just being supported or not, we now keep 
track of how to deal with it, and provide the target with a hook that they
can use to legalize arbitrary operations in arbitrary ways.

Implement custom lowering for a couple of ops, implement promotion for select
operations (which x86 needs).

llvm-svn: 19613
 2005-01-16 07:29:19 +00:00
Chris Lattner
835a5efef3 add method stub 
llvm-svn: 19612
 2005-01-16 07:28:41 +00:00
Chris Lattner
907534af24 Don't mash stuff together. 
llvm-svn: 19611
 2005-01-16 07:28:31 +00:00
Chris Lattner
b49d2a7b0f Use enums, move virtual dtor out of line. 
llvm-svn: 19610
 2005-01-16 07:28:11 +00:00
Chris Lattner
0f4f239899 Implement some more missing promotions. 
llvm-svn: 19606
 2005-01-16 05:06:12 +00:00
Chris Lattner
e88e660817 Fix bugpoint 
llvm-svn: 19605
 2005-01-16 04:23:22 +00:00
Chris Lattner
be2a427f51 cycles_t -> CycleCount_t 
llvm-svn: 19604
 2005-01-16 04:20:30 +00:00
Chris Lattner
742b77f9af Clarify assertion. 
llvm-svn: 19597
 2005-01-16 02:23:34 +00:00
Chris Lattner
4517b8af97 Add assertions. 
llvm-svn: 19596
 2005-01-16 02:23:22 +00:00
Chris Lattner
9f8589f4b3 Add support for promoted registers being live across blocks. 
llvm-svn: 19595
 2005-01-16 02:23:07 +00:00
Reid Spencer
afa1cb9e11 Rename BUILD_* to PROJ_* 
llvm-svn: 19592
 2005-01-16 02:21:29 +00:00
Tanya Lattner
66cf1a6f82 Fixed a couple of instructions that broke SSA. 
llvm-svn: 19587
 2005-01-16 02:14:17 +00:00
Chris Lattner
605b9a23a2 Improve compatiblity with HPUX on Itanium, patch by Duraid Madina 
llvm-svn: 19586
 2005-01-16 01:31:31 +00:00
Chris Lattner
06c297f8ca Set up identity transforms. 
llvm-svn: 19584
 2005-01-16 01:20:18 +00:00
Chris Lattner
01e2ce8a4c Move some information into the TargetLowering object. 
llvm-svn: 19583
 2005-01-16 01:11:45 +00:00
Chris Lattner
9762070e50 Use the new TLI method to get this. 
llvm-svn: 19582
 2005-01-16 01:11:19 +00:00
Chris Lattner
1d0e1ffe02 Move some information out of LegalizeDAG into the generic Target interface. 
llvm-svn: 19581
 2005-01-16 01:10:58 +00:00
Chris Lattner
0777f84d53 legalize a bunch of operations that I missed. 
llvm-svn: 19580
 2005-01-16 00:38:00 +00:00
Chris Lattner
1de18d422e Add support for targets that require promotions. 
llvm-svn: 19579
 2005-01-16 00:37:38 +00:00
Chris Lattner
8c4c81d6b3 Fix some serious bugs in promotion. 
llvm-svn: 19578
 2005-01-16 00:17:42 +00:00
Chris Lattner
9785def2cd Eliminate unneeded extensions. 
llvm-svn: 19577
 2005-01-16 00:17:20 +00:00
Chris Lattner
df02c93d90 Implement promotion of a whole bunch more operators. I think that this is 
basically everything.

llvm-svn: 19576
 2005-01-15 22:16:26 +00:00
Chris Lattner
f3fd0c6a93 Print extra type for nodes with extra type info. 
llvm-svn: 19575
 2005-01-15 21:11:37 +00:00
Chris Lattner
1ab9009270 Add support for legalizing FP_ROUND_INREG, SIGN_EXTEND_INREG, and 
ZERO_EXTEND_INREG for targets that don't support them.

llvm-svn: 19573
 2005-01-15 07:15:18 +00:00
Chris Lattner
191ac9c589 Common code factored out. 
llvm-svn: 19572
 2005-01-15 07:14:32 +00:00
Chris Lattner
3b20db54f3 implement these methods. 
llvm-svn: 19571
 2005-01-15 06:52:40 +00:00
Chris Lattner
fdd07b4092 Add support for promoting ADD/MUL. 
Add support for new SIGN_EXTEND_INREG, ZERO_EXTEND_INREG, and FP_ROUND_INREG operators.
Realize that if we do any promotions, we need to iterate SelectionDAG
construction.

llvm-svn: 19569
 2005-01-15 06:18:18 +00:00
Chris Lattner
2f65e8798f Add new SIGN_EXTEND_INREG, ZERO_EXTEND_INREG, and FP_ROUND_INREG operators. 
llvm-svn: 19568
 2005-01-15 06:17:04 +00:00
Chris Lattner
98611ce291 Add a new target-independent code generator flag. 
llvm-svn: 19567
 2005-01-15 06:00:32 +00:00
Chris Lattner
f3d950e816 Add support for truncstore and *extload. 
llvm-svn: 19566
 2005-01-15 05:22:24 +00:00
Chris Lattner
94b8a3e50c Add intitial support for promoting some operators. 
llvm-svn: 19565
 2005-01-15 05:21:40 +00:00
Reid Spencer
ad96095c97 We don't distribute the operating system specific directories any more. 
llvm-svn: 19563
 2005-01-14 22:43:01 +00:00
Chris Lattner
2dfbc4fddd Adjust to CopyFromReg changes, implement deletion of truncating/extending 
stores/loads.

llvm-svn: 19562
 2005-01-14 22:38:01 +00:00
Chris Lattner
27c91fac94 Adjust to CopyFromREg changes. 
llvm-svn: 19561
 2005-01-14 22:37:41 +00:00
Chris Lattner
0974002024 Start implementing truncating stores and extending loads. 
llvm-svn: 19559
 2005-01-14 22:08:15 +00:00
Chris Lattner
c032990335 Fix Regression/CodeGen/PowerPC/2005-01-14-UndefLong.ll 
llvm-svn: 19557
 2005-01-14 20:22:02 +00:00
Chris Lattner
b0b49268c4 Fix: Regression/CodeGen/PowerPC/2005-01-14-SetSelectCrash.ll 
llvm-svn: 19555
 2005-01-14 19:31:00 +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
2087f3c8e9 Improve compatibility with acc 
llvm-svn: 19549
 2005-01-14 15:54:24 +00:00
Chris Lattner
1e5620dfe1 Make this compatible with the HP/intel compiler. Fix by Duraid, thanks! 
llvm-svn: 19548
 2005-01-14 15:53:26 +00:00
Jeff Cohen
7dfbb46f7f Fix and improve win32 path validation. 
llvm-svn: 19545
 2005-01-14 04:09:39 +00:00
Reid Spencer
4e90250e81 Make asctime_r work for HP/UX. 
llvm-svn: 19544
 2005-01-14 00:50:50 +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
7a8788c9ac Add new ImplicitDef node, rename CopyRegSDNode class to RegSDNode. 
llvm-svn: 19535
 2005-01-13 20:50:02 +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
fce6a5439d Codegen factor nodes more intelligently according to perceived register pressure. 
llvm-svn: 19532
 2005-01-13 19:56:00 +00:00
Chris Lattner
9cc534f2dc Don't forget the existing root. 
llvm-svn: 19531
 2005-01-13 19:53:14 +00:00
Chris Lattner
cb4359465a Initial trivial (but stupid) codegen for this node. 
llvm-svn: 19529
 2005-01-13 18:01:36 +00:00
Chris Lattner
160fdb384b Codegen independent ops as being independent. 
llvm-svn: 19528
 2005-01-13 17:59:43 +00:00
Chris Lattner
37a5de6eb0 Legalize new node, add assertion. 
llvm-svn: 19527
 2005-01-13 17:59:25 +00:00
Chris Lattner
86b19c5605 Print new node. 
llvm-svn: 19526
 2005-01-13 17:59:10 +00:00
Chris Lattner
9a70166615 Add some really pedantic assertions to the load folding code. Fix a bunch 
of cases where we accidentally emitted a load folded once and unfolded
elsewhere.

llvm-svn: 19522
 2005-01-13 05:53:16 +00:00
Chris Lattner
93cb0148f8 Do not fold (zero_ext (sign_ext V)) -> (sign_ext V), they are not the same. 
This fixes llvm-test/SingleSource/Regression/C/casts.c

llvm-svn: 19519
 2005-01-12 18:51:15 +00:00
Chris Lattner
2ab70aafe0 We can only fold a load into an op if there is exactly one use of the value. 
Checking to see if the load has two uses is not equivalent, as the chain
value may have zero uses.

llvm-svn: 19518
 2005-01-12 18:38:26 +00:00
Chris Lattner
e97b0e1358 New method 
llvm-svn: 19517
 2005-01-12 18:37:47 +00:00
Chris Lattner
1b3b24f116 Fix sign extend to long. When coming from sbyte, we used to generate: 
movsbl 4(%esp), %eax
        movl %eax, %edx
        sarl $7, %edx

Now we generate:

        movsbl 4(%esp), %eax
        movl %eax, %edx
        sarl $31, %edx

Which is right.

llvm-svn: 19515
 2005-01-12 18:19:52 +00:00
Chris Lattner
4b03f0f99e Try both ways to fold an add together. This allows us to generate this code 
imul %EAX, %EAX, 400
        add %ECX, %EAX
        add %ESI, DWORD PTR [%ECX + 4*%EDX]
        inc %EDX
        cmp %EDX, 100

instead of this:

        imul %EAX, %EAX, 400
        add %ECX, %EAX
        mov %EAX, %EDX
        shl %EAX, 2
        add %ECX, %EAX
        add %ESI, DWORD PTR [%ECX]
        inc %EDX
        cmp %EDX, 100

llvm-svn: 19513
 2005-01-12 18:08:53 +00:00
Reid Spencer
c8c50250a1 Shut up warnings with GCC 3.4.3 about uninitialized variables. 
llvm-svn: 19512
 2005-01-12 14:53:45 +00:00
Chris Lattner
61c572eb7f Fix a major miscompilation where we were overwriting the scale reg. 
llvm-svn: 19511
 2005-01-12 07:33:20 +00:00
Chris Lattner
5816f1a302 Do not use the type of the RHS constant to determine the type of the operation. 
This fails for shifts because the constant is always 8 bits.

llvm-svn: 19508
 2005-01-12 05:22:07 +00:00
Chris Lattner
89d6b21ae6 Do not lose the offset from teh global when peephole optimizing instructions. 
This fixes FreeBench/pcompress

llvm-svn: 19507
 2005-01-12 05:17:28 +00:00
Chris Lattner
c9b64b9749 Silence VC++ warnings. 
llvm-svn: 19506
 2005-01-12 04:51:37 +00:00
Jeff Cohen
614a5ec22a Fix C++ more compilatiom errors 
llvm-svn: 19504
 2005-01-12 04:29:05 +00:00
Chris Lattner
5ef92f3a40 Fix a compile error with VC++, which things that static const arrays need 
to be dynamically initialized. :(

llvm-svn: 19503
 2005-01-12 04:23:22 +00:00
Chris Lattner
627c64e5e5 Fix a bug that caused us to crash on povray. We weren't emitting an FP_REG_KILL into a block that had a successor with a FP PHI node. 
llvm-svn: 19502
 2005-01-12 04:21:28 +00:00
Chris Lattner
a5f0ba59a0 Print a load of a null pointer (in intel mode) like this: 
mov %AX, WORD PTR [0]

instead of like this:

        mov %AX, WORD PTR []

llvm-svn: 19501
 2005-01-12 04:07:11 +00:00
Chris Lattner
360988bae2 Print a load of a null pointer like this: 
movw 0, %ax

instead of like this:

        movw , %ax

llvm-svn: 19500
 2005-01-12 04:05:19 +00:00
Chris Lattner
3c85c67c97 Fix a crash compiling povray on UINT_TO_FP from i16. 
llvm-svn: 19499
 2005-01-12 04:00:00 +00:00
Chris Lattner
e7945a2e2e Add an option to view the selection dags as they are generated. 
llvm-svn: 19498
 2005-01-12 03:41:21 +00:00
Chris Lattner
4e72a2a000 There are no [mem] op= reg instructions for FP, so remove their entries. 
llvm-svn: 19496
 2005-01-12 03:16:09 +00:00
Chris Lattner
00cb0ace9b Fix a bug where we didn't insert FP_REG_KILL instructions into MBB's that 
contain FP PHI nodes but no other FP defining instructions.  This fixes
183.equake

llvm-svn: 19495
 2005-01-12 02:57:10 +00:00
Chris Lattner
92166ed1df Fold TRUNCATE (LOAD P) into a smaller load from P. 
llvm-svn: 19494
 2005-01-12 02:19:06 +00:00
Chris Lattner
258b23bd9d Be more careful about order of arg evalution for CopyToReg nodes. This shrinks 
256.bzip2 from 7142 to 7103 lines of .s file.

Second, add initial support for folding loads into compares, though this code
is dynamically dead for now. :(

llvm-svn: 19493
 2005-01-12 02:02:48 +00:00
Chris Lattner
604416e8f4 Fold some more [mem] op= val operators. This allows us to things like this 
several times in 256.bzip2:

        mov %EAX, DWORD PTR [%ESP + 204]
-       mov %EAX, DWORD PTR [%EAX]
-       or %EAX, 2097152
-       mov %ECX, DWORD PTR [%ESP + 204]
-       mov DWORD PTR [%ECX], %EAX
+       or DWORD PTR [%EAX], 2097152

llvm-svn: 19492
 2005-01-12 01:28:00 +00:00
Chris Lattner
e83ae1063f Fold loads into sign/zero extends. instead of: 
mov %AL, BYTE PTR [%EDX + l18_length_code]
  movzx %EAX, %AL

Emit:

  movzx %EAX, BYTE PTR [%EDX + l18_length_code]

llvm-svn: 19489
 2005-01-11 23:33:00 +00:00
Chris Lattner
87a38bd4a8 Comment out debug code :) 
Select [mem] += Val operations.  For constants, we used to get:

  mov %ECX, -32768
  add %ECX, DWORD PTR [l4_match_start]
  mov DWORD PTR [l4_match_start], %ECX

Now we get:

  add DWORD PTR [l4_match_start], -32768

For other values we used to get:

  mov %EBP, %EDI   ;; because the add destroys the value
  add %EBP, DWORD PTR [l4_input_len]
  mov DWORD PTR [l4_input_len], %EBP

now we get:

  add DWORD PTR [l4_input_len], %EDI

Both of these use less registers than the alternative, are faster and smaller.

llvm-svn: 19488
 2005-01-11 23:21:30 +00:00
Chris Lattner
282473a25d Handle the global address case here, not just the offset case. 
llvm-svn: 19487
 2005-01-11 22:58:43 +00:00
Chris Lattner
9eb2cc700b Treat int constants as not requiring a register, since they are almost always 
folded into an instruction.

llvm-svn: 19486
 2005-01-11 22:29:12 +00:00
Chris Lattner
74fcfd5148 Print the value types in the nodes of the graph 
llvm-svn: 19485
 2005-01-11 22:21:04 +00:00
Chris Lattner
f588cdd51e add an assertion, avoid creating copyfromreg/copytoreg pairs that are the 
same for PHI nodes.

llvm-svn: 19484
 2005-01-11 22:03:46 +00:00
Chris Lattner
7cb2220907 * Factor a bunch of binary operator cases into shared code. 
* Fold loads into Add, sub, and, or, xor and mul when possible.
* Codegen shl X, 1 as add X, X

llvm-svn: 19483
 2005-01-11 21:19:59 +00:00
Chris Lattner
b1a72cb39a Clear the whole array, always. 
llvm-svn: 19482
 2005-01-11 20:25:26 +00:00
Chris Lattner
b838c9748e Fold multiplies by 3,5,9 into addressing modes when possible. 
llvm-svn: 19480
 2005-01-11 19:37:02 +00:00
Chris Lattner
8de5a27681 Squelch optimized warning. 
llvm-svn: 19475
 2005-01-11 17:46:49 +00:00
Chris Lattner
e7b1130b01 Instead of generating stuff like this: 
mov %ECX, %EAX
        add %ECX, 32768
        mov %SI, WORD PTR [2*%ECX + l13_prev]

Generate this:

        mov %SI, WORD PTR [2*%ECX + l13_prev + 65536]

This occurs when you have a GEP instruction where an index is
"something + imm".

llvm-svn: 19472
 2005-01-11 06:36:20 +00:00
Chris Lattner
bb63a09cd1 Implement MEMCPY natively in terms of rep movs* 
llvm-svn: 19468
 2005-01-11 06:19:26 +00:00
Chris Lattner
b2b08a8bc1 Implement memset -> rep stos* 
llvm-svn: 19467
 2005-01-11 06:14:36 +00:00
Chris Lattner
58816a9e81 Announce that we don't support mem ops yet. 
llvm-svn: 19466
 2005-01-11 05:57:36 +00:00
Chris Lattner
963af6652b Teach legalize to lower MEMSET/MEMCPY/MEMMOVE operations if the target 
does not support them.

llvm-svn: 19465
 2005-01-11 05:57:22 +00:00
Chris Lattner
6b9082114f Print new operations. 
llvm-svn: 19464
 2005-01-11 05:57:01 +00:00
Chris Lattner
7cde8a2658 Turn memset/memcpy/memmove into the corresponding operations. 
llvm-svn: 19463
 2005-01-11 05:56:49 +00:00
Chris Lattner
f867443d7e Teach the address selector to make 'reg+reg' addressing modes. 
llvm-svn: 19457
 2005-01-11 04:40:19 +00:00
Reid Spencer
7e9642515c Add the LOADABLE_MODULE=1 directive to indicate that this shared library is 
intended to be a dlopenable module and not a "plain" shared library.

llvm-svn: 19456
 2005-01-11 04:33:32 +00:00
Chris Lattner
edf06be50e Emit NOT instructions. 
llvm-svn: 19455
 2005-01-11 04:31:30 +00:00
Chris Lattner
2eacd11a86 shift X, 0 -> X 
llvm-svn: 19453
 2005-01-11 04:25:13 +00:00
Chris Lattner
4e4bef2d6c Fix a bug emitting branches that broke a lot of programs. 
llvm-svn: 19452
 2005-01-11 04:06:27 +00:00
Chris Lattner
4b51297a94 Be more careful where we set ContainsFPCode. We were missing a set in the 
int -> FP casting code.  Note that we don't have to set it for FP operations
that take FP values as operands: whatever produces the FP value will set the
flag.

llvm-svn: 19451
 2005-01-11 03:50:45 +00:00
Chris Lattner
0c4c4094e3 Fix a major bug in setcc/cmov folding, where we accidentally 
inverted the sense of the comparison.

llvm-svn: 19450
 2005-01-11 03:37:59 +00:00
Chris Lattner
d188e03011 Take register pressure into account when we have to decide whether to 
evaluate the LHS or the RHS of an operation first.  This causes good things
to happen.  For example, instead of compiling a loop to this:

.LBBstrength_result7_1: # loopentry
        movl 16(%esp), %edi
        movl (%edi), %edi             ;;; LOAD
        movl (%ecx), %ebx
        movl $2, (%eax,%ebx,4)
        movl (%edx), %ebx
        movl %esi, %ebp
        addl $21, %ebp
        addl $42, %esi
        cmpl $0, %edi                 ;;; USE
        cmovne %esi, %ebp
        cmpl %ebp, %ebx
        movl %ebp, %esi
        jg .LBBstrength_result7_1

We now compile it to this:

.LBBstrength_result7_1: # loopentry
        movl %edi, %ebx
        addl $42, %ebx
        addl $21, %edi
        movl (%ecx), %ebp              ;; LOAD
        cmpl $0, %ebp                  ;; USE
        cmovne %ebx, %edi
        movl (%edx), %ebx
        movl $2, (%eax,%ebx,4)
        movl (%esi), %ebx
        cmpl %edi, %ebx
        jg .LBBstrength_result7_1

Which reduces register pressure enough (in this case) to avoid spilling in the
loop.

As another example, consider the CodeGen/X86/regpressure.ll testcase.  We
used to generate this code for both cases:

regpressure1:
        subl $32, %esp
        movl %esi, 12(%esp)
        movl %edi, 8(%esp)
        movl %ebx, 4(%esp)
        movl %ebp, (%esp)
        movl 36(%esp), %ecx
        movl (%ecx), %eax
        movl 4(%ecx), %edx
        movl %edx, 24(%esp)
        movl 8(%ecx), %edx
        movl %edx, 16(%esp)
        movl 12(%ecx), %edx
        movl 16(%ecx), %esi
        movl 20(%ecx), %edi
        movl 24(%ecx), %ebx
        movl %ebx, 28(%esp)
        movl 28(%ecx), %ebx
        movl 32(%ecx), %ebp
        movl %ebp, 20(%esp)
        movl 36(%ecx), %ecx
        imull 24(%esp), %eax
        imull 16(%esp), %eax
        imull %edx, %eax
        imull %esi, %eax
        imull %edi, %eax
        imull 28(%esp), %eax
        imull %ebx, %eax
        imull 20(%esp), %eax
        imull %ecx, %eax
        movl (%esp), %ebp
        movl 4(%esp), %ebx
        movl 8(%esp), %edi
        movl 12(%esp), %esi
        addl $32, %esp
        ret

This code is basically trying to do all of the loads first, then execute all
of the multiplies.  Because we run out of registers, lots of spill code happens.
We now generate this code for both cases:

regpressure1:
        movl 4(%esp), %ecx
        movl (%ecx), %eax
        movl 4(%ecx), %edx
        imull %edx, %eax
        movl 8(%ecx), %edx
        imull %edx, %eax
        movl 12(%ecx), %edx
        imull %edx, %eax
        movl 16(%ecx), %edx
        imull %edx, %eax
        movl 20(%ecx), %edx
        imull %edx, %eax
        movl 24(%ecx), %edx
        imull %edx, %eax
        movl 28(%ecx), %edx
        imull %edx, %eax
        movl 32(%ecx), %edx
        imull %edx, %eax
        movl 36(%ecx), %ecx
        imull %ecx, %eax
        ret

which is much nicer (when we fold loads into the muls it will be even better).
The old instruction selector used to produce the good code for regpressure1
but not for regpressure2, as it depended on the order of operations in the
LLVM code.

llvm-svn: 19449
 2005-01-11 03:11:44 +00:00
Chris Lattner
07a3ade230 Print SelectionDAGs bottom up, include extra info in the node labels 
llvm-svn: 19447
 2005-01-11 00:34:33 +00:00
Chris Lattner
1c273d3a14 Add a marker for the graph root. 
llvm-svn: 19445
 2005-01-10 23:52:04 +00:00
Chris Lattner
daa052a97e Put the operation name in each node, put the function name on the graph. 
llvm-svn: 19444
 2005-01-10 23:26:00 +00:00
Chris Lattner
0307506841 Split out SDNode::getOperationName into its own method. 
llvm-svn: 19443
 2005-01-10 23:25:25 +00:00
Chris Lattner
8c13447254 Implement initial selectiondag printing support. This gets us a nice 
graph with no labels! :)

llvm-svn: 19441
 2005-01-10 23:08:40 +00:00
Chris Lattner
497e24c885 Fold setcc instructions into selects. 
llvm-svn: 19438
 2005-01-10 22:10:13 +00:00
Chris Lattner
65d007ab62 Add conditional moves for the parity flag. 
llvm-svn: 19437
 2005-01-10 22:09:33 +00:00
Chris Lattner
5433d8de29 Lower to the correct functions. This fixes FreeBench/fourinarow 
llvm-svn: 19436
 2005-01-10 21:02:37 +00:00
Chris Lattner
d61491dea2 Implement 8-bit multiply for X86. 
llvm-svn: 19435
 2005-01-10 20:55:48 +00:00
Chris Lattner
b35b30c283 Rework constant pool handling so that function constant pools are no longer 
leaked to the system.  Now they are destroyed with the JITMemoryManager is
destroyed.

llvm-svn: 19434
 2005-01-10 18:23:22 +00:00
Jeff Cohen
8b03a55724 Apply feedback from Chris. 
llvm-svn: 19432
 2005-01-10 04:23:32 +00:00
Jeff Cohen
a7f1ae5dc0 Apply feed back from Chris: 
1. Rename createLoaderPass to CreateProfileLoaderPass
  2. Opt shouldn't use the pass registered in CodeGen.

llvm-svn: 19431
 2005-01-10 03:56:27 +00:00
Chris Lattner
02236df007 Implement a couple of more simplifications. This lets us codegen: 
int test2(int * P, int* Q, int A, int B) {
        return P+A == P;
}

into:

test2:
        movl 4(%esp), %eax
        movl 12(%esp), %eax
        shll $2, %eax
        cmpl $0, %eax
        sete %al
        movzbl %al, %eax
        ret

instead of:

test2:
        movl 4(%esp), %eax
        movl 12(%esp), %ecx
        leal (%eax,%ecx,4), %ecx
        cmpl %eax, %ecx
        sete %al
        movzbl %al, %eax
        ret

ICC is producing worse code:

test2:
        movl      4(%esp), %eax                                 #8.5
        movl      12(%esp), %edx                                #8.5
        lea       (%edx,%edx), %ecx                             #9.9
        addl      %ecx, %ecx                                    #9.9
        addl      %eax, %ecx                                    #9.9
        cmpl      %eax, %ecx                                    #9.16
        movl      $0, %eax                                      #9.16
        sete      %al                                           #9.16
        ret                                                     #9.16

as is GCC (looks like our old code):

test2:
        movl    4(%esp), %edx
        movl    12(%esp), %eax
        leal    (%edx,%eax,4), %ecx
        cmpl    %edx, %ecx
        sete    %al
        movzbl  %al, %eax
        ret

llvm-svn: 19430
 2005-01-10 02:03:02 +00:00
Chris Lattner
8d09b03ed1 Fix incorrect constant folds, fixing Stepanov after the SHR patch. 
llvm-svn: 19429
 2005-01-10 01:16:03 +00:00
Chris Lattner
9d479d4a34 Constant fold shifts, turning this loop: 
.LBB_Z5test0PdS__3:     # no_exit.1
        fldl data(,%eax,8)
        fldl 24(%esp)
        faddp %st(1)
        fstl 24(%esp)
        incl %eax
        movl $16000, %ecx
        sarl $3, %ecx
        cmpl %eax, %ecx
        fstpl 16(%esp)
        #FP_REG_KILL
        jg .LBB_Z5test0PdS__3   # no_exit.1

into:

.LBB_Z5test0PdS__3:     # no_exit.1
        fldl data(,%eax,8)
        fldl 24(%esp)
        faddp %st(1)
        fstl 24(%esp)
        incl %eax
        cmpl $2000, %eax
        fstpl 16(%esp)
        #FP_REG_KILL
        jl .LBB_Z5test0PdS__3   # no_exit.1

llvm-svn: 19427
 2005-01-10 00:07:15 +00:00
Reid Spencer
283688b80d Rename Unix/*.cpp and Win32/*.cpp to have a *.inc suffix so that the silly 
gdb debugger doesn't get confused on which file it is reading (the one in
lib/System or the one in lib/System/{Win32,Unix})

llvm-svn: 19426
 2005-01-09 23:29:00 +00:00
Chris Lattner
59d7066da8 Add some folds for == and != comparisons. This allows us to 
codegen this loop in stepanov:

no_exit.i:              ; preds = %entry, %no_exit.i, %then.i, %_Z5checkd.exit
        %i.0.0 = phi int [ 0, %entry ], [ %i.0.0, %no_exit.i ], [ %inc.0, %_Z5checkd.exit ], [ %inc.012, %then.i ]              ; <int> [#uses=3]
        %indvar = phi uint [ %indvar.next, %no_exit.i ], [ 0, %entry ], [ 0, %then.i ], [ 0, %_Z5checkd.exit ]          ; <uint> [#uses=3]
        %result_addr.i.0 = phi double [ %tmp.4.i.i, %no_exit.i ], [ 0.000000e+00, %entry ], [ 0.000000e+00, %then.i ], [ 0.000000e+00, %_Z5checkd.exit ]          ; <double> [#uses=1]
        %first_addr.0.i.2.rec = cast uint %indvar to int                ; <int> [#uses=1]
        %first_addr.0.i.2 = getelementptr [2000 x double]* %data, int 0, uint %indvar           ; <double*> [#uses=1]
        %inc.i.rec = add int %first_addr.0.i.2.rec, 1           ; <int> [#uses=1]
        %inc.i = getelementptr [2000 x double]* %data, int 0, int %inc.i.rec            ; <double*> [#uses=1]
        %tmp.3.i.i = load double* %first_addr.0.i.2             ; <double> [#uses=1]
        %tmp.4.i.i = add double %result_addr.i.0, %tmp.3.i.i            ; <double> [#uses=2]
        %tmp.2.i = seteq double* %inc.i, getelementptr ([2000 x double]* %data, int 0, int 2000)                ; <bool> [#uses=1]
        %indvar.next = add uint %indvar, 1              ; <uint> [#uses=1]
        br bool %tmp.2.i, label %_Z10accumulateIPddET0_T_S2_S1_.exit, label %no_exit.i

To this:

.LBB_Z4testIPddEvT_S1_T0__1:    # no_exit.i
        fldl data(,%eax,8)
        fldl 16(%esp)
        faddp %st(1)
        fstpl 16(%esp)
        incl %eax
        movl %eax, %ecx
        shll $3, %ecx
        cmpl $16000, %ecx
        #FP_REG_KILL
        jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i

instead of this:

.LBB_Z4testIPddEvT_S1_T0__1:    # no_exit.i
        fldl data(,%eax,8)
        fldl 16(%esp)
        faddp %st(1)
        fstpl 16(%esp)
        incl %eax
        leal data(,%eax,8), %ecx
        leal data+16000, %edx
        cmpl %edx, %ecx
        #FP_REG_KILL
        jne .LBB_Z4testIPddEvT_S1_T0__1 # no_exit.i

llvm-svn: 19425
 2005-01-09 20:52:51 +00:00
Jeff Cohen
f692cd303d Add last four createXxxPass functions 
llvm-svn: 19424
 2005-01-09 20:42:52 +00:00
Jeff Cohen
91dd6d2d20 Fix VC++ compilation error 
llvm-svn: 19423
 2005-01-09 20:41:56 +00:00
Chris Lattner
fa06762d0e Print the DAG out more like a DAG in nested format. 
llvm-svn: 19422
 2005-01-09 20:38:33 +00:00
Chris Lattner
e3b9f22967 Print out nodes sorted by their address to make it easier to find them in a list. 
llvm-svn: 19421
 2005-01-09 20:26:36 +00:00
Chris Lattner
fcab5f75c0 Codegen (Reg|imm)+&GV as an LEA, because we cannot put it into the immediate field 
of an ADDri (due to current restrictions on MachineOperand :( ).  This allows
us to generate:

        leal Data+16000, %edx

instead of:

        movl $Data, %edx
        addl $16000, %edx

llvm-svn: 19420
 2005-01-09 20:20:29 +00:00
Chris Lattner
82caa0dc2e Add a simple transformation. This allows us to compile one of the inner 
loops in stepanov to this:

.LBB_Z5test0PdS__2:     # no_exit.1
        fldl data(,%eax,8)
        fldl 24(%esp)
        faddp %st(1)
        fstl 24(%esp)
        incl %eax
        cmpl $2000, %eax
        fstpl 16(%esp)
        #FP_REG_KILL
        jl .LBB_Z5test0PdS__2

instead of this:

.LBB_Z5test0PdS__2:     # no_exit.1
        fldl data(,%eax,8)
        fldl 24(%esp)
        faddp %st(1)
        fstl 24(%esp)
        incl %eax
        movl $data, %ecx
        movl %ecx, %edx
        addl $16000, %edx
        subl %ecx, %edx
        movl %edx, %ecx
        sarl $2, %ecx
        shrl $29, %ecx
        addl %ecx, %edx
        sarl $3, %edx
        cmpl %edx, %eax
        fstpl 16(%esp)
        #FP_REG_KILL
        jl .LBB_Z5test0PdS__2

The old instruction selector produced:

.LBB_Z5test0PdS__2:     # no_exit.1
        fldl 24(%esp)
        faddl data(,%eax,8)
        fstl 24(%esp)
        movl %eax, %ecx
        incl %ecx
        incl %eax
        leal data+16000, %edx
        movl $data, %edi
        subl %edi, %edx
        movl %edx, %edi
        sarl $2, %edi
        shrl $29, %edi
        addl %edi, %edx
        sarl $3, %edx
        cmpl %edx, %ecx
        fstpl 16(%esp)
        #FP_REG_KILL
        jl .LBB_Z5test0PdS__2   # no_exit.1

Which is even worse!

llvm-svn: 19419
 2005-01-09 20:09:57 +00:00
Chris Lattner
35375c11bf Fix copy and pasto's for FP -> Int. This fixes fldry 
llvm-svn: 19418
 2005-01-09 19:49:59 +00:00
Chris Lattner
d674d08230 Fix a bug legalizing call instructions (make sure to remember all result 
values), and eliminate some switch statements.

llvm-svn: 19417
 2005-01-09 19:43:23 +00:00
Chris Lattner
ac23355362 Fix a minor bug legalizing dynamic_stackalloc. This allows us to compile 
std::__pad<wchar_t, std::char_traits<wchar_t> >::_S_pad(std::ios_base&, wchar_t, wchar_t*, wchar_t const*, int, int, bool)

from libstdc++

llvm-svn: 19416
 2005-01-09 19:07:54 +00:00
Chris Lattner
b3e31c6def Teach legalize to deal with DYNAMIC_STACKALLOC (aka a dynamic llvm alloca) 
llvm-svn: 19415
 2005-01-09 19:03:49 +00:00
Chris Lattner
45155a3dee Initial implementation of FP->INT and INT->FP casts 
Also, fix zero_extend from bool to i8, which fixes Shootout/objinst.

llvm-svn: 19414
 2005-01-09 18:52:44 +00:00
Jeff Cohen
6827f061cc Get lib/Analysis/DataStructure to compile with VC++ 
llvm-svn: 19412
 2005-01-09 04:18:28 +00:00
Chris Lattner
9ca9b20447 Fix a subtle bug involving constant expr casts from int to fp 
llvm-svn: 19410
 2005-01-09 01:49:29 +00:00
Chris Lattner
cc18c057cf Handle static alloca arguments to PHI nodes. 
llvm-svn: 19409
 2005-01-09 01:16:24 +00:00
Chris Lattner
c5e53c07fd Implement varargs and returnaddress/frameaddress intrinsics. With this 
patch, all of SingleSource/UnitTests passes.

llvm-svn: 19408
 2005-01-09 00:01:27 +00:00
Chris Lattner
3454e31bba Use new interfaces to correctly lower varargs and return/frame address intrinsics. 
llvm-svn: 19407
 2005-01-09 00:00:49 +00:00
Chris Lattner
aad3ca491d Add support for llvm.setjmp and longjmp. Only 3 SingleSource/UnitTests fail now. 
llvm-svn: 19404
 2005-01-08 22:48:57 +00:00
Jeff Cohen
6c0db8d863 Add even more missing createXxxPass functions. 
llvm-svn: 19402
 2005-01-08 22:01:16 +00:00
Chris Lattner
ca81756527 Okay 15th time is the charm. Looking at the vector size is useless as it 
gets clobbered by a previous statement.  This fixes all calls finally.

llvm-svn: 19399
 2005-01-08 20:51:36 +00:00
Chris Lattner
85816cff9a Okay, my off by one was actually off by two. This fixes Generic/2003-07-07-BadLongConst.ll 
llvm-svn: 19398
 2005-01-08 20:39:31 +00:00
Chris Lattner
3b52b2f6c2 Tighten up assertions. 
llvm-svn: 19397
 2005-01-08 20:35:13 +00:00
Chris Lattner
2d68cb6cf4 Fix off by one error 
llvm-svn: 19396
 2005-01-08 20:31:34 +00:00
Chris Lattner
9dc8275f47 Allow arrays to have more than 4G elements. 
llvm-svn: 19395
 2005-01-08 20:19:51 +00:00
Jeff Cohen
aef3f70921 Use size_t instead of long to represent memory usage. long is 32 bits 
on 64-bit Windows.

llvm-svn: 19393
 2005-01-08 20:15:57 +00:00
Chris Lattner
7a6914d3fc Silence warnings 
llvm-svn: 19392
 2005-01-08 20:13:44 +00:00
Chris Lattner
ed92fd75e8 Silence VS warnings. 
llvm-svn: 19391
 2005-01-08 20:13:19 +00:00
Chris Lattner
f1c684b3a2 Silence VS warnings. 
llvm-svn: 19390
 2005-01-08 20:07:03 +00:00
Chris Lattner
a4a16f17a3 Silence VS warnings 
llvm-svn: 19389
 2005-01-08 20:05:34 +00:00
Chris Lattner
c23687789e Silence VS warnings 
llvm-svn: 19388
 2005-01-08 19:59:10 +00:00
Chris Lattner
2dafaac5d1 Silence warnings from VS 
llvm-svn: 19386
 2005-01-08 19:55:00 +00:00
Chris Lattner
104064bf2c Silence VS warnings 
llvm-svn: 19385
 2005-01-08 19:53:50 +00:00
Chris Lattner
a58b3f48ef Silence VS warnings. 
llvm-svn: 19384
 2005-01-08 19:52:31 +00:00
Chris Lattner
c2821461e9 Fix VS warnings 
llvm-svn: 19383
 2005-01-08 19:48:40 +00:00
Chris Lattner
2e24bcf264 Fix VS warnings. 
llvm-svn: 19382
 2005-01-08 19:45:31 +00:00
Chris Lattner
131ada2668 Fix uint64_t -> unsigned VS warnings. 
llvm-svn: 19381
 2005-01-08 19:42:22 +00:00
Chris Lattner
ee218d4348 Silence VS warnings. 
llvm-svn: 19380
 2005-01-08 19:37:20 +00:00
Chris Lattner
d1e987d9ae Silence warnings 
llvm-svn: 19379
 2005-01-08 19:34:41 +00:00
Chris Lattner
77d45e2e60 Do not throw away bits for no reason 
llvm-svn: 19378
 2005-01-08 19:32:59 +00:00
Chris Lattner
e4d415db9d Silence a VS warning. 
llvm-svn: 19377
 2005-01-08 19:31:31 +00:00
Chris Lattner
c4d075cfa3 Adjust to changes in LowerCallTo interface 
Minor bugfixes

llvm-svn: 19376
 2005-01-08 19:28:19 +00:00
Chris Lattner
38545e9952 Implement handling of most long operators through libcalls. 
Fix a bug legalizing "ret (Val,Val)"

llvm-svn: 19375
 2005-01-08 19:27:05 +00:00
Chris Lattner
60ef22ce82 Adjust to changes in LowerCAllTo interfaces 
llvm-svn: 19374
 2005-01-08 19:26:18 +00:00
Jeff Cohen
ce541ade79 Add more missing createXxxPass functions. 
llvm-svn: 19370
 2005-01-08 17:21:40 +00:00
Chris Lattner
fd84495692 Add support for FP->INT conversions and back. 
llvm-svn: 19369
 2005-01-08 08:08:56 +00:00
Chris Lattner
6c7d3bd8ea Wrap long line. 
llvm-svn: 19367
 2005-01-08 06:59:50 +00:00
Chris Lattner
e759d984cf Implement the 'store FPIMM, Ptr' -> 'store INTIMM, Ptr' optimization for 
all targets.

llvm-svn: 19366
 2005-01-08 06:25:56 +00:00
Chris Lattner
e32ab4bd47 1ULL << 64 is undefined, don't do it. 
llvm-svn: 19365
 2005-01-08 06:24:30 +00:00
Chris Lattner
473ec492f7 The X86 instruction selector already handles codegen of: 
store float 123.45, float* %P

as an integer store.  This adds handling of float immediate stores as integers
for arguments passed function calls.

This is now tested by CodeGen/X86/store-fp-constant.ll

llvm-svn: 19364
 2005-01-08 05:45:24 +00:00
Chris Lattner
717236fcd3 Fix a pointer invalidation problem. This fixes Generic/badarg6.ll 
llvm-svn: 19361
 2005-01-07 23:32:00 +00:00
Chris Lattner
53173ba1d1 Fold conditional branches on constants away. 
llvm-svn: 19360
 2005-01-07 22:49:57 +00:00
Chris Lattner
8f55fae569 Fix a thinko in the reassociation code, fixing Generic/badlive.ll 
llvm-svn: 19359
 2005-01-07 22:44:09 +00:00
Chris Lattner
6f461f406e Add support for truncating integer casts from long. 
llvm-svn: 19358
 2005-01-07 22:37:48 +00:00
Chris Lattner
79ca9cdb7e Fix a bug in load expansion legalization and ret legalization. This fixes 
CodeGen/Generic/select.ll:castconst.

llvm-svn: 19357
 2005-01-07 22:28:47 +00:00
Chris Lattner
a834e96647 Legalize unconditional branches too 
llvm-svn: 19356
 2005-01-07 22:12:08 +00:00
Chris Lattner
3f2ce91a99 Implement support for long GEP indices on 32-bit archs and support for 
int GEP indices on 64-bit archs.

llvm-svn: 19354
 2005-01-07 21:56:57 +00:00
Chris Lattner
191554c09f Simplify: truncate ({zero|sign}_extend (X)) 
llvm-svn: 19353
 2005-01-07 21:56:24 +00:00
Chris Lattner
60e3842843 implement legalization of a bunch more operators. 
llvm-svn: 19352
 2005-01-07 21:45:56 +00:00
Chris Lattner
8c6c12da86 Fix another bug legalizing calls! 
llvm-svn: 19350
 2005-01-07 21:35:32 +00:00
Chris Lattner
86601673d6 Fix handling of dead PHI nodes. 
llvm-svn: 19349
 2005-01-07 21:34:19 +00:00
Chris Lattner
d671aa053c Fix a bug legalizing calls 
llvm-svn: 19348
 2005-01-07 21:34:13 +00:00
Chris Lattner
3871313761 After legalizing a DAG, delete dead nodes to save space. 
llvm-svn: 19346
 2005-01-07 21:09:37 +00:00
Chris Lattner
16faa6501a Implement RemoveDeadNodes 
llvm-svn: 19345
 2005-01-07 21:09:16 +00:00
Chris Lattner
39baa91b9a Teach legalize how to handle condbranches 
llvm-svn: 19339
 2005-01-07 08:19:42 +00:00
Chris Lattner
2c398fc8f6 Allow the selection-dag based selector to be diabled with -disable-pattern-isel. 
For now, this is the default, as the current selector is missing some big pieces.
To enable the new selector, pass -disable-pattern-isel=false to llc or lli.

llvm-svn: 19335
 2005-01-07 07:50:50 +00:00
Chris Lattner
216198574d Reimplementation of the X86 pattern isel. This is still missing many large 
pieces, but can already do amazing things in some cases.

llvm-svn: 19334
 2005-01-07 07:49:41 +00:00
Chris Lattner
74019f517a This file is now dead. 
llvm-svn: 19333
 2005-01-07 07:49:05 +00:00
Chris Lattner
079b497982 Add a new prototype 
llvm-svn: 19332
 2005-01-07 07:48:33 +00:00
Chris Lattner
74f8f6f657 Initial implementation of the SelectionDAGISel class. This contains most 
of the code for lowering from LLVM code to a SelectionDAG.

llvm-svn: 19331
 2005-01-07 07:47:53 +00:00
Chris Lattner
89f2ccbe9c This file is obsolete 
llvm-svn: 19330
 2005-01-07 07:47:23 +00:00
Chris Lattner
fd473edcd8 Initial implementation of the DAG legalization. This still has a long way 
to go, but it does work for some non-trivial cases now.

llvm-svn: 19329
 2005-01-07 07:47:09 +00:00
Chris Lattner
c72669973a Complete rewrite of the SelectionDAG class. 
llvm-svn: 19327
 2005-01-07 07:46:32 +00:00
Chris Lattner
fb848e6fad First draft of new Target interface 
llvm-svn: 19324
 2005-01-07 07:44:53 +00:00
Chris Lattner
83deb67391 Add convenience method. 
llvm-svn: 19321
 2005-01-07 07:40:32 +00:00
Misha Brukman
22df7f894f Convert tabs to spaces 
llvm-svn: 19320
 2005-01-07 07:05:34 +00:00
Jeff Cohen
c07c54f5b4 Add missing createXxxPass functions 
llvm-svn: 19319
 2005-01-07 06:57:28 +00:00
Jeff Cohen
79dc6715bb Add missing include 
llvm-svn: 19315
 2005-01-07 05:42:13 +00:00
Chris Lattner
608dd77d6b Codegen -1 and -0.0 more efficiently. This implements CodeGen/X86/negatize_zero.ll 
llvm-svn: 19313
 2005-01-06 21:19:16 +00:00
Chris Lattner
97d3bf5049 No need to pessimize current code for future possibilities. 
llvm-svn: 19311
 2005-01-06 16:26:38 +00:00
Jeff Cohen
67f737e5d1 Put createLoopUnswitchPass() into proper namespace 
llvm-svn: 19306
 2005-01-06 05:47:18 +00:00
Jeff Cohen
a8574e28a3 Add missing include 
llvm-svn: 19305
 2005-01-06 05:46:44 +00:00
Jeff Cohen
146e5504e5 Fix CBE code so that it compiles with VC++. 
llvm-svn: 19303
 2005-01-06 04:21:49 +00:00
Chris Lattner
6d651234d6 1. If a double FP constant must be put into a constant pool, but it can be 
precisely represented as a float, put it into the constant pool as a
   float.
2. Use the cbw/cwd/cdq instructions instead of an explicit SAR for signed
   division.

llvm-svn: 19291
 2005-01-05 16:30:14 +00:00
Chris Lattner
b438f5251f Minor optimization to allocate R8 registers in a better order. 
llvm-svn: 19289
 2005-01-05 16:09:16 +00:00
Chris Lattner
6446c6fb34 To not break TBAA rules, use a union. 
llvm-svn: 19280
 2005-01-04 01:56:57 +00:00
Jeff Cohen
36968ed8c1 Revert elimination of global variable hack... still needed. 
llvm-svn: 19273
 2005-01-03 16:34:19 +00:00
Chris Lattner
1aaf8cccb2 ADC and IMUL are also commutable. 
llvm-svn: 19264
 2005-01-03 01:27:59 +00:00
Chris Lattner
93fc4bd9cb This hunk: 
-  unsigned TrueValue = getReg(TrueVal, BB, BB->begin());
+  unsigned TrueValue = getReg(TrueVal);

Fixes the PPC regressions from last night.

The other hunk is just a clarity improvement.

llvm-svn: 19263
 2005-01-02 23:07:31 +00:00
Reid Spencer
110e76fd79 Correct the case of a #include directory name, just in case. 
llvm-svn: 19254
 2005-01-02 09:45:04 +00:00
Jeff Cohen
1087b72875 Eliminate the use of the global variable hack in the X86 target that was used 
to get Visual Studio to link in X86.lib to the executables that need it.  There
is another way of doing it.

llvm-svn: 19252
 2005-01-02 04:23:12 +00:00
Chris Lattner
a78fd4726e Disable 2->3 address promotion of add and inc instructions to LEA's. In 
addition to being three address, LEA's don't set the flags.

This fixes 186.crafty.

llvm-svn: 19251
 2005-01-02 04:18:17 +00:00
Chris Lattner
3ef32da6c3 Add a new method. 
llvm-svn: 19249
 2005-01-02 02:38:18 +00:00
Chris Lattner
95f1e628ed Add support for SETNPr to lower to memory form. 
llvm-svn: 19248
 2005-01-02 02:37:46 +00:00
Chris Lattner
d6bc921fa8 Implement the convertToThreeAddress method, add support for inverting JP/JNP 
branches.

llvm-svn: 19247
 2005-01-02 02:37:07 +00:00
Chris Lattner
0d6f03e52b Two changes here: 
1. Add new instructions for checking parity flags: JP, JNP, SETP, SETNP.
2. Set the isCommutable and isPromotableTo3Address bits on several
   instructions.

llvm-svn: 19246
 2005-01-02 02:35:46 +00:00
Chris Lattner
c1feb0c8fe Make the 2-address instruction lowering pass smarter in two ways: 
1. If we are two-addressing a commutable instruction and the LHS is not the
   last use of the variable, see if the instruction is the last use of the
   RHS.  If so, commute the instruction, allowing us to avoid a
   register-register copy in many cases for common instructions like ADD, OR,
   AND, etc on X86.
2. If #1 doesn't hold, and if this is an instruction that also existing in
   3-address form, promote the instruction to a 3-address instruction to
   avoid the register-register copy.  We can do this for several common
   instructions in X86, including ADDrr, INC, DEC, etc.

This patch implements test/Regression/CodeGen/X86/commute-two-addr.ll,
overlap-add.ll, and overlap-shift.ll when I check in the X86 support for it.

llvm-svn: 19245
 2005-01-02 02:34:12 +00:00
Chris Lattner
cc26e332b3 Add some bits that can be set for instructions. 
llvm-svn: 19241
 2005-01-02 02:27:48 +00:00
Reid Spencer
37f31d4aa1 Make printing a warning message optional in CheckBytecodeOutputToConsole. 
llvm-svn: 19240
 2005-01-02 00:10:03 +00:00
Reid Spencer
2d73c4d556 Implement a function to print a warning if bytecode output is to be sent to 
a terminal/console.

llvm-svn: 19237
 2005-01-01 23:56:20 +00:00
Jeff Cohen
7466dd37d0 Add functions for determining if the stdin/out/err is connected to a 
console or not.

llvm-svn: 19236
 2005-01-01 22:54:05 +00:00
Reid Spencer
ed2f874a8d Add functions for determining if the stdin/out/err is connected to a 
console or not.

llvm-svn: 19233
 2005-01-01 22:29:26 +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
ad63a0d6a4 Fix a FIXME: Select instructions on longs were miscompiled. 
While we're at it, improve codegen of select instructions.  For this
testcase:

int %test(bool %C, int %A, int %B) {
  %D = select bool %C, int %A, int %B
  ret int %D
}

We used to generate this code:

_test:
        cmpwi cr0, r3, 0
        bne .LBB_test_2 ;
.LBB_test_1:    ;
        b .LBB_test_3   ;
.LBB_test_2:    ;
        or r5, r4, r4
.LBB_test_3:    ;
        or r3, r5, r5
        blr

Now we emit:

_test:
        cmpwi cr0, r3, 0
        bne .LBB_test_2 ;
.LBB_test_1:    ;
        or r4, r5, r5
.LBB_test_2:    ;
        or r3, r4, r4
        blr

-Chris

llvm-svn: 19214
 2005-01-01 16:10:12 +00:00