[WebAssembly] Generate R_WASM_FUNCTION_OFFSET relocs in debuginfo sections

[dschuff]

Summary

Debug info sections need R_WASM_FUNCTION_OFFSET_I32 relocs (with FK_Data_4 fixup kinds) to refer to functions (instead of R_WASM_TABLE_INDEX as is used in data sections). Usually this is done in a convoluted way, with unnamed temp data symbols which target the start of the function, in which case WasmObjectWriter::recordRelocation converts it to use the section symbol instead. However in some cases the function can actually be undefined; in this case the dwarf generator uses the function symbol (a named undefined function symbol) instead. In that case the section-symbol transform doesn't work and we need to generate the correct reloc type a different way. In this change WebAssemblyWasmObjectWriter::getRelocType takes the fixup section type into account to choose the correct reloc type.

Fixes PR50408

[dschuff]

fix diff

[dschuff]

• exclude functions from section-symbolizing

[dschuff]

llvm/lib/MC/WasmObjectWriter.cpp

508

@sbc100 from here, testing with Andy's example I found that we are getting some fixups where SymA has type data (or no type?) but the relocation is clearly intended to be against a function symbol (it has the name of a function and is a R_WASM_FUNCTION_OFFSET reloc). Also the SECTION_OFFSET relocs with target symbols in the .debug_str section are all nameless symbols. I don't really understand yet why either of these are the way they are.

[dschuff]

Add test

[dschuff]

fix diff

[dschuff]

rebase

[dschuff]

@sbc I think this patch functionality (i.e. pass the section to be fixed-up into getRelocType, and make the reloc type be WASM_FUNCTION_OFFSET_I32 if the section is a debuginfo section) gives the reasonable-looking behavior for the object file on the problematic tests.
However the linker seems to be turning into 0xffffff

Here's a complete example using dwarf 4 rather than dwarf 5 since wasm-emscripten-finalize is choking on .debug_addr still:

ds@ancho:/s/emr/emscripten-releases/localtests (main)$ cat PR50408.cc
// Compile with -g
#if MAIN
char a();
template <typename, char b()>
void f() { b(); }
void g() { f<char, a>(); }
#else
char a() { return 'a'; }
#endif
ds@ancho:/s/emr/emscripten-releases/localtests (main)$ /s/emr/install/emscripten/em++ PR50408.cc -DMAIN -c -g -gdwarf-4 -o PR50408.o
ds@ancho:/s/emr/emscripten-releases/localtests (main)$ /s/emr/install/emscripten/em++ PR50408.cc  -c -g -gdwarf-4 -o PR50408_a.o
ds@ancho:/s/emr/emscripten-releases/localtests (main)$ /s/emr/install/emscripten/em++ -g PR50408.o PR50408_a.o -o PR50408.js
ds@ancho:/s/emr/emscripten-releases/localtests (main)$ /s/emr/install/bin/llvm-dwarfdump -debug-info PR50408.o
PR50408.o:      file format WASM

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000080, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x00000084)

<snip>

0x00000061:     DW_TAG_template_value_parameter
                  DW_AT_type    (0x00000079 "char()*")
                  DW_AT_name    ("b")
                  DW_AT_location        (DW_OP_addr 0x0, DW_OP_stack_value)

ds@ancho:/s/emr/emscripten-releases/localtests (main)$ /s/emr/install/bin/llvm-dwarfdump -debug-info PR50408.wasm
PR50408.wasm:   file format WASM

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000080, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x00000084)

<snip>

0x00000061:     DW_TAG_template_value_parameter
                  DW_AT_type    (0x00000079 "char()*")
                  DW_AT_name    ("b")
                  DW_AT_location        (DW_OP_addr 0xffffffff, DW_OP_stack_value)

So maybe the linker isn't properly handling that use of WASM_FUNCTION_OFFSET_I32 when used with a function instead of a section symbo.

[dschuff]

• exclude functions from section-symbolizing
• Add test
• fix up map-file test
• commit random prints
• clean up debug printfs
• remove debuginfo-relocs

[dschuff]

• add asm test

[dschuff]

This is now almost ready, just a couple of issues. Primarily, as the comment on line 510 of WasmObjectWriter.cpp suggests, I don't fully understand how the existing codepath (which uses the section symbol) works. I'm not sure if I should try to understand that more or not. And secondly I figured out a way to test the new behavior (but not the existing one) with a .s file, so I'm not sure whether we should keep the .ll test or not (it would catch any changes in how the dwarf code generates this MC, but I'm not sure we care about that, if the MC code is correct).

