[WebAssembly] Use dummy debug info in Emscripten SjLj

[aheejin]

Summary

D74269 added debug info to newly created instructions, including calls
to malloc and free, by taking debug info from existing instructions
around, whose debug info may or may not be empty.

But there are cases debug info is required by the IR verifier: when both
the caller and the callee functions have DISubprograms, meaning we
already have declarations to malloc or free with a DISubprogram
attached, newly created calls to malloc and free should have
non-empty debug info. This patch creates a non-empty dummy debug info in
this case to those calls to make the IR verifier pass.

Fixes https://bugs.llvm.org/show_bug.cgi?id=45461.

[aheejin]

Small fix

[aheejin]

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

10

This function was just moved from lower-em-sjlj.ll.

[dschuff]

It just occurred to me, could we just mark the calls as non-inlineable? I assume we won't be running the inliner after this anyway. Or is that a property of the called function and not the callsite?
Anyway this approach seems ok to me too. It seems to me that there are other places we inject calls to runtime functions too; but I guess the others are mostly to imported functions and don't have this problem?

[aheejin]

In D77784#1972330, @dschuff wrote:

It just occurred to me, could we just mark the calls as non-inlineable? I assume we won't be running the inliner after this anyway. Or is that a property of the called function and not the callsite?

As you can see here, even if the error message says "inlinable call site blah blah", the condition being checked is not something about properties of the call instruction or callsite; it only checks three things:

• Is there a called function? (Not sure when this can be false though)
• Is the current caller function has a DISubprogram?
• Is the callee function has a DISubprogram?

So the reason it was OK so far after D74269 was, even though the caller had a DISubprogram, the callees (malloc and free) didn't have one. But it turned out there can be cases in which declarations of malloc and free can have DISubprogram too. So it is not possible to make this function non-inlinable, because the conditions don't really check them anyway.

Anyway this approach seems ok to me too. It seems to me that there are other places we inject calls to runtime functions too; but I guess the others are mostly to imported functions and don't have this problem?

Yes, all other functions we inject calls to in this pass are imported.

[dschuff]

LGTM
(I'll bet Call.getCalledFunction() returns nullptr if it's an indirect call)

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 ///    can't translate an int value to a jmp_buf.)
 ///    Label -1 means no longjmp occurred. Otherwise we jump to the right
 ///    post-setjmp BB based on the label.
 ///
 ///===----------------------------------------------------------------------===//
 
 #include "WebAssembly.h"
 #include "llvm/IR/CallSite.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/SSAUpdater.h"
 
 using namespace llvm;
 
bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
 
   // Erase everything we no longer need in this function
   for (Instruction *I : ToErase)
     I->eraseFromParent();
 
   return Changed;
 }
 
