RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-13 07:00:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
11,626 Commits 4 Branches 5 Tags
Commit Graph

11626 Commits

This Branch
This Branch
All Branches
Author SHA1 Message Date
Chris Lattner
c35a86f48b * Improve file header comment 
* Remove #include
* Add some methods to update loop/loopinfo
* Stop explicitly holding the loop depth in the Loop class.  Instead, just
  dynamically calculate it.  This makes it easier to update LoopInfo as a
  result of transformations.

llvm-svn: 13059
 2004-04-19 03:03:19 +00:00
Chris Lattner
69d4611250 Remove code to update loop depths 
llvm-svn: 13058
 2004-04-19 03:02:09 +00:00
Chris Lattner
1849aa8b1f Add #include 
llvm-svn: 13057
 2004-04-19 03:01:23 +00:00
Misha Brukman
9b353889ae Add notes about PRs 38 and 290 being fixed. 
llvm-svn: 13056
 2004-04-19 03:01:01 +00:00
Misha Brukman
2d5e64ab31 Wrap (some) lines to 80 cols. 
llvm-svn: 13055
 2004-04-19 02:56:49 +00:00
Misha Brukman
e7ccafce7e Finally implement rewriting global initializers which use external functions 
by creating an internal wrapper function with same signature as the external
function, and use it instead of the "real" function.

The wrapper then calls the external function using the same JIT function
resolution API that has been used before for rewriting instructions, since the
wrapper has an explicit call instruction which we can rewrite.

llvm-svn: 13054
 2004-04-19 01:12:01 +00:00
Chris Lattner
0ce3a74370 Provide an interface that is more convenient for iterating over the blocks 
in a loop.

llvm-svn: 13052
 2004-04-18 23:37:03 +00:00
Chris Lattner
ab6502f058 Move isLoopInvariant to the Loop class 
llvm-svn: 13051
 2004-04-18 22:46:08 +00:00
Chris Lattner
509116ec78 Add new method 
llvm-svn: 13050
 2004-04-18 22:45:27 +00:00
Chris Lattner
83017d0b1b Add new method. 
llvm-svn: 13049
 2004-04-18 22:45:16 +00:00
Chris Lattner
5a0ed18724 Correct rewriting of exit blocks after my last patch 
llvm-svn: 13048
 2004-04-18 22:27:10 +00:00
Chris Lattner
06e17bb6f7 Fix computation of exit blocks 
llvm-svn: 13047
 2004-04-18 22:21:41 +00:00
Chris Lattner
8e42c6f409 Loop exit sets are no longer explicitly held, they are dynamically computed on demand. 
llvm-svn: 13046
 2004-04-18 22:15:13 +00:00
Chris Lattner
7174acca00 Change the ExitBlocks list from being explicitly contained in the Loop 
structure to being dynamically computed on demand.  This makes updating
loop information MUCH easier.

llvm-svn: 13045
 2004-04-18 22:14:10 +00:00
Chris Lattner
5fbdaafc18 Spiff is no longer in our tree 
llvm-svn: 13041
 2004-04-18 18:26:38 +00:00
Chris Lattner
13140766df Reduce the unrolling limit 
llvm-svn: 13040
 2004-04-18 18:06:14 +00:00
Chris Lattner
430968ac2f If the preheader of the loop was the entry block of the function, make sure 
that the exit block of the loop becomes the new entry block of the function.

This was causing a verifier assertion on 252.eon.

llvm-svn: 13039
 2004-04-18 17:38:42 +00:00
Chris Lattner
199b58db3f Be much more careful about how we update instructions outside of the loop 
using instructions inside of the loop.  This should fix the MishaTest failure
from last night.

llvm-svn: 13038
 2004-04-18 17:32:39 +00:00
Chris Lattner
c6aded531b Another testcase 
llvm-svn: 13037
 2004-04-18 06:55:57 +00:00
Chris Lattner
08232425a0 Implement method 
llvm-svn: 13036
 2004-04-18 06:54:48 +00:00
Chris Lattner
b17c6d4732 Add a new method 
llvm-svn: 13035
 2004-04-18 06:54:34 +00:00
Chris Lattner
33ec7f2f9f After unrolling our single basic block loop, fold it into the preheader and exit 
block.  The primary motivation for doing this is that we can now unroll nested loops.

This makes a pretty big difference in some cases.  For example, in 183.equake,
we are now beating the native compiler with the CBE, and we are a lot closer
with LLC.

I'm now going to play around a bit with the unroll factor and see what effect
it really has.

llvm-svn: 13034
 2004-04-18 06:27:43 +00:00
Chris Lattner
f2045a8c05 Fix a bug: this does not preserve the CFG! 
While we're at it, add support for updating loop information correctly.

llvm-svn: 13033
 2004-04-18 05:38:37 +00:00
Chris Lattner
6606b526f6 Add a new method, add a check missing that caused a segfault if a loop didn't 
have a canonical indvar

