Commits · ba33ae5831ea8c03c26340f80be3d7dd0fb0c90f · Roger Ferrer / llvm-epi-0.8

Apr 06, 2004

Fix incorrect encoding of some ADC and SBB instuctions · ba33ae58
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12710
```
ba33ae58
Added licensing information for treecc. · 4db8b67a
John Criswell authored Apr 06, 2004
```
llvm-svn: 12703
```
4db8b67a

Fix a minor bug in previous checking · 19c8b13e

Chris Lattner authored Apr 06, 2004

Enable folding of long seteq/setne comparisons into branches and select instructions
Implement unfolded long relational comparisons against a constants a bit more efficiently

Folding comparisons changes code that looks like this:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EDX, DWORD PTR [%ESP + 8]
        mov %ECX, %EAX
        or %ECX, %EDX
        sete %CL
        test %CL, %CL
        je .LBB2 # PC rel: F

into code that looks like this:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EDX, DWORD PTR [%ESP + 8]
        mov %ECX, %EAX
        or %ECX, %EDX
        jne .LBB2 # PC rel: F

This speeds up 186.crafty by 6% with llc-ls.

llvm-svn: 12702

19c8b13e

Wrap at 80 cols. · 827c985a
Misha Brukman authored Apr 06, 2004
```
llvm-svn: 12701
```
827c985a
Minor cleanups · e216fc01
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12700
```
e216fc01
Document new option · 7f601ade
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12699
```
7f601ade
Add a new gccld -native-cbe option which causes gccld to generate native code · ad733e73
Chris Lattner authored Apr 06, 2004
```
for the application with the C backend instead of the native LLVM code generator

llvm-svn: 12698
```
ad733e73

Improve codegen of long == and != comparisons against constants. Before, · f2ee88eb

Chris Lattner authored Apr 06, 2004

comparing a long against zero got us this:

        sub %ESP, 8
        mov DWORD PTR [%ESP + 4], %ESI
        mov DWORD PTR [%ESP], %EDI
        mov %EAX, DWORD PTR [%ESP + 12]
        mov %EDX, DWORD PTR [%ESP + 16]
        mov %ECX, 0
        mov %ESI, 0
        mov %EDI, %EAX
        xor %EDI, %ECX
        mov %ECX, %EDX
        xor %ECX, %ESI
        or %EDI, %ECX
        sete %CL
        test %CL, %CL
        je .LBB2 # PC rel: F

Now it gets us this:

        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EDX, DWORD PTR [%ESP + 8]
        mov %ECX, %EAX
        or %ECX, %EDX
        sete %CL
        test %CL, %CL
        je .LBB2 # PC rel: F

llvm-svn: 12696

f2ee88eb

Update docs a bit · 3ef249c0
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12695
```
3ef249c0
Remove some options that don't really have anything to do with bugpoint · 80e594fa
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12694
```
80e594fa

Handle various other important cases of multiplying a long constant immediate. For · 6c3bf13f

Chris Lattner authored Apr 06, 2004

example, multiplying X*(1 + (1LL << 32)) now produces:

test:
        mov %ECX, DWORD PTR [%ESP + 4]
        mov %EDX, DWORD PTR [%ESP + 8]
        mov %EAX, %ECX
        add %EDX, %ECX
        ret

[[[Note to Alkis: why isn't linear scan generating this code??  This might be a
 problem with your intervals being too conservative:

test:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EDX, DWORD PTR [%ESP + 8]
        add %EDX, %EAX
        ret

end note]]]

Whereas GCC produces this:

T:
        sub     %esp, 12
        mov     %edx, DWORD PTR [%esp+16]
        mov     DWORD PTR [%esp+8], %edi
        mov     %ecx, DWORD PTR [%esp+20]
        xor     %edi, %edi
        mov     DWORD PTR [%esp], %ebx
        mov     %ebx, %edi
        mov     %eax, %edx
        mov     DWORD PTR [%esp+4], %esi
        add     %ebx, %edx
        mov     %edi, DWORD PTR [%esp+8]
        lea     %edx, [%ecx+%ebx]
        mov     %esi, DWORD PTR [%esp+4]
        mov     %ebx, DWORD PTR [%esp]
        add     %esp, 12
        ret

I'm not sure example what GCC is smoking here, but it looks like it has just
confused itself with a bunch of stack slots or something.  The intel compiler
is better, but still not good:

T:
        movl      4(%esp), %edx                                 #2.11
        movl      8(%esp), %eax                                 #2.11
        lea       (%eax,%edx), %ecx                             #3.12
        movl      $1, %eax                                      #3.12
        mull      %edx                                          #3.12
        addl      %ecx, %edx                                    #3.12
        ret                                                     #3.12

llvm-svn: 12693

6c3bf13f

Efficiently handle a long multiplication by a constant. For this testcase: · 1f6024cb

Chris Lattner authored Apr 06, 2004

long %test(long %X) {
        %Y = mul long %X, 123
        ret long %Y
}

we used to generate:

test:
        sub %ESP, 12
        mov DWORD PTR [%ESP + 8], %ESI
        mov DWORD PTR [%ESP + 4], %EDI
        mov DWORD PTR [%ESP], %EBX
        mov %ECX, DWORD PTR [%ESP + 16]
        mov %ESI, DWORD PTR [%ESP + 20]
        mov %EDI, 123
        mov %EBX, 0
        mov %EAX, %ECX
        mul %EDI
        imul %ESI, %EDI
        add %ESI, %EDX
        imul %ECX, %EBX
        add %ESI, %ECX
        mov %EDX, %ESI
        mov %EBX, DWORD PTR [%ESP]
        mov %EDI, DWORD PTR [%ESP + 4]
        mov %ESI, DWORD PTR [%ESP + 8]
        add %ESP, 12
        ret

Now we emit:
test:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %ECX, DWORD PTR [%ESP + 8]
        mov %EDX, 123
        mul %EDX
        imul %ECX, %ECX, 123
        add %ECX, %EDX
        mov %EDX, %ECX
        ret

Which, incidently, is substantially nicer than what GCC manages:
T:
        sub     %esp, 8
        mov     %eax, 123
        mov     DWORD PTR [%esp], %ebx
        mov     %ebx, DWORD PTR [%esp+16]
        mov     DWORD PTR [%esp+4], %esi
        mov     %esi, DWORD PTR [%esp+12]
        imul    %ecx, %ebx, 123
        mov     %ebx, DWORD PTR [%esp]
        mul     %esi
        mov     %esi, DWORD PTR [%esp+4]
        add     %esp, 8
        lea     %edx, [%ecx+%edx]
        ret

llvm-svn: 12692

1f6024cb

* Added link to newly written ExtendingLLVM.html document · ad3e28cb
Misha Brukman authored Apr 06, 2004
```
* Eliminated extraneous space in the HTML

