Add PNaClSjLjEH pass to implement C++ exception handling using setjmp()+longjmp()

There are two parts to this:

 * PNaClSjLjEH.cpp expands out the "invoke", "landingpad" and "resume"
   instructions, modifying the control flow to use setjmp().

 * ExceptionInfoWriter.cpp lowers landingpads' clause lists to data
   that PNaCl's C++ runtime library will interpret.  This part will be
   reused when we drop the SjLj part and create a stable ABI for
   zero-cost EH.

This pass isn't enabled in PNaClABISimplify yet: I'll do that in a
separate change.

BUG=https://code.google.com/p/nativeclient/issues/detail?id=3696
TEST=*.ll tests (also tested end-to-end: plumbing for this will follow later)

Review URL: https://codereview.chromium.org/24777002

2 files changed, 255 insertions, 0 deletions

diff --git a/test/Transforms/NaCl/pnacl-eh-exception-info.ll b/test/Transforms/NaCl/pnacl-eh-exception-info.ll
new file mode 100644
index 0000000000..a330f6f5ac
--- /dev/null
+++ b/test/Transforms/NaCl/pnacl-eh-exception-info.ll
@@ -0,0 +1,128 @@
+; RUN: opt %s -pnacl-sjlj-eh -S | FileCheck %s
+
+; Example std::type_info objects.
+@exc_typeid1 = external global i8
+@exc_typeid2 = external global i8
+@exc_typeid3 = external global i8
+
+; This must be declared for "-pnacl-sjlj-eh" to work.
+@__pnacl_eh_stack = external thread_local global i8*
+
+declare i32 @llvm.eh.typeid.for(i8*)
+
+declare void @external_func()
+
+
+@__pnacl_eh_type_table = external global i8*
+@__pnacl_eh_action_table = external global i8*
+@__pnacl_eh_filter_table = external global i8*
+
+; CHECK: %action_table_entry = type { i32, i32 }
+
+; CHECK: @__pnacl_eh_type_table = internal constant [4 x i8*] [i8* @exc_typeid1, i8* @exc_typeid2, i8* @exc_typeid3, i8* null]
+
+; CHECK: @__pnacl_eh_action_table = internal constant [6 x %action_table_entry] [%action_table_entry { i32 2, i32 0 }, %action_table_entry { i32 1, i32 1 }, %action_table_entry { i32 0, i32 2 }, %action_table_entry { i32 -1, i32 0 }, %action_table_entry { i32 -2, i32 0 }, %action_table_entry { i32 3, i32 0 }]
+
+; CHECK: @__pnacl_eh_filter_table = internal constant [5 x i32] [i32 -1, i32 1, i32 2, i32 0, i32 -1]
+
+
+; Exception type pointers are allocated IDs which specify the index
+; into __pnacl_eh_type_table where the type may be found.
+define void @test_eh_typeid(i32 %arg) {
+  %id1 = call i32 @llvm.eh.typeid.for(i8* @exc_typeid1)
+  %id2 = call i32 @llvm.eh.typeid.for(i8* @exc_typeid2)
+  %id3 = call i32 @llvm.eh.typeid.for(i8* @exc_typeid3)
+  %cmp1 = icmp eq i32 %arg, %id1
+  %cmp2 = icmp eq i32 %arg, %id2
+  %cmp3 = icmp eq i32 %arg, %id3
+  ret void
+}
+; CHECK: define void @test_eh_typeid
+; CHECK-NEXT: %cmp1 = icmp eq i32 %arg, 0
+; CHECK-NEXT: %cmp2 = icmp eq i32 %arg, 1
+; CHECK-NEXT: %cmp3 = icmp eq i32 %arg, 2
+; CHECK-NEXT: ret void
+
+
+define void @test_single_catch_clause() {
+  invoke void @external_func() to label %cont unwind label %lpad
+cont:
+  ret void
+lpad:
+  landingpad i32 personality i8* null
+      catch i8* @exc_typeid3
+  ret void
+}
+; CHECK: define void @test_single_catch_clause
+; CHECK: store i32 1, i32* %exc_info_ptr
+
+
+define void @test_multiple_catch_clauses() {
+  invoke void @external_func() to label %cont unwind label %lpad
+cont:
+  ret void
+lpad:
+  landingpad i32 personality i8* null
+      catch i8* @exc_typeid1
+      catch i8* @exc_typeid2
+      catch i8* @exc_typeid3
+  ret void
+}
+; CHECK: define void @test_multiple_catch_clauses
+; CHECK: store i32 3, i32* %exc_info_ptr
+
+
+define void @test_empty_filter_clause() {
+  invoke void @external_func() to label %cont unwind label %lpad
+cont:
+  ret void
+lpad:
+  landingpad i32 personality i8* null
+      filter [0 x i8*] []
+  ret void
+}
+; CHECK: define void @test_empty_filter_clause
+; CHECK: store i32 4, i32* %exc_info_ptr
+
+
+define void @test_filter_clause() {
+  invoke void @external_func() to label %cont unwind label %lpad
+cont:
+  ret void
+lpad:
+  landingpad i32 personality i8* null
+      filter [3 x i8*] [i8* @exc_typeid2,
+                        i8* @exc_typeid3,
+                        i8* @exc_typeid1]
+  ret void
+}
+; CHECK: define void @test_filter_clause
+; CHECK: store i32 5, i32* %exc_info_ptr
+
+
+; "catch i8* null" means that any C++ exception matches.
+define void @test_catch_all_clause() {
+  invoke void @external_func() to label %cont unwind label %lpad
+cont:
+  ret void
+lpad:
+  landingpad i32 personality i8* null
+      catch i8* null
+  ret void
+}
+; CHECK: define void @test_catch_all_clause
+; CHECK: store i32 6, i32* %exc_info_ptr
+
+
+; "cleanup" is treated the same as "catch i8* null".
+define void @test_cleanup_clause() {
+  invoke void @external_func() to label %cont unwind label %lpad
+cont:
+  ret void
+lpad:
+  landingpad i32 personality i8* null
+      cleanup
+  ret void
+}
+; CHECK: define void @test_cleanup_clause
+; CHECK: store i32 6, i32* %exc_info_ptr
diff --git a/test/Transforms/NaCl/pnacl-sjlj-eh.ll b/test/Transforms/NaCl/pnacl-sjlj-eh.ll
new file mode 100644
index 0000000000..3783b08a5e
--- /dev/null
+++ b/test/Transforms/NaCl/pnacl-sjlj-eh.ll
@@ -0,0 +1,127 @@
+; RUN: opt %s -pnacl-sjlj-eh -S | FileCheck %s
+
+; This must be declared for expanding "invoke" and "landingpad" instructions.
+@__pnacl_eh_stack = external thread_local global i8*
+
+; This must be declared for expanding "resume" instructions.
+declare void @__pnacl_eh_resume(i32* %exception)
+
+declare i32 @external_func(i64 %arg)
+
+
+; CHECK: %ExceptionFrame = type { [1024 x i8], %ExceptionFrame*, i32 }
+
+define i32 @invoke_test(i64 %arg) {
+  %result = invoke i32 @external_func(i64 %arg)
+      to label %cont unwind label %lpad
+cont:
+  ret i32 %result
+lpad:
+  %lp = landingpad { i8*, i32 } personality i8* null cleanup
+  ret i32 999
+}
+; CHECK: define i32 @invoke_test
+; CHECK-NEXT: %invoke_frame = alloca %ExceptionFrame, align 8
+; CHECK-NEXT: %exc_info_ptr = getelementptr %ExceptionFrame* %invoke_frame, i32 0, i32 2
+; CHECK-NEXT: %invoke_next = getelementptr %ExceptionFrame* %invoke_frame, i32 0, i32 1
+; CHECK-NEXT: %invoke_jmp_buf = getelementptr %ExceptionFrame* %invoke_frame, i32 0, i32 0, i32 0
+; CHECK-NEXT: %pnacl_eh_stack = bitcast i8** @__pnacl_eh_stack to %ExceptionFrame**
+; CHECK-NEXT: %invoke_sj = call i32 @llvm.nacl.setjmp(i8* %invoke_jmp_buf)
+; CHECK-NEXT: %invoke_sj_is_zero = icmp eq i32 %invoke_sj, 0
+; CHECK-NEXT: br i1 %invoke_sj_is_zero, label %invoke_do_call, label %lpad
+; CHECK: invoke_do_call:
+; CHECK-NEXT: %old_eh_stack = load %ExceptionFrame** %pnacl_eh_stack
+; CHECK-NEXT: store %ExceptionFrame* %old_eh_stack, %ExceptionFrame** %invoke_next
+; CHECK-NEXT: store i32 {{[0-9]+}}, i32* %exc_info_ptr
+; CHECK-NEXT: store %ExceptionFrame* %invoke_frame, %ExceptionFrame** %pnacl_eh_stack
+; CHECK-NEXT: %result = call i32 @external_func(i64 %arg)
+; CHECK-NEXT: store %ExceptionFrame* %old_eh_stack, %ExceptionFrame** %pnacl_eh_stack
+; CHECK-NEXT: br label %cont
+; CHECK: cont:
+; CHECK-NEXT: ret i32 %result
+; CHECK: lpad:
+; CHECK-NEXT: %landingpad_ptr = bitcast i8* %invoke_jmp_buf to { i8*, i32 }*
+; CHECK-NEXT: %lp = load { i8*, i32 }* %landingpad_ptr
+; CHECK-NEXT: ret i32 999
+
+
+; A landingpad block may be used by multiple "invoke" instructions.
+define i32 @shared_landingpad(i64 %arg) {
+  %result1 = invoke i32 @external_func(i64 %arg)
+      to label %cont1 unwind label %lpad
+cont1:
+  %result2 = invoke i32 @external_func(i64 %arg)
+      to label %cont2 unwind label %lpad
+cont2:
+  ret i32 %result2
+lpad:
+  %lp = landingpad { i8*, i32 } personality i8* null cleanup
+  ret i32 999
+}
+; CHECK: define i32 @shared_landingpad
+; CHECK: br i1 %invoke_sj_is_zero, label %invoke_do_call, label %lpad
+; CHECK: br i1 %invoke_sj_is_zero2, label %invoke_do_call3, label %lpad
+
+
+; Check that the pass can handle a landingpad appearing before an invoke.
+define i32 @landingpad_before_invoke() {
+  ret i32 123
+
+dead_block:
+  %lp = landingpad i32 personality i8* null cleanup
+  ret i32 %lp
+}
+; CHECK: define i32 @landingpad_before_invoke
+; CHECK: %lp = load i32* %landingpad_ptr
+
+
+; Test the expansion of the "resume" instruction.
+define void @test_resume({ i8*, i32 } %arg) {
+  resume { i8*, i32 } %arg
+}
+; CHECK: define void @test_resume
+; CHECK-NEXT: %resume_exc = extractvalue { i8*, i32 } %arg, 0
+; CHECK-NEXT: %resume_cast = bitcast i8* %resume_exc to i32*
+; CHECK-NEXT: call void @__pnacl_eh_resume(i32* %resume_cast)
+; CHECK-NEXT: unreachable
+
+
+; Check that call attributes are preserved.
+define i32 @call_attrs(i64 %arg) {
+  %result = invoke fastcc i32 @external_func(i64 inreg %arg) noreturn
+      to label %cont unwind label %lpad
+cont:
+  ret i32 %result
+lpad:
+  %lp = landingpad { i8*, i32 } personality i8* null cleanup
+  ret i32 999
+}
+; CHECK: define i32 @call_attrs
+; CHECK: %result = call fastcc i32 @external_func(i64 inreg %arg) [[NORETURN:#[0-9]+]]
+
+
+; Check that any PHI nodes referring to the result of an "invoke" are
+; updated to refer to the correct basic block.
+define i32 @invoke_with_phi_nodes(i64 %arg) {
+entry:
+  %result = invoke i32 @external_func(i64 %arg)
+      to label %cont unwind label %lpad
+cont:
+  %cont_phi = phi i32 [ 100, %entry ]
+  ret i32 %cont_phi
+lpad:
+  %lpad_phi = phi i32 [ 200, %entry ]
+  %lp = landingpad { i8*, i32 } personality i8* null cleanup
+  ret i32 %lpad_phi
+}
+; CHECK: define i32 @invoke_with_phi_nodes
+; CHECK: %result = call i32 @external_func(i64 %arg)
+; CHECK: cont:
+; CHECK-NEXT: %cont_phi = phi i32 [ 100, %invoke_do_call ]
+; CHECK-NEXT: ret i32 %cont_phi
+; CHECK: lpad:
+; CHECK-NEXT: %lpad_phi = phi i32 [ 200, %entry ]
+; CHECK: ret i32 %lpad_phi
+
+
+; CHECK: attributes [[NORETURN]] = { noreturn }