llvm-svn: 13032
 2004-04-18 05:38:05 +00:00
Chris Lattner
a8ec64511a Allow clients to delete loops, add a new method 
llvm-svn: 13031
 2004-04-18 05:37:42 +00:00
Chris Lattner
0caf28f4ff Move loop optimization passes up, add loop unroller 
llvm-svn: 13030
 2004-04-18 05:21:01 +00:00
Chris Lattner
27fd823c1b Add prototype 
llvm-svn: 13029
 2004-04-18 05:20:32 +00:00
Chris Lattner
b0d23bf99d Initial checkin of a simple loop unroller. This pass is extremely basic and 
limited.  Even in it's extremely simple state (it can only *fully* unroll single
basic block loops that execute a constant number of times), it already helps improve
performance a LOT on some benchmarks, particularly with the native code generators.

llvm-svn: 13028
 2004-04-18 05:20:17 +00:00
Chris Lattner
e0f56972f0 Make the tail duplication threshold accessible from the command line instead of hardcoded 
llvm-svn: 13025
 2004-04-18 00:52:43 +00:00
Chris Lattner
22ca3df5b1 Fix a memory leak. We leaked the vector holding the entries in switch tables. 
llvm-svn: 13023
 2004-04-17 23:49:15 +00:00
Chris Lattner
7a6db7ee0e New testcase 
llvm-svn: 13020
 2004-04-17 23:00:51 +00:00
Chris Lattner
b5ee2bcb62 Add the ability to compute exit values for complex loop using unanalyzable 
operations.  This allows us to compile this testcase:

int main() {
        int h = 1;
         do h = 3 * h + 1; while (h <= 256);
        printf("%d\n", h);
        return 0;
}

into this:

