maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
10,789 Commits 23 Branches 0 Tags 2.2 GiB
Commit Graph

1228 Commits

Author SHA1 Message Date
Chris Lattner d3e6ae263c Implement switch->br and br->switch folding by ripping out the switch->switch 
and br->br code and generalizing it.  This allows us to compile code like this:

int test(Instruction *I) {
  if (isa<CastInst>(I))
    return foo(7);
  else if (isa<BranchInst>(I))
    return foo(123);
  else if (isa<UnwindInst>(I))
    return foo(1241);
  else if (isa<SetCondInst>(I))
    return foo(1);
  else if (isa<VAArgInst>(I))
    return foo(42);
  return foo(-1);
}

into:

int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
        %tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4            ; <uint*> [#uses=1]
        %tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i          ; <uint> [#uses=2]
        %tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27                ; <bool> [#uses=0]
        switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
                 uint 27, label %then.0
                 uint 2, label %then.1
                 uint 5, label %then.2
                 uint 14, label %then.3
                 uint 15, label %then.3
                 uint 16, label %then.3
                 uint 17, label %then.3
                 uint 18, label %then.3
                 uint 19, label %then.3
                 uint 32, label %then.4
        ]
...

As well as handling the cases in 176.gcc and many other programs more effectively.

llvm-svn: 11964
 2004-02-28 21:28:10 +00:00
Chris Lattner 772eafa332 if there is already a prototype for malloc/free, use it, even if it's incorrect. 
Do not just inject a new prototype.

llvm-svn: 11951
 2004-02-28 18:51:45 +00:00
Chris Lattner 51ea127bf3 Rename AddUsesToWorkList -> AddUsersToWorkList, as that is what it does. 
Create a new AddUsesToWorkList method
optimize memmove/set/cpy of zero bytes to a noop.

llvm-svn: 11941
 2004-02-28 05:22:00 +00:00
Chris Lattner f3a366062c Turn 'free null' into nothing 
llvm-svn: 11940
 2004-02-28 04:57:37 +00:00
Misha Brukman 8a2c28fdda Right, it's really Extractor, not Extraction. 
llvm-svn: 11939
 2004-02-28 03:37:58 +00:00
Misha Brukman 03a11340ff A pass that uses the generic CodeExtractor to rip out *every* loop in every 
function, as long as the loop isn't the only one in that function. This should
help debugging passes easier with BugPoint.

llvm-svn: 11936
 2004-02-28 03:33:01 +00:00
Misha Brukman caa1a5abeb A generic code extractor: given a list of BasicBlocks, it will rip them out into 
a new function, taking care of inputs and outputs.

llvm-svn: 11935
 2004-02-28 03:26:20 +00:00
Chris Lattner e82c217b2f setcond instructions don't have aliasing implications. 
llvm-svn: 11919
 2004-02-27 18:09:25 +00:00
Chris Lattner 4f7accab96 Implement test/Regression/Transforms/InstCombine/canonicalize_branch.ll 
This is a really minor thing, but might help out the 'switch statement induction'
code in simplifycfg.

llvm-svn: 11900
 2004-02-27 06:27:46 +00:00
Chris Lattner 79636d7cd5 Since LLVM uses structure type equivalence, it isn't useful to keep around 
multiple type names for the same structural type.  Make DTE eliminate all
but one of the type names

llvm-svn: 11879
 2004-02-26 20:02:23 +00:00
Chris Lattner 21e941fbfd turn things like: 
if (X == 0 || X == 2)

...where the comparisons and branches are in different blocks... into a switch
instruction.  This comes up a lot in various programs, and works well with
the switch/switch merging code I checked earlier.  For example, this testcase:

int switchtest(int C) {
  return C == 0 ? f(123) :
         C == 1 ? f(3123) :
         C == 4 ? f(312) :
         C == 5 ? f(1234): f(444);
}

is converted into this:
        switch int %C, label %cond_false.3 [
                 int 0, label %cond_true.0
                 int 1, label %cond_true.1
                 int 4, label %cond_true.2
                 int 5, label %cond_true.3
        ]

instead of a whole bunch of conditional branches.

Admittedly the code is ugly, and incomplete.  To be complete, we need to add
br -> switch merging and switch -> br merging.  For example, this testcase:

struct foo { int Q, R, Z; };
#define A (X->Q+X->R * 123)
int test(struct foo *X) {
  return A  == 123 ? X1() :
        A == 12321 ? X2():
        (A == 111 || A == 222) ? X3() :
        A == 875 ? X4() : X5();
}

Gets compiled to this:
        switch int %tmp.7, label %cond_false.2 [
                 int 123, label %cond_true.0
                 int 12321, label %cond_true.1
                 int 111, label %cond_true.2
                 int 222, label %cond_true.2
        ]
...
cond_false.2:           ; preds = %entry
        %tmp.52 = seteq int %tmp.7, 875         ; <bool> [#uses=1]
        br bool %tmp.52, label %cond_true.3, label %cond_false.3

where the branch could be folded into the switch.

This kind of thing occurs *ALL OF THE TIME*, especially in programs like
176.gcc, which is a horrible mess of code.  It contains stuff like *shudder*:

#define SWITCH_TAKES_ARG(CHAR) \
  (   (CHAR) == 'D' \
   || (CHAR) == 'U' \
   || (CHAR) == 'o' \
   || (CHAR) == 'e' \
   || (CHAR) == 'u' \
   || (CHAR) == 'I' \
   || (CHAR) == 'm' \
   || (CHAR) == 'L' \
   || (CHAR) == 'A' \
   || (CHAR) == 'h' \
   || (CHAR) == 'z')

and

#define CONST_OK_FOR_LETTER_P(VALUE, C)                 \
  ((C) == 'I' ? SMALL_INTVAL (VALUE)                    \
   : (C) == 'J' ? SMALL_INTVAL (-(VALUE))               \
   : (C) == 'K' ? (unsigned)(VALUE) < 32                \
   : (C) == 'L' ? ((VALUE) & 0xffff) == 0               \
   : (C) == 'M' ? integer_ok_for_set (VALUE)            \
   : (C) == 'N' ? (VALUE) < 0                           \
   : (C) == 'O' ? (VALUE) == 0                          \
   : (C) == 'P' ? (VALUE) >= 0                          \
   : 0)

and

#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)                     \
{                                                               \
  if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \
    (X) = gen_rtx (PLUS, SImode, XEXP (X, 0),                   \
                   copy_to_mode_reg (SImode, XEXP (X, 1)));     \
  if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \
    (X) = gen_rtx (PLUS, SImode, XEXP (X, 1),                   \
                   copy_to_mode_reg (SImode, XEXP (X, 0)));     \
  if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT)   \
    (X) = gen_rtx (PLUS, SImode, XEXP (X, 1),                   \
                   force_operand (XEXP (X, 0), 0));             \
  if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT)   \
    (X) = gen_rtx (PLUS, SImode, XEXP (X, 0),                   \
                   force_operand (XEXP (X, 1), 0));             \
  if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS)   \
    (X) = gen_rtx (PLUS, Pmode, force_operand (XEXP (X, 0), NULL_RTX),\
                   XEXP (X, 1));                                \
  if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS)   \
    (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0),                    \
                   force_operand (XEXP (X, 1), NULL_RTX));      \
  if (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST       \
           || GET_CODE (X) == LABEL_REF)                        \
    (X) = legitimize_address (flag_pic, X, 0, 0);               \
  if (memory_address_p (MODE, X))                               \
    goto WIN; }