llvm-svn: 12691
```
ad3e28cb
Incorporated Chris' comments. · c069ca5d
Misha Brukman authored Apr 06, 2004
```
llvm-svn: 12690
```
c069ca5d
Added notes on extending LLVM with new instructions, intrinsics, types, etc. · 2282a6eb
Misha Brukman authored Apr 06, 2004
```
llvm-svn: 12689
```
2282a6eb

Improve code generation of long shifts by 32. · 2448baea

Chris Lattner authored Apr 06, 2004

On this testcase:

long %test(long %X) {
        %Y = shr long %X, ubyte 32
        ret long %Y
}

instead of:
t:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EAX, DWORD PTR [%ESP + 8]
        sar %EAX, 0
        mov %EDX, 0
        ret


we now emit:
test:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EAX, DWORD PTR [%ESP + 8]
        mov %EDX, 0
        ret

llvm-svn: 12688

2448baea

Bugfixes: inc/dec don't set the carry flag! · 7332d4c5
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12687
```
7332d4c5

Improve code for passing constant longs as arguments to function calls. · decce5bc

Chris Lattner authored Apr 06, 2004

For example, on this instruction:

        call void %test(long 1234)

Instead of this:
        mov %EAX, 1234
        mov %ECX, 0
        mov DWORD PTR [%ESP], %EAX
        mov DWORD PTR [%ESP + 4], %ECX
        call test

We now emit this:
        mov DWORD PTR [%ESP], 1234
        mov DWORD PTR [%ESP + 4], 0
        call test

llvm-svn: 12686

decce5bc

Emit more efficient 64-bit operations when the RHS is a constant, and one · 5fc6f77b