[sbc100]

lld/test/wasm/debuginfo-relocs.s

20

Why delete this file? Can we just update the comment instead?

lld/test/wasm/map-file.s

33

Why change this test?

llvm/lib/MC/WasmObjectWriter.cpp

514

Its seem odd that does doesn't break stuff since R_WASM_SECTION_OFFSET_I32 relocations (where SymA is not a function) no longer get SymA converted to a section symbol?

630

Can we use RelEntry.Symbol->isDefined like below? (or at least make them the same?)

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

47

I'm still not sure about the rename of this function. This function seems to return the section in which the symbol being relocated against is defined. Is that the "target" section? Or is the target section the section in which the relocation itself lives?

136

I guess this is fine for now, but would break if we ever have metadata sections that want to refer to the table index of a function?

llvm/test/MC/WebAssembly/debuginfo-relocs.s

1 ↗

(On Diff #359182)

Maybe comment here saying what we are testing? i.e. that we always generate R_WASM_FUNCTION_OFFSET_I32 in debug sections.

I wonder if it would make sense to use a relocation type in the assembly here to make this more explicit: i.e. .int32 bar@OFF? Might make this change more invasive but would be less magical perhaps? I think it would involve a new MCSymbolRefExpr::VariantKind such as VS_BYTE_OFFSET?

39 ↗

(On Diff #359182)

Indentation looks off here

40 ↗

(On Diff #359182)

Remove blank line

[dschuff]

lld/test/wasm/debuginfo-relocs.s

20

This test no longer tests the code it was intended to cover (see https://reviews.llvm.org/D66435) becuase that change is about handling R_WASM_TABLE_INDEX and now this test case generates R_WASM_FUNCTION_OFFSET instead. In fact, I'm not even sure it's possible anymore to get the situation that D66435 is supposed to handle (I at least couldn't think of another way to write a test for it).

lld/test/wasm/map-file.s

33

The .debug_info section on line 40 has the same pattern that's being changed. Previously it generated R_WASM_TABLE_INDEX reloc, and therefore a table section in the linked binary (now there would be no table section). Since the point of this test is to show the link map with all the sections, I decided to go ahead and change the test so that the result would still include a table section.

llvm/lib/MC/WasmObjectWriter.cpp

514

I think the R_WASM_SECTION_OFFSET_I32 relocations are never associated with function symbols, so they always fall into this case. (Whereas the R_WASM_FUNCTION_OFFSET relocs can be either way). This condition could also be written as

if (((Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
     Type == wasm::R_WASM_FUNCTION_OFFSET_I64) &&
    !SymA->isFunction()) ||
    Type == wasm::R_WASM_SECTION_OFFSET_I32) {

and it also seems to work.

630

It seems to pass the tests, although I'm not sure I understand what the difference is. isInSection is implemented as return isDefined() && !isAbsolute(); but I'm not sure whether isAbsolute is relevant here. isInSection seems more intuitive given that the condition it guards goes to actually get the section?

[sbc100]

lld/test/wasm/debuginfo-relocs.s

20

But why not just update the comment? This .s file is still valid right? And it should have the same content (zero) for the debug_info section?

llvm/lib/MC/WasmObjectWriter.cpp

514

I still don't understand. Surely we want to use the section symbol for all relocations of this type not just the !SymA->isFunction() ones?

i.e. Why do we leave SymA alone one when isFunction() returns true? Why not always adjust SymA to be a section symbol?

630

Given that we have the following code below I still think we should be consistent:

// For undefined symbols, use zero
if (!RelEntry.Symbol->isDefined())
  return 0;

All defined functions must have a section .. I think that is just as intuitive (maybe more intuitive).

[dschuff]

• review comments

lld/test/wasm/debuginfo-relocs.s

20

actually no, the content of the debug_info section is now 2 (because it's the offset of bar from the start of the code section, rather than a table index). And the whole point of the test originally was to test lld's behavior on table_index relocations, which it doesn't anymore. So this test doesn't test anything not covered by other tests.

llvm/lib/MC/WasmObjectWriter.cpp

514

We can't use the section symbol for the cases in PR50408 because the function is undefined, and therefore not in any section.
It seems that for every other case the symbol is not actually a function symbol but a data symbol.
In other words, I don't know of any cases where IsFunction() and IsDefined() are both true.
If there were, I think we would have the correct behavior either way, we could just get it via 2 different codepaths. I still don't fulle understand how the section-symbol case ends up using the defined function symbol by the time the object file is written.
Another way this could be written could maybe be

if ((Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
     Type == wasm::R_WASM_FUNCTION_OFFSET_I64 ||
     Type == wasm::R_WASM_SECTION_OFFSET_I32) &&
    SymA->isDefined()) {

That would mean that if SymA were a defined function it would go through the section-symbol codepath instead. That also passes all the tests we have (but as I said, I'm pretty sure our tests don't cover that case).

630

OK yeah, that makes sense given the invariant.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

47

yes, I guess it's a matter of perspective. To me the "fixup section", is the section being fixed up, which this is not. I'm open to other ideas for names though.

136

Yes, it would. I couldn't think of any cases where we'd need that (nor a convenient way to tell the difference in that case, short of having another fixup type?)

llvm/test/MC/WebAssembly/debuginfo-relocs.s

1 ↗

(On Diff #359182)

I added a comment.
That's an interesting idea about the SymbolRefExpr. I guess that would allow assembly code to explicitly select either byte offset or table index relocs. Would it be possible to use it in the compiler though?
One of the weird things I discovered working on this CL is that for the existing case (where it starts with a temp data symbol, and we convert it to use the section symbols) I couldn't think of any way to test that with assembly.

[sbc100]

llvm/lib/MC/WasmObjectWriter.cpp

514

I think I would prefer this since it obvious why undefined symbols can't be replaced with the corresponding section symbol.

lld/test/wasm/debuginfo-relocs.s

-# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
-# RUN: wasm-ld %t.o -o %t.wasm
-# RUN: obj2yaml %t.wasm | FileCheck %s
-
-bar:
-    .functype bar () -> ()
-    end_function
-
-    .globl _start
-_start:
-    .functype _start () -> ()
-    call bar
-    end_function
-
-    .section .debug_info,"",@
-    .int32 bar
-
-# Even though `bar` is live in the final binary it doesn't have a table entry
-# since its not address taken in the code.  In this case any relocations in the
-# debug sections see a address of zero.
-
-# CHECK:         Name:            .debug_info
-# CHECK-NEXT:    Payload:         '00000000'

lld/test/wasm/map-file.s

 _start:
     .functype _start () -> ()
     call bar
     call write_global
     end_function
 
 .section .data.somedata,"",@
 somedata:
-    .int32 123
-.size somedata, 4
+  .int32 bar
+.size somedata, 8
 
 .section .bss.somezeroes,"",@
 somezeroes:
     .int32 0
 .size somezeroes, 4
 
 .section .debug_info,"",@
     .int32 bar
 
 
 #      CHECK:    Addr      Off     Size Out     In      Symbol
 # CHECK-NEXT:       -        8        e TYPE
 # CHECK-NEXT:       -       16        6 FUNCTION
 # CHECK-NEXT:       -       1c        7 TABLE
 # CHECK-NEXT:       -       23        5 MEMORY
 # CHECK-NEXT:       -       28        f GLOBAL
 # CHECK-NEXT:       0        0        0         __stack_pointer
 # CHECK-NEXT:       1        0        0         wasm_global
 # CHECK-NEXT:       -       37       15 EXPORT
-# CHECK-NEXT:       -       4c       2d CODE
-# CHECK-NEXT:       -       4d       10         {{.*}}{{/|\\}}map-file.s.tmp1.o:(bar)
-# CHECK-NEXT:       -       4d       10                 bar
-# CHECK-NEXT:       -       5d        b         {{.*}}{{/|\\}}map-file.s.tmp1.o:(write_global)
-# CHECK-NEXT:       -       5d        b                 write_global
-# CHECK-NEXT:       -       68        f         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
-# CHECK-NEXT:       -       68        f                 _start
-# CHECK-NEXT:       -       79        d DATA
-# CHECK-NEXT:     400       7a        4 .data
-# CHECK-NEXT:     400       80        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
-# CHECK-NEXT:     400       80        4                 somedata
-# CHECK-NEXT:     404       79        4 .bss
-# CHECK-NEXT:     404        0        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.bss.somezeroes)
-# CHECK-NEXT:     404        0        4                 somezeroes
-# CHECK-NEXT:       -       86       12 CUSTOM(.debug_info)
-# CHECK-NEXT:       -       98       50 CUSTOM(name)
+# CHECK-NEXT:       -       4c        9 ELEM
+# CHECK-NEXT:       -       55       2d CODE
+# CHECK-NEXT:       -       56       10         {{.*}}{{/|\\}}map-file.s.tmp1.o:(bar)
+# CHECK-NEXT:       -       56       10                 bar
+# CHECK-NEXT:       -       66        b         {{.*}}{{/|\\}}map-file.s.tmp1.o:(write_global)
+# CHECK-NEXT:       -       66        b                 write_global
+# CHECK-NEXT:       -       71        f         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
+# CHECK-NEXT:       -       71        f                 _start
+# CHECK-NEXT:       -       82       11 DATA
+# CHECK-NEXT:     400       83        8 .data
+# CHECK-NEXT:     400       89        8         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
+# CHECK-NEXT:     400       89        8                 somedata
+# CHECK-NEXT:     408       82        4 .bss
+# CHECK-NEXT:     408        0        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.bss.somezeroes)
+# CHECK-NEXT:     408        0        4                 somezeroes
+# CHECK-NEXT:       -       93       12 CUSTOM(.debug_info)
+# CHECK-NEXT:       -       a5       50 CUSTOM(name)
 
 # RUN: not wasm-ld %t1.o -o /dev/null -Map=/ 2>&1 \
 # RUN:  | FileCheck -check-prefix=FAIL %s
 # FAIL: wasm-ld: error: cannot open map file /

llvm/include/llvm/MC/MCWasmObjectWriter.h

 #define LLVM_MC_MCWASMOBJECTWRITER_H
 
 #include "llvm/MC/MCObjectWriter.h"
 #include <memory>
 
 namespace llvm {
 
 class MCFixup;
+class MCSectionWasm;
 class MCValue;
 class raw_pwrite_stream;
 
 class MCWasmObjectTargetWriter : public MCObjectTargetWriter {
   const unsigned Is64Bit : 1;
   const unsigned IsEmscripten : 1;
 
 protected:
   explicit MCWasmObjectTargetWriter(bool Is64Bit_, bool IsEmscripten);
 
 public:
   virtual ~MCWasmObjectTargetWriter();
 
   Triple::ObjectFormatType getFormat() const override { return Triple::Wasm; }
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::Wasm;
   }
 
   virtual unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
+                                const MCSectionWasm &FixupSection,
                                 bool IsLocRel) const = 0;
 
   /// \name Accessors
   /// @{
   bool is64Bit() const { return Is64Bit; }
   bool isEmscripten() const { return IsEmscripten; }
   /// @}
 };

llvm/lib/MC/WasmObjectWriter.cpp

if (const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr))
         llvm_unreachable("weakref used in reloc not yet implemented");
   }
 
   // Put any constant offset in an addend. Offsets can be negative, and
   // LLVM expects wrapping, in contrast to wasm's immediates which can't
   // be negative and don't wrap.
   FixedValue = 0;
 
-  unsigned Type = TargetObjectWriter->getRelocType(Target, Fixup, IsLocRel);
+  unsigned Type =
+      TargetObjectWriter->getRelocType(Target, Fixup, FixupSection, IsLocRel);
 
   // Absolute offset within a section or a function.
   // Currently only supported for for metadata sections.
   // See: test/MC/WebAssembly/blockaddress.ll
-  if (Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
+  if ((Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
        Type == wasm::R_WASM_FUNCTION_OFFSET_I64 ||
-      Type == wasm::R_WASM_SECTION_OFFSET_I32) {
+       Type == wasm::R_WASM_SECTION_OFFSET_I32) &&
+      !SymA->isFunction()) {
+    // SymA can be a temp data symbol that represents a function (in which case
+    // it needs to be replaced by the section symbol), [XXX and it apparently
+    // later gets changed again to a func symbol?] or it can be a real
+    // function symbol, in which case it can be left as-is.
+
     if (!FixupSection.getKind().isMetadata())
       report_fatal_error("relocations for function or section offsets are "
                          "only supported in metadata sections");
 
     const MCSymbol *SectionSymbol = nullptr;
     const MCSection &SecA = SymA->getSection();
     if (SecA.getKind().isText()) {
       auto SecSymIt = SectionFunctions.find(&SecA);
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   case wasm::R_WASM_TAG_INDEX_LEB:
   case wasm::R_WASM_TABLE_NUMBER_LEB:
     // Provisional value is function/global/tag Wasm index
     assert(WasmIndices.count(RelEntry.Symbol) > 0 && "symbol not found in wasm index space");
     return WasmIndices[RelEntry.Symbol];
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_FUNCTION_OFFSET_I64:
   case wasm::R_WASM_SECTION_OFFSET_I32: {
+    if (!RelEntry.Symbol->isInSection())
+      return 0;
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
     return Section.getSectionOffset() + RelEntry.Addend;
   }
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_LEB64:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB64:

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

 
 namespace {
 class WebAssemblyWasmObjectWriter final : public MCWasmObjectTargetWriter {
 public:
   explicit WebAssemblyWasmObjectWriter(bool Is64Bit, bool IsEmscripten);
 
 private:
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
+                        const MCSectionWasm &FixupSection,
                         bool IsLocRel) const override;
 };
 } // end anonymous namespace
 
 WebAssemblyWasmObjectWriter::WebAssemblyWasmObjectWriter(bool Is64Bit,
                                                          bool IsEmscripten)
     : MCWasmObjectTargetWriter(Is64Bit, IsEmscripten) {}
 
-static const MCSection *getFixupSection(const MCExpr *Expr) {
+static const MCSection *getTargetSection(const MCExpr *Expr) {
   if (auto SyExp = dyn_cast<MCSymbolRefExpr>(Expr)) {
     if (SyExp->getSymbol().isInSection())
       return &SyExp->getSymbol().getSection();
     return nullptr;
   }
 
   if (auto BinOp = dyn_cast<MCBinaryExpr>(Expr)) {
-    auto SectionLHS = getFixupSection(BinOp->getLHS());
-    auto SectionRHS = getFixupSection(BinOp->getRHS());
+    auto SectionLHS = getTargetSection(BinOp->getLHS());
+    auto SectionRHS = getTargetSection(BinOp->getRHS());
     return SectionLHS == SectionRHS ? nullptr : SectionLHS;
   }
 
   if (auto UnOp = dyn_cast<MCUnaryExpr>(Expr))
-    return getFixupSection(UnOp->getSubExpr());
+    return getTargetSection(UnOp->getSubExpr());
 
   return nullptr;
 }
 
-unsigned WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
-                                                   const MCFixup &Fixup,
-                                                   bool IsLocRel) const {
+unsigned WebAssemblyWasmObjectWriter::getRelocType(
+    const MCValue &Target, const MCFixup &Fixup,
+    const MCSectionWasm &FixupSection, bool IsLocRel) const {
   const MCSymbolRefExpr *RefA = Target.getSymA();
   assert(RefA);
   auto& SymA = cast<MCSymbolWasm>(RefA->getSymbol());
 
   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 
   switch (Modifier) {
     case MCSymbolRefExpr::VK_GOT:
if (SymA.isTag())
       return wasm::R_WASM_TAG_INDEX_LEB;
     if (SymA.isTable())
       return wasm::R_WASM_TABLE_NUMBER_LEB;
     return wasm::R_WASM_MEMORY_ADDR_LEB;
   case WebAssembly::fixup_uleb128_i64:
     assert(SymA.isData());
     return wasm::R_WASM_MEMORY_ADDR_LEB64;
   case FK_Data_4:
-    if (SymA.isFunction())
+    if (SymA.isFunction()) {
+      if (FixupSection.getKind().isMetadata())
+        return wasm::R_WASM_FUNCTION_OFFSET_I32;
+      assert(FixupSection.isWasmData());
       return wasm::R_WASM_TABLE_INDEX_I32;
+    }
     if (SymA.isGlobal())
       return wasm::R_WASM_GLOBAL_INDEX_I32;
     if (auto Section = static_cast<const MCSectionWasm *>(
-            getFixupSection(Fixup.getValue()))) {
+            getTargetSection(Fixup.getValue()))) {
       if (Section->getKind().isText())
         return wasm::R_WASM_FUNCTION_OFFSET_I32;
       else if (!Section->isWasmData())
         return wasm::R_WASM_SECTION_OFFSET_I32;
     }
     return IsLocRel ? wasm::R_WASM_MEMORY_ADDR_LOCREL_I32
                     : wasm::R_WASM_MEMORY_ADDR_I32;
   case FK_Data_8:
-    if (SymA.isFunction())
+    if (SymA.isFunction()) {
+      if (FixupSection.getKind().isMetadata())
+        return wasm::R_WASM_FUNCTION_OFFSET_I64;
       return wasm::R_WASM_TABLE_INDEX_I64;
+    }
     if (SymA.isGlobal())
       llvm_unreachable("unimplemented R_WASM_GLOBAL_INDEX_I64");
     if (auto Section = static_cast<const MCSectionWasm *>(
-            getFixupSection(Fixup.getValue()))) {
+            getTargetSection(Fixup.getValue()))) {
       if (Section->getKind().isText())
         return wasm::R_WASM_FUNCTION_OFFSET_I64;
       else if (!Section->isWasmData())
         llvm_unreachable("unimplemented R_WASM_SECTION_OFFSET_I64");
     }
     assert(SymA.isData());
     return wasm::R_WASM_MEMORY_ADDR_I64;
   default:
     llvm_unreachable("unimplemented fixup kind");
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createWebAssemblyWasmObjectWriter(bool Is64Bit, bool IsEmscripten) {
   return std::make_unique<WebAssemblyWasmObjectWriter>(Is64Bit, IsEmscripten);
 }

llvm/test/MC/WebAssembly/debug-template-param.ll

+; RUN: llc -filetype=obj %s -o - | llvm-readobj -r  - | FileCheck %s
+
+; Test for PR50408. Compiled from:
+; char a();
+; template <typename, char b()>
+; void f() { b(); }
+; void g() { f<char, a>(); }
+
+; CHECK: Section (10) .debug_addr
+; CHECK-NEXT:    0x8 R_WASM_FUNCTION_OFFSET_I32 _Z1gv 0
+; CHECK-NEXT:   0xC R_WASM_FUNCTION_OFFSET_I32 _Z1fIcXadL_Z1avEEEvv 0
+; ensure that the reloc type is correct for _Z1av which is undefined
+; CHECK-NEXT:    0x10 R_WASM_FUNCTION_OFFSET_I32 _Z1av 0
+; CHECK-NEXT:  }
+
+; ModuleID = 'PR50408.cc'
+source_filename = "PR50408.cc"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1"
+target triple = "wasm32-unknown-emscripten"
+
+$_Z1fIcXadL_Z1avEEEvv = comdat any
+
+; Function Attrs: noinline optnone mustprogress
+define hidden void @_Z1gv() #0 !dbg !7 {
+entry:
+  call void @_Z1fIcXadL_Z1avEEEvv(), !dbg !10
+  ret void, !dbg !11
+}
+
+; Function Attrs: noinline optnone mustprogress
+define linkonce_odr hidden void @_Z1fIcXadL_Z1avEEEvv() #0 comdat !dbg !12 {
+entry:
+  %call = call signext i8 @_Z1av(), !dbg !20
+  ret void, !dbg !21
+}
+
+declare signext i8 @_Z1av() #1
+
+attributes #0 = { noinline optnone mustprogress "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="generic" }
+attributes #1 = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="generic" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 13.0.0 (https://github.com/llvm/llvm-project.git 5027637fa1d409e3ca78dab60dc2e2db6c62c175)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "PR50408.cc", directory: "/s/emr/emscripten-releases/localtests", checksumkind: CSK_MD5, checksum: "285a5682ae46dbbe90ccfb84cdef66c7")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 5}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 13.0.0 (https://github.com/llvm/llvm-project.git 5027637fa1d409e3ca78dab60dc2e2db6c62c175)"}
+!7 = distinct !DISubprogram(name: "g", linkageName: "_Z1gv", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !DILocation(line: 5, column: 12, scope: !7)
+!11 = !DILocation(line: 5, column: 26, scope: !7)
+!12 = distinct !DISubprogram(name: "f<char, &a>", linkageName: "_Z1fIcXadL_Z1avEEEvv", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, templateParams: !13, retainedNodes: !2)
+!13 = !{!14, !16}
+!14 = !DITemplateTypeParameter(type: !15)
+!15 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!16 = !DITemplateValueParameter(name: "b", type: !17, value: i8 ()* @_Z1av)
+!17 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !18, size: 32)
+!18 = !DISubroutineType(types: !19)
+!19 = !{!15}
+!20 = !DILocation(line: 4, column: 12, scope: !12)
+!21 = !DILocation(line: 4, column: 17, scope: !12)