Home | History | Annotate | Download | only in Bitcode 
      1 ; RUN: verify-uselistorder < %s
      2 
      3 @a = global [4 x i1] [i1 0, i1 1, i1 0, i1 1]
      4 @b = alias i1, getelementptr ([4 x i1], [4 x i1]* @a, i64 0, i64 2)
      5 
      6 ; Check use-list order of constants used by globals.
      7 @glob1 = global i5 7
      8 @glob2 = global i5 7
      9 @glob3 = global i5 7
     10 
     11 ; Check use-list order between variables and aliases.
     12 @target = global i3 zeroinitializer
     13 @alias1 = alias i3, i3* @target
     14 @alias2 = alias i3, i3* @target
     15 @alias3 = alias i3, i3* @target
     16 @var1 = global i3* @target
     17 @var2 = global i3* @target
     18 @var3 = global i3* @target
     19 
     20 ; Check use-list order for a global when used both by a global and in a
     21 ; function.
     22 @globalAndFunction = global i4 4
     23 @globalAndFunctionGlobalUser = global i4* @globalAndFunction
     24 
     25 ; Check use-list order for constants used by globals that are themselves used
     26 ; as aliases.  This confirms that this globals are recognized as GlobalValues
     27 ; (not general constants).
     28 @const.global = global i63 0
     29 @const.global.ptr = global i63* @const.global
     30 @const.global.2 = global i63 0
     31 
     32 ; Same as above, but for aliases.
     33 @const.target = global i62 1
     34 @const.alias = alias i62, i62* @const.target
     35 @const.alias.ptr = alias i62, i62* @const.alias
     36 @const.alias.2 = alias i62, i62* @const.target
     37 
     38 define i64 @f(i64 %f) {
     39 entry:
     40   %sum = add i64 %f, 0
     41   ret i64 %sum
     42 }
     43 
     44 define i64 @g(i64 %g) {
     45 entry:
     46   %sum = add i64 %g, 0
     47   ret i64 %sum
     48 }
     49 
     50 define i64 @h(i64 %h) {
     51 entry:
     52   %sum = add i64 %h, 0
     53   ret i64 %sum
     54 }
     55 
     56 define i64 @i(i64 %i) {
     57 entry:
     58   %sum = add i64 %i, 1
     59   ret i64 %sum
     60 }
     61 
     62 define i64 @j(i64 %j) {
     63 entry:
     64   %sum = add i64 %j, 1
     65   ret i64 %sum
     66 }
     67 
     68 define i64 @k(i64 %k) {
     69 entry:
     70   %sum = add i64 %k, 1
     71   ret i64 %sum
     72 }
     73 
     74 define i64 @l(i64 %l) {
     75 entry:
     76   %sum = add i64 %l, 1
     77   ret i64 %sum
     78 }
     79 
     80 define i1 @loadb() {
     81 entry:
     82   %b = load i1, i1* @b
     83   ret i1 %b
     84 }
     85 
     86 define i1 @loada() {
     87 entry:
     88   %a = load i1, i1* getelementptr ([4 x i1], [4 x i1]* @a, i64 0, i64 2)
     89   ret i1 %a
     90 }
     91 
     92 define i32 @f32(i32 %a, i32 %b, i32 %c, i32 %d) {
     93 entry:
     94   br label %first
     95 
     96 second:
     97   %eh = mul i32 %e, %h
     98   %sum = add i32 %eh, %ef
     99   br label %exit
    100 
    101 exit:
    102   %product = phi i32 [%ef, %first], [%sum, %second]
    103   ret i32 %product
    104 
    105 first:
    106   %e = add i32 %a, 7
    107   %f = add i32 %b, 7
    108   %g = add i32 %c, 8
    109   %h = add i32 %d, 8
    110   %ef = mul i32 %e, %f
    111   %gh = mul i32 %g, %h
    112   %gotosecond = icmp slt i32 %gh, -9
    113   br i1 %gotosecond, label %second, label %exit
    114 }
    115 
    116 define i4 @globalAndFunctionFunctionUser() {
    117 entry:
    118   %local = load i4, i4* @globalAndFunction
    119   ret i4 %local
    120 }
    121 
    122 ; Check for when an instruction is its own user.
    123 define void @selfUser(i1 %a) {
    124 entry:
    125   ret void
    126 
    127 loop1:
    128   br label %loop2
    129 
    130 loop2:
    131   %var = phi i32 [ %var, %loop1 ], [ %var, %loop2 ]
    132   br label %loop2
    133 }
    134 
    135 ; Check that block addresses work.
    136 @ba1 = constant i8* blockaddress (@bafunc1, %bb)
    137 @ba2 = constant i8* getelementptr (i8, i8* blockaddress (@bafunc2, %bb), i61 0)
    138 @ba3 = constant i8* getelementptr (i8, i8* blockaddress (@bafunc2, %bb), i61 0)
    139 
    140 define i8* @babefore() {
    141   ret i8* getelementptr (i8, i8* blockaddress (@bafunc2, %bb), i61 0)
    142 bb1:
    143   ret i8* blockaddress (@bafunc1, %bb)
    144 bb2:
    145   ret i8* blockaddress (@bafunc3, %bb)
    146 }
    147 define void @bafunc1() {
    148   unreachable
    149 bb:
    150   unreachable
    151 }
    152 define void @bafunc2() {
    153   unreachable
    154 bb:
    155   unreachable
    156 }
    157 define void @bafunc3() {
    158   unreachable
    159 bb:
    160   unreachable
    161 }
    162 define i8* @baafter() {
    163   ret i8* blockaddress (@bafunc2, %bb)
    164 bb1:
    165   ret i8* blockaddress (@bafunc1, %bb)
    166 bb2:
    167   ret i8* blockaddress (@bafunc3, %bb)
    168 }
    169