Chris Lattner authored Apr 06, 2004

of the words of the constant is zeros.  For example:
  Y = and long X, 1234

now generates:
  Yl = and Xl, 1234
  Yh = 0

instead of:
  Yl = and Xl, 1234
  Yh = and Xh, 0

llvm-svn: 12685

5fc6f77b

Fix typeo · b49608af
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12684
```
b49608af
Add support for simple immediate handling to long instruction selection. · 996e667a
Chris Lattner authored Apr 06, 2004
```
This allows us to handle code like 'add long %X, 123456789012' more efficiently.

llvm-svn: 12683
```
996e667a
The sbb instructions really ARE sbb's, not adc's · 9366f034
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12682
```
9366f034

Implement negation of longs efficiently. For this testcase: · 37ba31f7

Chris Lattner authored Apr 06, 2004

long %test(long %X) {
        %Y = sub long 0, %X
        ret long %Y
}

We used to generate:

test:
        sub %ESP, 4
        mov DWORD PTR [%ESP], %ESI
        mov %ECX, DWORD PTR [%ESP + 8]
        mov %ESI, DWORD PTR [%ESP + 12]
        mov %EAX, 0
        mov %EDX, 0
        sub %EAX, %ECX
        sbb %EDX, %ESI
        mov %ESI, DWORD PTR [%ESP]
        add %ESP, 4
        ret

Now we generate:

test:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %EDX, DWORD PTR [%ESP + 8]
        neg %EAX
        adc %EDX, 0
        neg %EDX
        ret

llvm-svn: 12681

37ba31f7

Minor tweak to avoid an extra reg-reg copy that the register allocator has to eliminate · bfe74f58
Chris Lattner authored Apr 06, 2004
```
llvm-svn: 12680
```
bfe74f58

Two changes: · 464e2ea5

Chris Lattner authored Apr 06, 2004

  * In promote32, if we can just promote a constant value, do so instead of
    promoting a constant dynamically.
  * In visitReturn inst, actually USE the promote32 argument that takes a
    Value*

The end result of this is that we now generate this:

test:
        mov %EAX, 0
        ret

instead of...

test:
        mov %AX, 0
        movzx %EAX, %AX
        ret

for:

ushort %test() {
        ret ushort 0
}

llvm-svn: 12679

464e2ea5

Merge the code generator miscompilation code into the optimizer miscompilation · bf791614

Chris Lattner authored Apr 05, 2004

code.  This "instantly" gives us loop-extractor power to assist with the
debugment of our nasty codegen issues.  :)

llvm-svn: 12678

bf791614

Make a method public · 95053a9f
Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12677
```
95053a9f

Apr 05, 2004
- Minor cleanups, remove some old debug code · 9af52d12
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12676
```
  9af52d12
- Refactor and genericize code · 0434ba3e
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12675
```
  0434ba3e
- lli no longer takes the -quiet option! · b0d1e9d0
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12674
```
  b0d1e9d0
- Do not mangle intrinsics in any way! · c97b7b22
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12673
```
  c97b7b22
- Make full use of the Mangler interface to simplify code · 0f1df36b
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12671
```
  0f1df36b
- Sparc don't got not "sqrtl", bum bum bum · d4f78f27
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12670
```
  d4f78f27
- Kill warnings during an optimized compile where assert() disappears. · 5ebc25c8
  Misha Brukman authored Apr 05, 2004
```
llvm-svn: 12669
```
  5ebc25c8
- Fix PR312 and IndVarsSimplify/2004-04-05-InvokeCastCrash.llx · 29153fc2
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12668
```
  29153fc2
- New testcase for PR312 · 6f4fea93
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12667
```
  6f4fea93
- Fix a bug in yesterdays checkins which broke siod. siod is a great testcase! :) · 4d1fcf1d
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12659
```
  4d1fcf1d
- Fix InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll · 8953b90a
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12658
```
  8953b90a
- New testcase that crashes the instcombine pass. Dominance properties have · e79fd5c7
  Chris Lattner authored Apr 05, 2004
```
no meaning if the code is not reachable.

llvm-svn: 12657
```
  e79fd5c7
- PR82 is finally fixed! · 677202b4
  Chris Lattner authored Apr 05, 2004
```
llvm-svn: 12656
```
  677202b4