test/CodeGen/AMDGPU/multilevel-break.ll

   1 ; RUN: opt -S -mtriple=amdgcn-- -structurizecfg -si-annotate-control-flow < %s | FileCheck -check-prefix=OPT %s
   2 ; RUN: llc -march=amdgcn -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s
   3
   4 ; OPT-LABEL: {{^}}define amdgpu_vs void @multi_else_break(
   5 ; OPT: main_body:
   6 ; OPT: LOOP.outer:
   7 ; OPT: LOOP:
   8 ; OPT:     [[if:%[0-9]+]] = call { i1, i64 } @llvm.amdgcn.if.i64(
   9 ; OPT:     [[if_exec:%[0-9]+]] = extractvalue { i1, i64 } [[if]], 1
  10 ;
  11 ; OPT: Flow:
  12 ;
  13 ; Ensure two if.break calls, for both the inner and outer loops
  14
  15 ; OPT:        call void @llvm.amdgcn.end.cf
  16 ; OPT-NEXT:   call i64 @llvm.amdgcn.if.break.i64.i64(i1
  17 ; OPT-NEXT:   call i1 @llvm.amdgcn.loop.i64(i64
  18 ; OPT-NEXT:   call i64 @llvm.amdgcn.if.break.i64.i64(i1
  19 ;
  20 ; OPT: Flow1:
  21
  22 ; GCN-LABEL: {{^}}multi_else_break:
  23
  24 ; GCN: ; %main_body
  25 ; GCN:      s_mov_b64           [[LEFT_OUTER:s\[[0-9]+:[0-9]+\]]], 0{{$}}
  26
  27 ; GCN: [[FLOW2:BB[0-9]+_[0-9]+]]: ; %Flow2
  28 ; GCN:      s_or_b64            exec, exec, [[TMP0:s\[[0-9]+:[0-9]+\]]]
  29 ; GCN:      s_and_b64           [[TMP1:s\[[0-9]+:[0-9]+\]]], exec, [[BREAK_OUTER:s\[[0-9]+:[0-9]+\]]]
  30 ; GCN:      s_or_b64            [[TMP1]], [[TMP1]], [[LEFT_OUTER]]
  31 ; GCN:      s_mov_b64           [[LEFT_OUTER]], [[TMP1]]
  32 ; GCN:      s_andn2_b64         exec, exec, [[TMP1]]
  33 ; GCN:      s_cbranch_execz    [[IF_BLOCK:BB[0-9]+_[0-9]+]]
  34
  35 ; GCN: [[OUTER_LOOP:BB[0-9]+_[0-9]+]]: ; %LOOP.outer{{$}}
  36 ; GCN:      s_mov_b64           [[LEFT_INNER:s\[[0-9]+:[0-9]+\]]], 0{{$}}
  37
  38 ; GCN: ; %Flow
  39 ; GCN:      s_or_b64            exec, exec, [[SAVE_EXEC:s\[[0-9]+:[0-9]+\]]]
  40 ; GCN:      s_and_b64           [[TMP0]], exec, [[BREAK_INNER:s\[[0-9]+:[0-9]+\]]]
  41 ; GCN:      s_or_b64            [[TMP0]], [[TMP0]], [[LEFT_INNER]]
  42 ; GCN:      s_mov_b64           [[LEFT_INNER]], [[TMP0]]
  43 ; GCN:      s_andn2_b64         exec, exec, [[TMP0]]
  44 ; GCN:      s_cbranch_execz    [[FLOW2]]
  45
  46 ; GCN: [[INNER_LOOP:BB[0-9]+_[0-9]+]]: ; %LOOP{{$}}
  47 ; GCN:      s_or_b64            [[BREAK_OUTER]], [[BREAK_OUTER]], exec
  48 ; GCN:      s_or_b64            [[BREAK_INNER]], [[BREAK_INNER]], exec
  49 ; GCN:      s_and_saveexec_b64  [[SAVE_EXEC]], vcc
  50
  51 ; FIXME: duplicate comparison
  52 ; GCN: ; %ENDIF
  53 ; GCN-DAG:  v_cmp_eq_u32_e32    vcc,
  54 ; GCN-DAG:  v_cmp_ne_u32_e64    [[TMP51NEG:s\[[0-9]+:[0-9]+\]]],
  55 ; GCN-DAG:  s_andn2_b64         [[BREAK_OUTER]], [[BREAK_OUTER]], exec
  56 ; GCN-DAG:  s_andn2_b64         [[BREAK_INNER]], [[BREAK_INNER]], exec
  57 ; GCN-DAG:  s_and_b64           [[TMP_EQ:s\[[0-9]+:[0-9]+\]]], vcc, exec
  58 ; GCN-DAG:  s_and_b64           [[TMP_NE:s\[[0-9]+:[0-9]+\]]], [[TMP51NEG]], exec
  59 ; GCN-DAG:  s_or_b64            [[BREAK_OUTER]], [[BREAK_OUTER]], [[TMP_EQ]]
  60 ; GCN-DAG:  s_or_b64            [[BREAK_INNER]], [[BREAK_INNER]], [[TMP_NE]]
  61
  62 ; GCN: [[IF_BLOCK]]: ; %IF
  63 ; GCN-NEXT: s_endpgm
  64 define amdgpu_vs void @multi_else_break(<4 x float> %vec, i32 %ub, i32 %cont) {
  65 main_body:
  66   br label %LOOP.outer
  67
  68 LOOP.outer:                                       ; preds = %ENDIF, %main_body
  69   %tmp43 = phi i32 [ 0, %main_body ], [ %tmp47, %ENDIF ]
  70   br label %LOOP
  71
  72 LOOP:                                             ; preds = %ENDIF, %LOOP.outer
  73   %tmp45 = phi i32 [ %tmp43, %LOOP.outer ], [ %tmp47, %ENDIF ]
  74   %tmp47 = add i32 %tmp45, 1
  75   %tmp48 = icmp slt i32 %tmp45, %ub
  76   br i1 %tmp48, label %ENDIF, label %IF
  77
  78 IF:                                               ; preds = %LOOP
  79   ret void
  80
  81 ENDIF:                                            ; preds = %LOOP
  82   %tmp51 = icmp eq i32 %tmp47, %cont
  83   br i1 %tmp51, label %LOOP, label %LOOP.outer
  84 }
  85
  86 ; OPT-LABEL: define amdgpu_kernel void @multi_if_break_loop(
  87 ; OPT: llvm.amdgcn.if.break
  88 ; OPT: llvm.amdgcn.loop
  89 ; OPT: llvm.amdgcn.if.break
  90 ; OPT: llvm.amdgcn.end.cf
  91
  92 ; GCN-LABEL: {{^}}multi_if_break_loop:
  93 ; GCN:      s_mov_b64          [[LEFT:s\[[0-9]+:[0-9]+\]]], 0{{$}}
  94
  95 ; GCN: ; %Flow4
  96 ; GCN:      s_and_b64          [[BREAK:s\[[0-9]+:[0-9]+\]]], exec, [[BREAK]]
  97 ; GCN:      s_or_b64           [[LEFT]], [[BREAK]], [[OLD_LEFT:s\[[0-9]+:[0-9]+\]]]
  98 ; GCN:      s_andn2_b64        exec, exec, [[LEFT]]
  99 ; GCN-NEXT: s_cbranch_execz
 100
 101 ; GCN: [[LOOP:BB[0-9]+_[0-9]+]]: ; %bb1{{$}}
 102 ; GCN:      s_mov_b64          [[OLD_LEFT]], [[LEFT]]
 103
 104 ; GCN: ; %LeafBlock1
 105 ; GCN:      s_mov_b64
 106 ; GCN:      s_mov_b64          [[BREAK]], -1{{$}}
 107
 108 ; GCN: ; %case1
 109 ; GCN:      buffer_load_dword  [[LOAD2:v[0-9]+]],
 110 ; GCN:      v_cmp_ge_i32_e32   vcc, {{v[0-9]+}}, [[LOAD2]]
 111 ; GCN:      s_orn2_b64         [[BREAK]], vcc, exec
 112
 113 ; GCN: ; %Flow3
 114 ; GCN:      s_branch           [[FLOW:BB[0-9]+_[0-9]+]]
 115
 116 ; GCN:      s_mov_b64          [[BREAK]], -1{{$}}
 117
 118 ; GCN: [[FLOW]]: ; %Flow
 119
 120 ; GCN: ; %case0
 121 ; GCN:      buffer_load_dword  [[LOAD1:v[0-9]+]],
 122 ; GCN-DAG:  s_andn2_b64        [[BREAK]], [[BREAK]], exec
 123 ; GCN-DAG:  v_cmp_ge_i32_e32   vcc, {{v[0-9]+}}, [[LOAD1]]
 124 ; GCN-DAG:  s_and_b64          [[TMP:s\[[0-9]+:[0-9]+\]]], vcc, exec
 125 ; GCN:      s_or_b64           [[BREAK]], [[BREAK]], [[TMP]]
 126
 127 define amdgpu_kernel void @multi_if_break_loop(i32 %arg) #0 {
 128 bb:
 129   %id = call i32 @llvm.amdgcn.workitem.id.x()
 130   %tmp = sub i32 %id, %arg
 131   br label %bb1
 132
 133 bb1:
 134   %lsr.iv = phi i32 [ undef, %bb ], [ %lsr.iv.next, %case0 ], [ %lsr.iv.next, %case1 ]
 135   %lsr.iv.next = add i32 %lsr.iv, 1
 136   %cmp0 = icmp slt i32 %lsr.iv.next, 0
 137   %load0 = load volatile i32, i32 addrspace(1)* undef, align 4
 138   switch i32 %load0, label %bb9 [
 139     i32 0, label %case0
 140     i32 1, label %case1
 141   ]
 142
 143 case0:
 144   %load1 = load volatile i32, i32 addrspace(1)* undef, align 4
 145   %cmp1 = icmp slt i32 %tmp, %load1
 146   br i1 %cmp1, label %bb1, label %bb9
 147
 148 case1:
 149   %load2 = load volatile i32, i32 addrspace(1)* undef, align 4
 150   %cmp2 = icmp slt i32 %tmp, %load2
 151   br i1 %cmp2, label %bb1, label %bb9
 152
 153 bb9:
 154   ret void
 155 }
 156
 157 declare i32 @llvm.amdgcn.workitem.id.x() #1
 158
 159 attributes #0 = { nounwind }
 160 attributes #1 = { nounwind readnone }