int %main() {
entry:
        call void %__main( )
        %tmp.6 = call int (sbyte*, ...)* %printf( sbyte* getelementptr ([4 x sbyte]*  %.str_1, long 0, long 0), int 364 )        ; <int> [#uses=0]
        ret int 0
}

This testcase was taken directly from 256.bzip2, believe it or not.

This code is not as general as I would like.  Next up is to refactor it
a bit to handle more cases.

llvm-svn: 13019
 2004-04-17 22:58:41 +00:00
Chris Lattner
740ae78ae6 If the loop executes a constant number of times, try a bit harder to replace 
exit values.

llvm-svn: 13018
 2004-04-17 18:44:09 +00:00
Chris Lattner
9a73de2ba2 Add the ability to compute trip counts that are only controlled by constants 
even if the loop is using expressions that we can't compute as a closed-form.
This allows us to calculate that this function always returns 55:

int test() {
  double X;
  int Count = 0;
  for (X = 100; X > 1; X = sqrt(X), ++Count)
    /*empty*/;
  return Count;
}

And allows us to compute trip counts for loops like:

        int h = 1;
         do h = 3 * h + 1; while (h <= 256);

(which occurs in bzip2), and for this function, which occurs after inlining
and other optimizations:

int popcount()
{
   int x = 666;
  int result = 0;
  while (x != 0) {
    result = result + (x & 0x1);
    x = x >> 1;
  }
  return result;
}

We still cannot compute the exit values of result or h in the two loops above,
which means we cannot delete the loop, but we are getting closer.  Being able to
compute a constant trip count for these two loops will allow us to unroll them
completely though.

llvm-svn: 13017
 2004-04-17 18:36:24 +00:00
Chris Lattner
bcb690dc9b Fix a HUGE pessimization on X86. The indvars pass was taking this 
(familiar) function:

int _strlen(const char *str) {
    int len = 0;
    while (*str++) len++;
    return len;
}

And transforming it to use a ulong induction variable, because the type of
the pointer index was left as a constant long.  This is obviously very bad.

The fix is to shrink long constants in getelementptr instructions to intptr_t,
making the indvars pass insert a uint induction variable, which is much more
efficient.

Here's the before code for this function:

int %_strlen(sbyte* %str) {
entry:
        %tmp.13 = load sbyte* %str              ; <sbyte> [#uses=1]
        %tmp.24 = seteq sbyte %tmp.13, 0                ; <bool> [#uses=1]
        br bool %tmp.24, label %loopexit, label %no_exit

no_exit:                ; preds = %entry, %no_exit
***     %indvar = phi uint [ %indvar.next, %no_exit ], [ 0, %entry ]            ; <uint> [#uses=2]
***     %indvar = phi ulong [ %indvar.next, %no_exit ], [ 0, %entry ]           ; <ulong> [#uses=2]
        %indvar1 = cast ulong %indvar to uint           ; <uint> [#uses=1]
        %inc.02.sum = add uint %indvar1, 1              ; <uint> [#uses=1]
        %inc.0.0 = getelementptr sbyte* %str, uint %inc.02.sum          ; <sbyte*> [#uses=1]
        %tmp.1 = load sbyte* %inc.0.0           ; <sbyte> [#uses=1]
        %tmp.2 = seteq sbyte %tmp.1, 0          ; <bool> [#uses=1]
        %indvar.next = add ulong %indvar, 1             ; <ulong> [#uses=1]
        %indvar.next = add uint %indvar, 1              ; <uint> [#uses=1]
        br bool %tmp.2, label %loopexit.loopexit, label %no_exit

loopexit.loopexit:              ; preds = %no_exit
        %indvar = cast uint %indvar to int              ; <int> [#uses=1]
        %inc.1 = add int %indvar, 1             ; <int> [#uses=1]
        ret int %inc.1

loopexit:               ; preds = %entry
        ret int 0
}


Here's the after code:

int %_strlen(sbyte* %str) {
entry:
        %inc.02 = getelementptr sbyte* %str, uint 1             ; <sbyte*> [#uses=1]
        %tmp.13 = load sbyte* %str              ; <sbyte> [#uses=1]
        %tmp.24 = seteq sbyte %tmp.13, 0                ; <bool> [#uses=1]
        br bool %tmp.24, label %loopexit, label %no_exit

no_exit:                ; preds = %entry, %no_exit
***     %indvar = phi uint [ %indvar.next, %no_exit ], [ 0, %entry ]            ; <uint> [#uses=3]
        %indvar = cast uint %indvar to int              ; <int> [#uses=1]
        %inc.0.0 = getelementptr sbyte* %inc.02, uint %indvar           ; <sbyte*> [#uses=1]
        %inc.1 = add int %indvar, 1             ; <int> [#uses=1]
        %tmp.1 = load sbyte* %inc.0.0           ; <sbyte> [#uses=1]
        %tmp.2 = seteq sbyte %tmp.1, 0          ; <bool> [#uses=1]
        %indvar.next = add uint %indvar, 1              ; <uint> [#uses=1]
        br bool %tmp.2, label %loopexit, label %no_exit

loopexit:               ; preds = %entry, %no_exit
        %len.0.1 = phi int [ 0, %entry ], [ %inc.1, %no_exit ]          ; <int> [#uses=1]
        ret int %len.0.1
}

llvm-svn: 13016
 2004-04-17 18:16:10 +00:00
Chris Lattner
5c85946417 Even if there are not any induction variables in the loop, if we can compute 
the trip count for the loop, insert one so that we can canonicalize the exit
condition.

llvm-svn: 13015
 2004-04-17 18:08:33 +00:00
Chris Lattner
6d5decd7d4 Add support for evaluation of exp/log/log10/pow 
llvm-svn: 13011
 2004-04-16 22:35:33 +00:00
Chris Lattner
ed423cc09d Fix some really nasty dominance bugs that were exposed by my patch to 
make the verifier more strict.  This fixes building zlib

llvm-svn: 13002
 2004-04-16 18:08:07 +00:00
Misha Brukman
cb5de6bca6 Fix retriving parent Function. 
llvm-svn: 13001
 2004-04-16 17:37:12 +00:00
Misha Brukman
a2cc39ff28 Fit comment into 80 cols. 
llvm-svn: 12996
 2004-04-16 17:13:52 +00:00
Brian Gaeke
decd864ee4 Regenerated using autoconf-2.57. 
llvm-svn: 12995
 2004-04-16 17:13:44 +00:00
Brian Gaeke
66f747098a Refactor external benchmark checking stuff into one hairy 
macro-to-bind-them-all, called EXTERNAL_BENCHMARK().

llvm-svn: 12994
 2004-04-16 17:13:33 +00:00
Misha Brukman
52a9e3b31f Add idea about a disassembler. 
llvm-svn: 12993
 2004-04-16 16:55:30 +00:00
Brian Gaeke
76f386fd75 Switch to including <iostream> for compatibility with gcc-3.0.x (Debian). 
llvm-svn: 12990
 2004-04-16 16:28:33 +00:00
Misha Brukman
fdb346f70a * Fix capitalization of PICk 
* Wrap long lines to 80 cols

llvm-svn: 12988
 2004-04-16 16:20:07 +00:00
Brian Gaeke
4b9f67c638 Include <cmath> for compatibility with gcc 3.0.x (the system compiler on 
Debian.)

llvm-svn: 12986
 2004-04-16 15:57:32 +00:00
Brian Gaeke
2a087ad673 Include <string> for compatibility with gcc 3.0.x (the system compiler on 
Debian.)

llvm-svn: 12985
 2004-04-16 15:57:14 +00:00
Brian Gaeke
c465066a6c As a part of the bootstrapping process, the top-level tools-only target 
should not build projects.

llvm-svn: 12984
 2004-04-16 15:57:02 +00:00
Misha Brukman
aadcd46d25 Assert if deleting BasicBlock before removing it from Function. 
llvm-svn: 12983
 2004-04-16 15:47:21 +00:00
Misha Brukman
7c46021fe7 Assert if Instruction is being deleted before being removed from BasicBlock. 
llvm-svn: 12982
 2004-04-16 15:46:43 +00:00