and others.  These macros get used multiple times of course.  These are such
lovely candidates for macros, aren't they?  :)

This code also nicely handles LLVM constructs that look like this:

  if (isa<CastInst>(I))
   ...
  else if (isa<BranchInst>(I))
   ...
  else if (isa<SetCondInst>(I))
   ...
  else if (isa<UnwindInst>(I))
   ...
  else if (isa<VAArgInst>(I))
   ...

where the isa can obviously be a dyn_cast as well.  Switch instructions are a
good thing.

llvm-svn: 11870
 2004-02-26 07:13:46 +00:00
Chris Lattner 8d1da1abee My faith in programmers has been found to be totally misplaced. One would 
assume that if they don't intend to write to a global variable, that they
would mark it as constant.  However, there are people that don't understand
that the compiler can do nice things for them if they give it the information
it needs.

This pass looks for blatently obvious globals that are only ever read from.
Though it uses a trivially simple "alias analysis" of sorts, it is still able
to do amazing things to important benchmarks.  253.perlbmk, for example,
contains several ***GIANT*** function pointer tables that are not marked
constant and should be.  Marking them constant allows the optimizer to turn
a whole bunch of indirect calls into direct calls.  Note that only a link-time
optimizer can do this transformation, but perlbmk does have several strings
and other minor globals that can be marked constant by this pass when run
from GCCAS.

