llvm/test/CodeGen/WebAssembly/lower-em-sjlj.ll

   1 ; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s --check-prefixes=CHECK,NO-TLS -DPTR=i32
   2 ; RUN: opt < %s -wasm-lower-em-ehsjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s --check-prefixes=CHECK,TLS -DPTR=i32
   3 ; RUN: opt < %s -wasm-lower-em-ehsjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s --check-prefixes=CHECK -DPTR=i64
   4
   5 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
   6 target triple = "wasm32-unknown-unknown"
   7
   8 %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
   9
  10 @global_var = global i32 0, align 4
  11 ; NO-TLS-DAG: __THREW__ = external global [[PTR]]
  12 ; NO-TLS-DAG: __threwValue = external global [[PTR]]
  13 ; TLS-DAG: __THREW__ = external thread_local(localexec) global i32
  14 ; TLS-DAG: __threwValue = external thread_local(localexec) global i32
  15 @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* @longjmp, align 4
  16 ; CHECK-DAG: @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* bitcast (void ([[PTR]], i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*)
  17
  18 ; Test a simple setjmp - longjmp sequence
  19 define void @setjmp_longjmp() {
  20 ; CHECK-LABEL: @setjmp_longjmp
  21 entry:
  22   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
  23   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
  24   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
  25   %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
  26   call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 1) #1
  27   unreachable
  28 ; CHECK: entry:
  29 ; CHECK-NEXT: %[[MALLOCCALL:.*]] = tail call i8* @malloc(i32 40)
  30 ; CHECK-NEXT: %[[SETJMP_TABLE:.*]] = bitcast i8* %[[MALLOCCALL]] to i32*
  31 ; CHECK-NEXT: store i32 0, i32* %[[SETJMP_TABLE]]
  32 ; CHECK-NEXT: %[[SETJMP_TABLE_SIZE:.*]] = add i32 4, 0
  33 ; CHECK-NEXT: %[[BUF:.*]] = alloca [1 x %struct.__jmp_buf_tag]
  34 ; CHECK-NEXT: %[[ARRAYDECAY:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0
  35 ; CHECK-NEXT: %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp(%struct.__jmp_buf_tag* %[[ARRAYDECAY]], i32 1, i32* %[[SETJMP_TABLE]], i32 %[[SETJMP_TABLE_SIZE]])
  36 ; CHECK-NEXT: %[[SETJMP_TABLE_SIZE1:.*]] = call i32 @getTempRet0()
  37 ; CHECK-NEXT: br label %entry.split
  38
  39 ; CHECK: entry.split:
  40 ; CHECK-NEXT: phi i32 [ 0, %entry ], [ %[[LONGJMP_RESULT:.*]], %if.end ]
  41 ; CHECK-NEXT: %[[ARRAYDECAY1:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0
  42 ; CHECK-NEXT: %[[JMPBUF:.*]] = ptrtoint %struct.__jmp_buf_tag* %[[ARRAYDECAY1]] to [[PTR]]
  43 ; CHECK-NEXT: store [[PTR]] 0, [[PTR]]* @__THREW__
  44 ; CHECK-NEXT: call cc{{.*}} void @__invoke_void_[[PTR]]_i32(void ([[PTR]], i32)* @emscripten_longjmp, [[PTR]] %[[JMPBUF]], i32 1)
  45 ; CHECK-NEXT: %[[__THREW__VAL:.*]] = load [[PTR]], [[PTR]]* @__THREW__
  46 ; CHECK-NEXT: store [[PTR]] 0, [[PTR]]* @__THREW__
  47 ; CHECK-NEXT: %[[CMP0:.*]] = icmp ne [[PTR]] %__THREW__.val, 0
  48 ; CHECK-NEXT: %[[THREWVALUE_VAL:.*]] = load i32, i32* @__threwValue
  49 ; CHECK-NEXT: %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0
  50 ; CHECK-NEXT: %[[CMP:.*]] = and i1 %[[CMP0]], %[[CMP1]]
  51 ; CHECK-NEXT: br i1 %[[CMP]], label %if.then1, label %if.else1
  52
  53 ; CHECK: entry.split.split:
  54 ; CHECK-NEXT: unreachable
  55
  56 ; CHECK: if.then1:
  57 ; CHECK-NEXT: %[[__THREW__VAL_P:.*]] = inttoptr [[PTR]] %[[__THREW__VAL]] to [[PTR]]*
  58 ; CHECK-NEXT: %[[__THREW__VAL_P_LOADED:.*]] = load [[PTR]], [[PTR]]* %[[__THREW__VAL_P]]
  59 ; CHECK-NEXT: %[[LABEL:.*]] = call i32 @testSetjmp([[PTR]] %[[__THREW__VAL_P_LOADED]], i32* %[[SETJMP_TABLE1]], i32 %[[SETJMP_TABLE_SIZE1]])
  60 ; CHECK-NEXT: %[[CMP:.*]] = icmp eq i32 %[[LABEL]], 0
  61 ; CHECK-NEXT: br i1 %[[CMP]], label %if.then2, label %if.end2
  62
  63 ; CHECK: if.else1:
  64 ; CHECK-NEXT: br label %if.end
  65
  66 ; CHECK: if.end:
  67 ; CHECK-NEXT: %[[LABEL_PHI:.*]] = phi i32 [ %[[LABEL:.*]], %if.end2 ], [ -1, %if.else1 ]
  68 ; CHECK-NEXT: %[[LONGJMP_RESULT]] = call i32 @getTempRet0()
  69 ; CHECK-NEXT: switch i32 %[[LABEL_PHI]], label %entry.split.split [
  70 ; CHECK-NEXT:   i32 1, label %entry.split
  71 ; CHECK-NEXT: ]
  72
  73 ; CHECK: if.then2:
  74 ; CHECK-NEXT: %[[BUF:.*]] = bitcast i32* %[[SETJMP_TABLE1]] to i8*
  75 ; CHECK-NEXT: call void @free(i8* %[[BUF]])
  76 ; CHECK-NEXT: call void @emscripten_longjmp([[PTR]] %[[__THREW__VAL]], i32 %[[THREWVALUE_VAL]])
  77 ; CHECK-NEXT: unreachable
  78
  79 ; CHECK: if.end2:
  80 ; CHECK-NEXT: call void  @setTempRet0(i32 %[[THREWVALUE_VAL]])
  81 ; CHECK-NEXT: br label %if.end
  82 }
  83
  84 ; Test a case of a function call (which is not longjmp) after a setjmp
  85 define void @setjmp_other() {
  86 ; CHECK-LABEL: @setjmp_other
  87 entry:
  88   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
  89   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
  90   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
  91   call void @foo()
  92   ret void
  93 ; CHECK: entry:
  94 ; CHECK: %[[SETJMP_TABLE:.*]] = call i32* @saveSetjmp(
  95
  96 ; CHECK: entry.split:
  97 ; CHECK: @__invoke_void(void ()* @foo)
  98
  99 ; CHECK: entry.split.split:
 100 ; CHECK-NEXT: %[[BUF:.*]] = bitcast i32* %[[SETJMP_TABLE]] to i8*
 101 ; CHECK-NEXT: tail call void @free(i8* %[[BUF]])
 102 ; CHECK-NEXT: ret void
 103 }
 104
 105 ; Test a case where a function has a setjmp call but no other calls that can
 106 ; longjmp. We don't need to do any transformation in this case.
 107 define void @setjmp_only(i8* %ptr) {
 108 ; CHECK-LABEL: @setjmp_only
 109 entry:
 110   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
 111   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
 112   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
 113   ; free cannot longjmp
 114   call void @free(i8* %ptr)
 115   ret void
 116 ; CHECK-NOT: @malloc
 117 ; CHECK-NOT: %setjmpTable
 118 ; CHECK-NOT: @saveSetjmp
 119 ; CHECK-NOT: @testSetjmp
 120 }
 121
 122 ; Test SSA validity
 123 define void @ssa(i32 %n) {
 124 ; CHECK-LABEL: @ssa
 125 entry:
 126   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
 127   %cmp = icmp sgt i32 %n, 5
 128   br i1 %cmp, label %if.then, label %if.end
 129 ; CHECK: entry:
 130 ; CHECK: %[[SETJMP_TABLE0:.*]] = bitcast i8*
 131 ; CHECK: %[[SETJMP_TABLE_SIZE0:.*]] = add i32 4, 0
 132
 133 if.then:                                          ; preds = %entry
 134   %0 = load i32, i32* @global_var, align 4
 135   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
 136   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
 137   store i32 %0, i32* @global_var, align 4
 138   br label %if.end
 139 ; CHECK: if.then:
 140 ; CHECK: %[[VAR0:.*]] = load i32, i32* @global_var, align 4
 141 ; CHECK: %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp(
 142 ; CHECK-NEXT: %[[SETJMP_TABLE_SIZE1:.*]] = call i32 @getTempRet0()
 143
 144 ; CHECK: if.then.split:
 145 ; CHECK: %[[VAR1:.*]] = phi i32 [ %[[VAR0]], %if.then ], [ %[[VAR2:.*]], %if.end3 ]
 146 ; CHECK: %[[SETJMP_TABLE_SIZE2:.*]] = phi i32 [ %[[SETJMP_TABLE_SIZE1]], %if.then ], [ %[[SETJMP_TABLE_SIZE3:.*]], %if.end3 ]
 147 ; CHECK: %[[SETJMP_TABLE2:.*]] = phi i32* [ %[[SETJMP_TABLE1]], %if.then ], [ %[[SETJMP_TABLE3:.*]], %if.end3 ]
 148 ; CHECK: store i32 %[[VAR1]], i32* @global_var, align 4
 149
 150 if.end:                                           ; preds = %if.then, %entry
 151   %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
 152   call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 5) #1
 153   unreachable
 154 ; CHECK: if.end:
 155 ; CHECK: %[[VAR2]] = phi i32 [ %[[VAR1]], %if.then.split ], [ undef, %entry ]
 156 ; CHECK: %[[SETJMP_TABLE_SIZE3]] = phi i32 [ %[[SETJMP_TABLE_SIZE2]], %if.then.split ], [ %[[SETJMP_TABLE_SIZE0]], %entry ]
 157 ; CHECK: %[[SETJMP_TABLE3]] = phi i32* [ %[[SETJMP_TABLE2]], %if.then.split ], [ %[[SETJMP_TABLE0]], %entry ]
 158 }
 159
 160 ; Test a case when a function only calls other functions that are neither setjmp nor longjmp
 161 define void @other_func_only() {
 162 ; CHECK-LABEL: @other_func_only
 163 entry:
 164   call void @foo()
 165   ret void
 166 ; CHECK: call void @foo()
 167 }
 168
 169 ; Test inline asm handling
 170 define void @inline_asm() {
 171 ; CHECK-LABEL: @inline_asm
 172 entry:
 173   %env = alloca [1 x %struct.__jmp_buf_tag], align 16
 174   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %env, i32 0, i32 0
 175   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #4
 176 ; Inline assembly should not generate __invoke wrappers.
 177 ; Doing so would fail as inline assembly cannot be passed as a function pointer.
 178 ; CHECK: call void asm sideeffect "", ""()
 179 ; CHECK-NOT: __invoke_void
 180   call void asm sideeffect "", ""()
 181   ret void
 182 }
 183
 184 ; Test that the allocsize attribute is being transformed properly
 185 declare i8 *@allocator(i32, %struct.__jmp_buf_tag*) #3
 186 define i8 *@allocsize() {
 187 ; CHECK-LABEL: @allocsize
 188 entry:
 189   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
 190   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
 191   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
 192 ; CHECK: call cc{{.*}} i8* @"__invoke_i8*_i32_%struct.__jmp_buf_tag*"([[ARGS:.*]]) #[[ALLOCSIZE_ATTR:[0-9]+]]
 193   %alloc = call i8* @allocator(i32 20, %struct.__jmp_buf_tag* %arraydecay) #3
 194   ret i8 *%alloc
 195 }
 196
 197 ; Test a case when a function only calls longjmp and not setjmp
 198 @buffer = global [1 x %struct.__jmp_buf_tag] zeroinitializer, align 16
 199 define void @longjmp_only() {
 200 ; CHECK-LABEL: @longjmp_only
 201 entry:
 202   ; CHECK: call void @emscripten_longjmp
 203   call void @longjmp(%struct.__jmp_buf_tag* getelementptr inbounds ([1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* @buffer, i32 0, i32 0), i32 1) #1
 204   unreachable
 205 }
 206
 207 ; Tests if SSA rewrite works when a use and its def are within the same BB.
 208 define void @ssa_rewite_in_same_bb() {
 209 ; CHECK-LABEL: @ssa_rewite_in_same_bb
 210 entry:
 211   call void @foo()
 212   br label %for.cond
 213
 214 for.cond:                                         ; preds = %for.inc, %entry
 215   ; CHECK: %{{.*}} = phi i32 [ %var[[VARNO:.*]], %for.inc.split ]
 216   %0 = phi i32 [ %var, %for.inc ], [ undef, %entry ]
 217   %var = add i32 0, 0
 218   br label %for.inc
 219
 220 for.inc:                                          ; preds = %for.cond
 221   %call5 = call i32 @setjmp(%struct.__jmp_buf_tag* undef) #0
 222   br label %for.cond
 223
 224 ; CHECK: for.inc.split:
 225   ; CHECK: %var[[VARNO]] = phi i32 [ %var, %for.inc ]
 226 }
 227
 228 ; Tests cases where longjmp function pointer is used in other ways than direct
 229 ; calls. longjmps should be replaced with
 230 ; (int(*)(jmp_buf*, int))emscripten_longjmp.
 231 declare void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* %arg_ptr)
 232 define void @indirect_longjmp() {
 233 ; CHECK-LABEL: @indirect_longjmp
 234 entry:
 235   %local_longjmp_ptr = alloca void (%struct.__jmp_buf_tag*, i32)*, align 4
 236   %buf0 = alloca [1 x %struct.__jmp_buf_tag], align 16
 237   %buf1 = alloca [1 x %struct.__jmp_buf_tag], align 16
 238
 239   ; Store longjmp in a local variable, load it, and call it
 240   store void (%struct.__jmp_buf_tag*, i32)* @longjmp, void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
 241   ; CHECK: store void (%struct.__jmp_buf_tag*, i32)* bitcast (void ([[PTR]], i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*), void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
 242   %longjmp_from_local_ptr = load void (%struct.__jmp_buf_tag*, i32)*, void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
 243   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf0, i32 0, i32 0
 244   call void %longjmp_from_local_ptr(%struct.__jmp_buf_tag* %arraydecay, i32 0)
 245
 246   ; Load longjmp from a global variable and call it
 247   %longjmp_from_global_ptr = load void (%struct.__jmp_buf_tag*, i32)*, void (%struct.__jmp_buf_tag*, i32)** @global_longjmp_ptr, align 4
 248   %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf1, i32 0, i32 0
 249   call void %longjmp_from_global_ptr(%struct.__jmp_buf_tag* %arraydecay1, i32 0)
 250
 251   ; Pass longjmp as a function argument. This is a call but longjmp is not a
 252   ; callee but an argument.
 253   call void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* @longjmp)
 254   ; CHECK: call void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* bitcast (void ([[PTR]], i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*))
 255   ret void
 256 }
 257
 258 ; Function Attrs: nounwind
 259 declare void @foo() #2
 260 ; Function Attrs: returns_twice
 261 declare i32 @setjmp(%struct.__jmp_buf_tag*) #0
 262 ; Function Attrs: noreturn
 263 declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1
 264 declare i32 @__gxx_personality_v0(...)
 265 declare i8* @__cxa_begin_catch(i8*)
 266 declare void @__cxa_end_catch()
 267 declare i8* @malloc(i32)
 268 declare void @free(i8*)
 269
 270 ; JS glue functions and invoke wrappers declaration
 271 ; CHECK-DAG: declare i32 @getTempRet0()
 272 ; CHECK-DAG: declare void @setTempRet0(i32)
 273 ; CHECK-DAG: declare i32* @saveSetjmp(%struct.__jmp_buf_tag*, i32, i32*, i32)
 274 ; CHECK-DAG: declare i32 @testSetjmp([[PTR]], i32*, i32)
 275 ; CHECK-DAG: declare void @emscripten_longjmp([[PTR]], i32)
 276 ; CHECK-DAG: declare void @__invoke_void(void ()*)
 277
 278 attributes #0 = { returns_twice }
 279 attributes #1 = { noreturn }
 280 attributes #2 = { nounwind }
 281 attributes #3 = { allocsize(0) }
 282 ; CHECK-DAG: attributes #{{[0-9]+}} = { nounwind "wasm-import-module"="env" "wasm-import-name"="getTempRet0" }
 283 ; CHECK-DAG: attributes #{{[0-9]+}} = { nounwind "wasm-import-module"="env" "wasm-import-name"="setTempRet0" }
 284 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="__resumeException" }
 285 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="llvm_eh_typeid_for" }
 286 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="__invoke_void" }
 287 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="__cxa_find_matching_catch_2" }
 288 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="saveSetjmp" }
 289 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="testSetjmp" }
 290 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="emscripten_longjmp" }
 291 ; CHECK-DAG: attributes #{{[0-9]+}} = { "wasm-import-module"="env" "wasm-import-name"="__invoke_i8*_i32_%struct.__jmp_buf_tag*" }
 292 ; CHECK-DAG: attributes #[[ALLOCSIZE_ATTR]] = { allocsize(1) }
 293
 294 !llvm.dbg.cu = !{!2}
 295 !llvm.module.flags = !{!0}
 296
 297 !0 = !{i32 2, !"Debug Info Version", i32 3}
 298 !1 = !DIFile(filename: "lower-em-sjlj.c", directory: "test")
 299 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
 300 !3 = distinct !DISubprogram(name: "setjmp_debug_info", unit:!2, file: !1, line: 1)
 301 !4 = !DILocation(line:2, scope: !3)
 302 !5 = !DILocation(line:3, scope: !3)
 303 !6 = !DILocation(line:4, scope: !3)
 304 !7 = !DILocation(line:5, scope: !3)
 305 !8 = !DILocation(line:6, scope: !3)