test/CodeGen/Generic/select.ll

   1 %AConst    = constant int 123
   2
   3 implementation
   4
   5 ; Test setting values of different constants in registers.
   6 ;
   7 void "testConsts"(int %N, float %X)
   8 begin
   9 ; <label>:0
  10         %a = add int %N, 1              ; 1 should be put in immed field
  11         %a2= add int %N, 12345678       ; constant has to be loaded
  12         %b = add short 4, 3             ; one of the operands shd be immed
  13         %c = add float %X, 0.0          ; will this be optimzzed?
  14         %d = add float %X, 3.1415       ; constant has to be loaded
  15         %f = add uint 4294967295, 10    ; result shd be  9   (not in immed fld)
  16         %g = add ushort 20, 65535       ; result shd be 19 (65536 in immed fld)
  17         %g = add ushort 65535, 30       ; result shd be 29   (not in immed fld)
  18         %h = add ubyte  40, 255         ; result shd be 39   (255 in immed fld)
  19         %h = add ubyte  255, 50         ; result shd be 49   (not in immed fld)
  20
  21         ret void
  22 end
  23
  24 ; A SetCC whose result is used should produce instructions to
  25 ; compute the boolean value in a register.  One whose result
  26 ; is unused will only generate the condition code but not
  27 ; the boolean result.
  28 ;
  29 void "unusedBool"(int * %x, int * %y)
  30 begin
  31 ; <label>:0                             ;               [#uses=0]
  32         seteq int * %x, %y              ; <bool>:0      [#uses=1]
  33         not bool %0                     ; <bool>:1      [#uses=0]
  34         setne int * %x, %y              ; <bool>:2      [#uses=0]
  35         ret void
  36 end
  37
  38 ; A constant argument to a Phi produces a Cast instruction in the
  39 ; corresponding predecessor basic block.  This checks a few things:
  40 ; -- phi arguments coming from the bottom of the same basic block
  41 ;    (they should not be forward substituted in the machine code!)
  42 ; -- code generation for casts of various types
  43 ; -- use of immediate fields for integral constants of different sizes
  44 ; -- branch on a constant condition
  45 ;
  46 void "mergeConstants"(int * %x, int * %y)
  47 begin
  48 ; <label>:0
  49         br label %Top
  50 Top:
  51         phi int    [ 0,    %0 ], [ 1,    %Top ], [ 524288, %Next ]
  52         phi float  [ 0.0,  %0 ], [ 1.0,  %Top ], [ 2.0,    %Next ]
  53         phi double [ 0.5,  %0 ], [ 1.5,  %Top ], [ 2.5,    %Next ]
  54         phi bool   [ true, %0 ], [ false,%Top ], [ true,   %Next ]
  55         br bool true, label %Top, label %Next
  56 Next:
  57         br label %Top
  58 end
  59
  60
  61
  62 ; A constant argument to a cast used only once should be forward substituted
  63 ; and loaded where needed, which happens is:
  64 ; -- User of cast has no immediate field
  65 ; -- User of cast has immediate field but constant is too large to fit
  66 ;    or constant is not resolved until later (e.g., global address)
  67 ; -- User of cast uses it as a call arg. or return value so it is an implicit
  68 ;    use but has to be loaded into a virtual register so that the reg.
  69 ;    allocator can allocate the appropriate phys. reg. for it
  70 ;
  71 int* "castconst"(float)
  72 begin
  73 ; <label>:0
  74         %castbig   = cast ulong 99999999 to int
  75         %castsmall = cast ulong 1        to int
  76         %usebig    = add int %castbig, %castsmall
  77
  78         %castglob = cast int* %AConst to long*
  79         %dummyl   = load long* %castglob
  80
  81         %castnull = cast ulong 0 to int*
  82         ret int* %castnull
  83 end
  84
  85
  86
  87 ; Test branch-on-comparison-with-zero, in two ways:
  88 ; 1. can be folded
  89 ; 2. cannot be folded because result of comparison is used twice
  90 ;
  91 void "testbool"(int, int)   ; Def %0, %1
  92         const int 0          ; Def 2
  93         const int -4         ; Def 3
  94 begin
  95 ; <label>:0
  96         br label %Top
  97 Top:
  98         add int %0, %1    ; Def 4
  99         sub int %4, %3    ; Def 5
 100         setle int %5, %2  ; Def 0 - bool plane
 101         br bool %0, label %retlbl, label %loop
 102
 103 loop:
 104         add int %0, %1    ; Def 6
 105         sub int %4, %3    ; Def 7
 106         setle int %7, %2  ; Def 1 - bool
 107         not bool %1               ; Def 2 - bool. first use of bool %1
 108         br bool %1, label %loop, label %Top   ;  second use of bool %1
 109
 110 retlbl:
 111         ret void
 112 end
 113
 114
 115 ; Test branch on floating point comparison
 116 ;
 117 void "testfloatbool"(float %x, float %y)   ; Def %0, %1 - float
 118 begin
 119 ; <label>:0
 120         br label %Top
 121 Top:
 122         %p = add float %x, %y    ; Def 2 - float
 123         %z = sub float %x, %y    ; Def 3 - float
 124         %b = setle float %p, %z  ; Def 0 - bool
 125         %c = not bool %b         ; Def 1 - bool
 126         br bool %b, label %Top, label %goon
 127 goon:
 128         ret void
 129 end
 130
 131
 132 ; Test cases where an LLVM instruction requires no machine
 133 ; instructions (e.g., cast int* to long).  But there are 2 cases:
 134 ; 1. If the result register has only a single use and the use is in the
 135 ;    same basic block, the operand will be copy-propagated during
 136 ;    instruction selection.
 137 ; 2. If the result register has multiple uses or is in a different
 138 ;    basic block, it cannot (or will not) be copy propagated during
 139 ;    instruction selection.  It will generate a
 140 ;    copy instruction (add-with-0), but this copy should get coalesced
 141 ;    away by the register allocator.
 142 ;
 143 int "checkForward"(int %N, int* %A)
 144 begin
 145
 146 bb2:            ;;<label>
 147         %reg114 = shl int %N, ubyte 2           ;;
 148         %cast115 = cast int %reg114 to int*     ;; reg114 will be propagated
 149         %reg116 = add int* %A, %cast115         ;;
 150         %reg118 = load int* %reg116             ;;
 151         %cast117 = cast int %reg118 to long     ;; reg118 will be copied 'cos
 152         %reg159 = add long 1234567, %cast117    ;;  cast117 has 2 uses, here
 153         %reg160 = add long 7654321, %cast117    ;;  and here.
 154         ret void
 155 end