176.gcc has a ton of strings and large tables that are marked constant, both
at compile time (38 of them) and at link time (48 more).  Other benchmarks
give similar results, though it seems like big ones have disproportionally
more than small ones.

This pass is extremely quick and does good things.  I'm going to enable it
in gccas & gccld.  Not bad for 50 SLOC.

llvm-svn: 11836
 2004-02-25 21:34:36 +00:00
Chris Lattner 9c6833c5ca Fix incorrect debug code 
llvm-svn: 11821
 2004-02-25 15:15:04 +00:00
Chris Lattner 8ee0593f0d Fix a faulty optimization on FP values 
llvm-svn: 11801
 2004-02-24 18:10:14 +00:00
Chris Lattner 90ea78edba If a block is made dead, make sure to promptly remove it. 
llvm-svn: 11799
 2004-02-24 16:09:21 +00:00
Chris Lattner a2ab489135 Implement SimplifyCFG/switch_switch_fold.ll 
This case occurs many times in various benchmarks, especially when combined
with the previous patch.  This allows it to get stuff like:
  if (X == 4 || X == 3)
    if (X == 5 || X == 8)

and

switch (X) {
case 4: case 5: case 6:
  if (X == 4 || X == 5)

llvm-svn: 11797
 2004-02-24 07:23:58 +00:00
Chris Lattner 3cd98f054a Rearrange code a bit 
llvm-svn: 11793
 2004-02-24 05:54:22 +00:00
Chris Lattner 6f4b45acf5 Implement: test/Regression/Transforms/SimplifyCFG/switch_create.ll 
This turns code like this:
  if (X == 4 | X == 7)
and
  if (X != 4 & X != 7)
into switch instructions.

llvm-svn: 11792
 2004-02-24 05:38:11 +00:00
Chris Lattner ae739aefd7 Generate much more efficient code in programs like pifft 
llvm-svn: 11775
 2004-02-23 21:46:58 +00:00
Chris Lattner c40b9d7d51 Fix a small typeo in my checkin last night that broke vortex and other programs :( 
llvm-svn: 11774
 2004-02-23 21:46:42 +00:00
Chris Lattner f5ce254692 Fix InstCombine/2004-02-23-ShiftShiftOverflow.ll 
Also, turn 'shr int %X, 1234' into 'shr int %X, 31'

llvm-svn: 11768
 2004-02-23 20:30:06 +00:00
Chris Lattner 2b55ea38bc Implement cast.ll::test14/15 
llvm-svn: 11742
 2004-02-23 07:16:20 +00:00
Chris Lattner e79e854c5c Refactor some code. In the mul - setcc folding case, we really care about 
whether this is the sign bit or not, so check unsigned comparisons as well.

llvm-svn: 11740
 2004-02-23 06:38:22 +00:00
Chris Lattner c8a10c4b6a Implement mul.ll:test11 
llvm-svn: 11737
 2004-02-23 06:00:11 +00:00
Chris Lattner 59611149ee Implement "strength reduction" of X <= C and X >= C 
llvm-svn: 11735
 2004-02-23 05:47:48 +00:00
Chris Lattner 2635b52d4e Implement InstCombine/mul.ll:test10, which is a case that occurs when dealing 
with "predication"

llvm-svn: 11734
 2004-02-23 05:39:21 +00:00
Chris Lattner 8d0bacbb9e Implement Transforms/InstCombine/cast.ll:test13, a case which occurs in a 
hot 164.gzip loop.

llvm-svn: 11702
 2004-02-22 05:25:17 +00:00
Chris Lattner 693e393fee Fix PR245: Linking weak and strong global variables is dependent on link order 
llvm-svn: 11565
 2004-02-17 21:56:04 +00:00
Chris Lattner e42732e75f Implement test/Regression/Transforms/SimplifyCFG/UncondBranchToReturn.ll, 
see the testcase for the reasoning.

llvm-svn: 11496
 2004-02-16 06:35:48 +00:00
Chris Lattner 4db2d22bea Fold PHI nodes of constants which are only used by a single cast. This implements 
phi.ll:test4

llvm-svn: 11494
 2004-02-16 05:07:08 +00:00
Chris Lattner b36d908f7b Teach LLVM to unravel the "swap idiom". This implements: 
Regression/Transforms/InstCombine/xor.ll:test20

llvm-svn: 11492
 2004-02-16 03:54:20 +00:00
Chris Lattner c207635fd5 Implement Transforms/InstCombine/xor.ll:test19 
llvm-svn: 11490
 2004-02-16 01:20:27 +00:00
Chris Lattner d85e061575 Instead of producing calls to setjmp/longjmp, produce uses of the 
llvm.setjmp/llvm.longjmp intrinsics.

llvm-svn: 11482
 2004-02-15 22:24:27 +00:00
Chris Lattner 76b2ff4ded Adjustments to support the new ConstantAggregateZero class 
llvm-svn: 11474
 2004-02-15 05:55:15 +00:00
Chris Lattner 37a716fa80 Remove dependence on return type of ConstantStruct::get 
llvm-svn: 11466
 2004-02-15 04:07:32 +00:00
Chris Lattner c75bf528c1 Remove dependence on the return type of ConstantArray::get 
llvm-svn: 11463
 2004-02-15 04:05:58 +00:00
Chris Lattner 283ffdfac5 Fix compilation of 126.gcc: intrinsic functions cannot throw, so they are not 
allowed in invoke instructions.  Thus, if we are inlining a call to an intrinsic
function into an invoke site, we don't need to turn the call into an invoke!

llvm-svn: 11384
 2004-02-13 16:47:35 +00:00
Chris Lattner 7db49ce5b4 Intrinsic functions cannot throw 
llvm-svn: 11383
 2004-02-13 16:46:46 +00:00
Chris Lattner 7cbb22abe6 Expose a pass ID that can be 'required' 
llvm-svn: 11376
 2004-02-13 16:16:16 +00:00
Chris Lattner d4b36cf9bc Remove obsolete comment. Unreachable blocks will automatically be left at the 
end of the function.

llvm-svn: 11313
 2004-02-11 05:20:50 +00:00
Chris Lattner 5add05129e Add an _embarassingly simple_ implementation of basic block layout. This is 
more of a testcase for profiling information than anything that should reasonably
be used, but it's a starting point.  When I have more time I will whip this into
better shape.

llvm-svn: 11311
 2004-02-11 04:53:20 +00:00
Chris Lattner 18d1f19fba Implement SimplifyCFG/PhiEliminate.ll 
Having a proper 'select' instruction would allow the elimination of a lot
of the special case cruft in this patch, but we don't have one yet.

llvm-svn: 11307
 2004-02-11 03:36:04 +00:00
Chris Lattner 838b845781 The hasConstantReferences predicate always returns false. 
llvm-svn: 11301
 2004-02-11 01:17:07 +00:00
Chris Lattner 3232bbb9d8 initialization calls now return argc. If the program uses the argc value 
passed into main, make sure they use the return value of the init call
instead of the one passed in.

llvm-svn: 11262
 2004-02-10 17:41:01 +00:00
Chris Lattner 37d46f4815 Only add the global variable with the abort message if an unwind actually 
occurs in the program.

llvm-svn: 11249
 2004-02-09 22:48:47 +00:00
Chris Lattner e3af6f73ce Don't depend on auto data conversion 
llvm-svn: 11229
 2004-02-09 05:16:30 +00:00
Chris Lattner ac6db755c3 Adjust to the changed StructType interface. In particular, getElementTypes() is gone. 
llvm-svn: 11228
 2004-02-09 04:37:31 +00:00
Chris Lattner fa829be4d3 Start using the new and improve interface to FunctionType arguments 
llvm-svn: 11224
 2004-02-09 04:14:01 +00:00
Chris Lattner 57ea2e3294 The ConstantExpr::getCast call can cause a CPR to be generated. If so, 
strip it off.

llvm-svn: 11213
 2004-02-09 00:20:55 +00:00
Misha Brukman 3480e935d0 Fix grammar-o. 
llvm-svn: 11210
 2004-02-08 22:27:33 +00:00