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

284 Commits

Author SHA1 Message Date
Chris Lattner a43312d30b Add support for evaluation of exp/log/log10/pow 
llvm-svn: 13011
 2004-04-16 22:35:33 +00:00
Brian Gaeke 174633b078 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
Chris Lattner 0328d75c83 Fix Inline/2004-04-15-InlineDeletesCall.ll 
Basically we were using SimplifyCFG as a huge sledgehammer for a simple
optimization.  Because simplifycfg does so many things, we can't use it
for this purpose.

llvm-svn: 12977
 2004-04-16 05:17:59 +00:00
Chris Lattner ca52d0468e Add a simple call constant propagation interface. 
llvm-svn: 12919
 2004-04-13 19:28:52 +00:00
Chris Lattner 0aa565647c Fold code like: 
if (C)
    V1 |= V2;

into:
  Vx = V1 | V2;
  V1 = select C, V1, Vx

when the expression can be evaluated unconditionally and is *cheap* to
execute.  This limited form of if conversion is quite handy in lots of cases.
For example, it turns this testcase into straight-line code:

int in0 ; int in1 ; int in2 ; int in3 ;
int in4 ; int in5 ; int in6 ; int in7 ;
int in8 ; int in9 ; int in10; int in11;
int in12; int in13; int in14; int in15;
long output;

void mux(void) {
  output =
      (in0   ?  0x00000001 : 0) | (in1   ?  0x00000002 : 0) |
      (in2   ?  0x00000004 : 0) | (in3   ?  0x00000008 : 0) |
      (in4   ?  0x00000010 : 0) | (in5   ?  0x00000020 : 0) |
      (in6   ?  0x00000040 : 0) | (in7   ?  0x00000080 : 0) |
      (in8   ?  0x00000100 : 0) | (in9   ?  0x00000200 : 0) |
      (in10  ?  0x00000400 : 0) | (in11  ?  0x00000800 : 0) |
      (in12  ?  0x00001000 : 0) | (in13  ?  0x00002000 : 0) |
      (in14  ?  0x00004000 : 0) | (in15  ?  0x00008000 : 0) ;
}

llvm-svn: 12798
 2004-04-09 22:50:22 +00:00
Chris Lattner 3b3861d305 Implement ScalarRepl/select_promote.ll 
llvm-svn: 12779
 2004-04-08 19:59:34 +00:00
Chris Lattner eed034bcd3 Fix the obvious bug in my previous checkin 
llvm-svn: 12618
 2004-04-02 18:15:10 +00:00
Chris Lattner 9f0db32625 Implement Transforms/SimplifyCFG/return-merge.ll 
This actually causes us to turn code like:

  return C ? A : B;

into a select instruction.

llvm-svn: 12617
 2004-04-02 18:13:43 +00:00
Chris Lattner c24019c825 Fix PR310 and TailDup/2004-04-01-DemoteRegToStack.llx 
llvm-svn: 12597
 2004-04-01 20:28:45 +00:00
Chris Lattner 709f03e2dd Fix linking of constant expr casts due to type resolution changes. With 
this and the other patches 253.perlbmk links again.

llvm-svn: 12565
 2004-03-31 02:58:28 +00:00
Chris Lattner 81bdcb90ce Now that all the code generators support the select instruction, and the instcombine 
pass can eliminate many nasty cases of them, start generating them in the optimizers

llvm-svn: 12545
 2004-03-30 19:44:05 +00:00
Chris Lattner 232155dc1b Fix bug: CodeExtractor/2004-03-17-MissedLiveIns.ll 
With this fix we now successfully extract all 149 loops from 256.bzip2 without
crashing or miscompiling the program!

llvm-svn: 12493
 2004-03-18 05:56:32 +00:00
Chris Lattner acd75986ee Fix CodeExtractor/2004-03-17-UpdatePHIsOutsideRegion.ll 
llvm-svn: 12489
 2004-03-18 05:38:31 +00:00
Chris Lattner 320d59f4cd Seriously simplify and correct the PHI node handling code. 
llvm-svn: 12487
 2004-03-18 05:28:49 +00:00
Chris Lattner d8017a340d Fix CodeExtractor/2004-03-17-OutputMismatch.ll 
llvm-svn: 12486
 2004-03-18 04:12:05 +00:00
Chris Lattner 37de257ef0 Fix several bugs in the extractor: 
1. Names were not put on the new arguments created (ok, this just helps sanity :)
2. Fix outgoing pointer values
3. Do not insert stores for values that had not been computed
4. Fix some wierd problems with the outset calculation

This fixes CodeExtractor/2004-03-14-DominanceProblem.ll, making the extractor
work on at least one simple case!