+// This tries to get debug info from the instruction before which a new
+// instruction will be inserted, and if there's no debug info in that
+// instruction, tries to get the info instead from the previous instruction (if
+// any). If none of these has debug info and a DISubprogram is provided, it
+// creates a dummy debug info with line 1 and col 1, because IR verifier
+// requires all inlinable callsites should have debug info when both a caller
+// and callee have DISubprogram. If none of these conditions are met, returns
+// empty info.
+static DebugLoc getOrCreateDebugLoc(const Instruction *InsertBefore,
+                                    DISubprogram *SP) {
+  assert(InsertBefore);
+  if (InsertBefore->getDebugLoc())
+    return InsertBefore->getDebugLoc();
+  const Instruction *Prev = InsertBefore->getPrevNode();
+  if (Prev && Prev->getDebugLoc())
+    return Prev->getDebugLoc();
+  if (SP)
+    return DILocation::get(SP->getContext(), 1, 1, SP);
+  return DebugLoc();
+}
+
 bool WebAssemblyLowerEmscriptenEHSjLj::runSjLjOnFunction(Function &F) {
   Module &M = *F.getParent();
   LLVMContext &C = F.getContext();
   IRBuilder<> IRB(C);
   SmallVector<Instruction *, 64> ToErase;
   // Vector of %setjmpTable values
   std::vector<Instruction *> SetjmpTableInsts;
   // Vector of %setjmpTableSize values
   std::vector<Instruction *> SetjmpTableSizeInsts;
 
   // Setjmp preparation
 
   // This instruction effectively means %setjmpTableSize = 4.
   // We create this as an instruction intentionally, and we don't want to fold
   // this instruction to a constant 4, because this value will be used in
   // SSAUpdater.AddAvailableValue(...) later.
   BasicBlock &EntryBB = F.getEntryBlock();
-  DebugLoc FirstDL = EntryBB.begin()->getDebugLoc();
+  DebugLoc FirstDL = getOrCreateDebugLoc(&*EntryBB.begin(), F.getSubprogram());
   BinaryOperator *SetjmpTableSize = BinaryOperator::Create(
       Instruction::Add, IRB.getInt32(4), IRB.getInt32(0), "setjmpTableSize",
       &*EntryBB.getFirstInsertionPt());
   SetjmpTableSize->setDebugLoc(FirstDL);
   // setjmpTable = (int *) malloc(40);
   Instruction *SetjmpTable = CallInst::CreateMalloc(
       SetjmpTableSize, IRB.getInt32Ty(), IRB.getInt32Ty(), IRB.getInt32(40),
       nullptr, nullptr, "setjmpTable");
bool WebAssemblyLowerEmscriptenEHSjLj::runSjLjOnFunction(Function &F) {
   // Erase everything we no longer need in this function
   for (Instruction *I : ToErase)
     I->eraseFromParent();
 
   // Free setjmpTable buffer before each return instruction
   for (BasicBlock &BB : F) {
     Instruction *TI = BB.getTerminator();
     if (isa<ReturnInst>(TI)) {
+      DebugLoc DL = getOrCreateDebugLoc(TI, F.getSubprogram());
       auto *Free = CallInst::CreateFree(SetjmpTable, TI);
-      Free->setDebugLoc(TI->getDebugLoc());
+      Free->setDebugLoc(DL);
       // CallInst::CreateFree may create a bitcast instruction if its argument
       // types mismatch. We need to set the debug loc for the bitcast too.
       if (auto *FreeCallI = dyn_cast<CallInst>(Free)) {
         if (auto *BitCastI = dyn_cast<BitCastInst>(FreeCallI->getArgOperand(0)))
-          BitCastI->setDebugLoc(TI->getDebugLoc());
+          BitCastI->setDebugLoc(DL);
       }
     }
   }
 
   // Every call to saveSetjmp can change setjmpTable and setjmpTableSize
   // (when buffer reallocation occurs)
   // entry:
   //   setjmpTableSize = 4;

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

+; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
+
+; Basic debug info test. All existing instructions have debug info and inserted
+; 'malloc' and 'free' calls take debug info from the next instruction.
+define void @setjmp_debug_info0() !dbg !3 {
+; CHECK-LABEL: @setjmp_debug_info0
+entry:
+  %buf = alloca [1 x %struct.__jmp_buf_tag], align 16, !dbg !4
+  %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0, !dbg !5
+  %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0, !dbg !6
+  call void @foo(), !dbg !7
+  ret void, !dbg !8
+; CHECK: entry:
+  ; CHECK-NEXT: call i8* @malloc(i32 40), !dbg ![[DL0:.*]]
+  ; CHECK-NEXT: bitcast {{.*}}, !dbg ![[DL0]]
+  ; CHECK: alloca {{.*}}, !dbg ![[DL0]]
+  ; CHECK: call i32* @saveSetjmp{{.*}}, !dbg ![[DL1:.*]]
+  ; CHECK-NEXT: call i32 @getTempRet0{{.*}}, !dbg ![[DL1]]
+  ; CHECK-NEXT: br {{.*}}, !dbg ![[DL2:.*]]
+
+; CHECK: entry.split:
+  ; CHECK: call {{.*}} void @__invoke_void{{.*}}, !dbg ![[DL2]]
+
+; CHECK: entry.split.split:
+  ; CHECK-NEXT: bitcast {{.*}}, !dbg ![[DL3:.*]]
+  ; CHECK-NEXT: call void @free{{.*}}, !dbg ![[DL3]]
+
+; CHECK: if.then1:
+  ; CHECK: call i32 @testSetjmp{{.*}}, !dbg ![[DL2]]
+
+; CHECK: if.end:
+  ; CHECK: call i32 @getTempRet0{{.*}}, !dbg ![[DL2]]
+
+; CHECK: if.then2:
+  ; CHECK: call void @emscripten_longjmp{{.*}}, !dbg ![[DL2]]
+
+; CHECK: if.end2:
+  ; CHECK: call void @setTempRet0{{.*}}, !dbg ![[DL2]]
+}
+
+; No instruction has debug info but the current function (setjmp_debug_info2)
+; and the called function (malloc / free) have DISubprograms, so the newly
+; generated calls should have debug info attached. We don't have an instruction
+; to take debug info from, so we create dummy debug info.
+define void @setjmp_debug_info1() !dbg !9 {
+; CHECK-LABEL: @setjmp_debug_info1
+entry:
+  %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
+  %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
+  %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
+  call void @foo()
+  ret void
+  ; CHECK: call i8* @malloc(i32 40), !dbg ![[DL_DUMMY:.*]]
+  ; CHECK: call void @free{{.*}}, !dbg ![[DL_DUMMY]]
+}
+
+; Note that these functions have DISubprograms.
+declare !dbg !10 i8* @malloc(i32)
+declare !dbg !11 void @free(i8*)
+
+declare void @foo()
+; Function Attrs: returns_twice
+declare i32 @setjmp(%struct.__jmp_buf_tag*) #0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!0}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = !DIFile(filename: "lower-em-sjlj.c", directory: "test")
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
+!3 = distinct !DISubprogram(name: "setjmp_debug_info0", unit:!2, file: !1, line: 1)
+!4 = !DILocation(line:2, scope: !3)
+!5 = !DILocation(line:3, scope: !3)
+!6 = !DILocation(line:4, scope: !3)
+!7 = !DILocation(line:5, scope: !3)
+!8 = !DILocation(line:6, scope: !3)
+!9 = distinct !DISubprogram(name: "setjmp_debug_info1", unit:!2, file: !1, line: 1)
+!10 = !DISubprogram(name: "malloc", file: !1, line: 10, isDefinition: false)
+!11 = !DISubprogram(name: "free", file: !1, line: 20, isDefinition: false)
+
+; Dummy debug info generated
+; CHECK: ![[DL_DUMMY]] = !DILocation(line: 1, column: 1, scope: !9)

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

 for.inc:                                          ; preds = %for.cond
   %call5 = call i32 @setjmp(%struct.__jmp_buf_tag* undef) #0
   br label %for.cond
 
 ; CHECK: for.inc.split:
   ; CHECK: %var[[VARNO]] = phi i32 [ %var, %for.inc ]
 }
 
-; Debug info test
-define void @setjmp_debug_info() !dbg !3 {
-; CHECK-LABEL: @setjmp_debug_info
-entry:
-  %buf = alloca [1 x %struct.__jmp_buf_tag], align 16, !dbg !4
-  %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0, !dbg !5
-  %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0, !dbg !6
-  call void @foo(), !dbg !7
-  ret void, !dbg !8
-; CHECK: entry:
-  ; CHECK-NEXT: call i8* @malloc(i32 40), !dbg ![[DL0:.*]]
-  ; CHECK-NEXT: bitcast {{.*}}, !dbg ![[DL0]]
-  ; CHECK: alloca {{.*}}, !dbg ![[DL0]]
-  ; CHECK: call i32* @saveSetjmp{{.*}}, !dbg ![[DL1:.*]]
-  ; CHECK-NEXT: call i32 @getTempRet0{{.*}}, !dbg ![[DL1]]
-  ; CHECK-NEXT: br {{.*}}, !dbg ![[DL2:.*]]
-
-; CHECK: entry.split:
-  ; CHECK: call {{.*}} void @__invoke_void{{.*}}, !dbg ![[DL2]]
-
-; CHECK: entry.split.split:
-  ; CHECK-NEXT: bitcast {{.*}}, !dbg ![[DL3:.*]]
-  ; CHECK-NEXT: call void @free{{.*}}, !dbg ![[DL3]]
-
-; CHECK: if.then1:
-  ; CHECK: call i32 @testSetjmp{{.*}}, !dbg ![[DL2]]
-
-; CHECK: if.end:
-  ; CHECK: call i32 @getTempRet0{{.*}}, !dbg ![[DL2]]
-
-; CHECK: if.then2:
-  ; CHECK: call void @emscripten_longjmp{{.*}}, !dbg ![[DL2]]
-
-; CHECK: if.end2:
-  ; CHECK: call void @setTempRet0{{.*}}, !dbg ![[DL2]]
-}
-
 declare void @foo()
 ; Function Attrs: returns_twice
 declare i32 @setjmp(%struct.__jmp_buf_tag*) #0
 ; Function Attrs: noreturn
 declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1
 declare i32 @__gxx_personality_v0(...)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()