llvm-svn: 12484
 2004-03-18 03:49:40 +00:00
Chris Lattner cee3404d0a Prune #includes, moving the module interface to the front. Note that this 
exposed the fact that the header was not self-contained.  There is a reason
we do things :)

llvm-svn: 12481
 2004-03-18 03:15:29 +00:00
Chris Lattner a078f47b39 Fix compilation of mesa, which I broke earlier today 
llvm-svn: 12465
 2004-03-17 02:02:47 +00:00
Chris Lattner bb1a2cc7ab This code was both incredibly complex and incredibly broken. Fix it. 
llvm-svn: 12456
 2004-03-16 23:23:11 +00:00
Chris Lattner a64923ad26 Do not copy gigantic switch instructions 
llvm-svn: 12441
 2004-03-16 19:45:22 +00:00
Chris Lattner fb87cdecd8 Mostly cosmetic improvements. Do fix the bug where a global value was considered an input. 
llvm-svn: 12406
 2004-03-15 01:26:44 +00:00
Chris Lattner 73ab1fa7c8 Assert that input blocks meet the invariants we expect 
Simplify the input/output finder.  All elements of a basic block are
instructions.  Any used arguments are also inputs.  An instruction can only
be used by another instruction.

llvm-svn: 12405
 2004-03-15 01:18:23 +00:00
Chris Lattner 5b2072ecd3 No correctness fixes here, just minor qoi fixes: 
* Don't insert a branch to the switch instruction after the call, just
  make it a single block.
* Insert the new alloca instructions in the entry block of the original
  function instead of having them execute dynamically
* Don't make the default edge of the switch instruction go back to the switch.
  The loop extractor shouldn't create new loops!
* Give meaningful names to the alloca slots and the reload instructions
* Some minor code simplifications

llvm-svn: 12402
 2004-03-14 23:43:24 +00:00
Chris Lattner b4d8bf365c Simplify code a bit, and fix bug CodeExtractor/2004-03-14-NoSwitchSupport.ll 
This also implements a two minor improvements:
  * Don't insert live-out stores IN the region, insert them on the code path
    that exits the region
  * If the region is exited to the same block from multiple paths, share the
    switch statement entry, live-out store code, and the basic block.

llvm-svn: 12401
 2004-03-14 23:05:49 +00:00
Chris Lattner 9c431f6c44 Simplify the code a bit by making the collection of basic blocks to extract 
a member of the class.  While we're at it, turn the collection into a set
instead of a vector to improve efficiency and make queries simpler.

llvm-svn: 12400
 2004-03-14 22:34:55 +00:00
Chris Lattner 4fca71eb44 Minor random cleanups 
llvm-svn: 12382
 2004-03-14 04:01:47 +00:00
Chris Lattner 3684469326 Verify functions as they are produced if -debug is specified. Reduce 
curly braceage

llvm-svn: 12378
 2004-03-14 03:17:22 +00:00
Chris Lattner 41ec709e00 Move to the IPO library. Utils shouldn't contain passes. 
llvm-svn: 12372
 2004-03-14 02:32:27 +00:00
Chris Lattner 8eebc49884 DemoteRegToStack got moved from DemoteRegToStack.h to Local.h 
llvm-svn: 12368
 2004-03-14 02:13:38 +00:00
Chris Lattner cb015ee6c0 Add constant folding wrapper support for select instructions. 
llvm-svn: 12319
 2004-03-12 05:53:03 +00:00
Misha Brukman f44acae31e Implement ExtractCodeRegion() 
llvm-svn: 12070
 2004-03-02 00:20:57 +00:00
Misha Brukman f272f9b3d5 Make a note that this is usually used via bugpoint. 
llvm-svn: 12068
 2004-03-02 00:19:09 +00:00
Misha Brukman 5af2be7d09 * Add implementation of ExtractBasicBlock() 
* Add comments to ExtractLoop()

llvm-svn: 12053
 2004-03-01 18:28:34 +00:00
Chris Lattner 2de229f31b Fix bug: test/Regression/Transforms/LowerInvoke/2004-02-29-PHICrash.llx 
... which tickled the lowerinvoke pass because it used the BCE routines.

llvm-svn: 12012
 2004-02-29 22:24:41 +00:00
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
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 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 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 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 76b2ff4ded Adjustments to support the new ConstantAggregateZero class 
llvm-svn: 11474
 2004-02-15 05:55:15 +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 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 fae8ab3088 rename the "exceptional" destination of an invoke instruction to the 'unwind' dest 
llvm-svn: 11202
 2004-02-08 21:44:31 +00:00