[WebAssembly] Add DW_OP_WASM_location_int

[aardappel]

Summary

This to allow us to add reloctable global indices as a symbol.
See discussion in https://github.com/WebAssembly/debugging/issues/12

To accomplish this, we add a new DW_OP_WASM_location_int tag (to keep DW_OP_WASM_location unchanged for now for tools that rely on it), and a new R_WASM_GLOBAL_INDEX_I32 relocation type.

As discussed in the issue, the current implementation is a bit of a "hard-coded" version of what DwarfExpression does, with added support for symbols. Weaving this into DwarfExpression itself was deemed to invasive at this stage, but could be a good change in the future if use of this functionality expands. For now it serves our need of a relocatable stack pointer reference, and possibly other globals.

[yurydelendik]

I'm still curious if something like this will work:

diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h
index c4dc53337c0..4bbff49606a 100644
--- a/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h
@@ -44,2 +44,3 @@ public:
       BaseTypeRef = 8,
+      WasmLocationArg = 30,
       SignBit = 0x80,
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
index e9463fd53d9..c51039c66ef 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
@@ -96,3 +96,3 @@ static DescVector getDescriptions() {
   Descriptions[DW_OP_WASM_location] =
-      Desc(Op::Dwarf4, Op::SizeLEB, Op::SignedSizeLEB);
+      Desc(Op::Dwarf4, Op::SizeLEB, Op::WasmLocationArg);
   Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
@@ -172,2 +172,15 @@ bool DWARFExpression::Operation::extract(DataExtractor Data,
       break;
+    case Operation::WasmLocationArg:
+      assert(Operand == 1);
+      switch (Operands.Op[0]) {
+        case 0: case 1: case 2:
+          Operands[Operand] = Data.getULEB128(&Offset);
+          break;
+        case 4: // global as uint32
+          Operands[Operand] = Data.getU32(&Offset);
+          break;
+        default:
+          return false; // Unknown Wasm location
+      }
+      break;
     case Operation::SizeBlock:
@@ -273,2 +286,10 @@ bool DWARFExpression::Operation::print(raw_ostream &OS,
         OS << format(" 0x%02x", Expr->Data.getU8(&Offset));
+    } else if (Size == Operation::WasmLocationArg) {
+      assert(Operand == 1);
+      switch (Operands[0]) {
+        case 0: case 1: case 2:
+        case 4: // global as uint32
+          OS << format(" 0x%" PRIx64, Operands[Operand]);
+        default: assert(false);
+      }
     } else {

[aardappel]

@yurydelendik that would just take care of the encoding, the bigger question would be how to plumb symbol support into DwarfExpression (including the buffering path).

[aardappel]

Fixed dwarfdump (see change to WasmObjectFile).
Fixed int32 value being unsigned (now signed, like existing tag).
Fixed accidental binary file added to patch.

[aardappel]

Added new relocation type: R_WASM_GLOBAL_INDEX_I32

[sbc100]

New relocation type lgtm. I'm surprised there wasn't a need to update any lld tests. Probably means we need to add one that tests DW_AT_frame_base

[aardappel]

Fixed global only used from debug section not getting flags set.
Fixed tests.

[aardappel]

Fixes for LLD

[dschuff]

In D77353#1959964, @aardappel wrote:

@yurydelendik that would just take care of the encoding, the bigger question would be how to plumb symbol support into DwarfExpression (including the buffering path).

Is this just because DwarfExpression doesn't have access to the AsmPrinter?

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

424–454

This should probably at least say which header this value comes from.

[aardappel]

Is this just because DwarfExpression doesn't have access to the AsmPrinter?

It is slightly more complicated, DwarfExpression has two paths, one that directly emits to a DIE structure as it goes, the other that caches into a list (of integers) whose size can be measured before its emitted. The latter is not really set up for metadata, like "this integer is really a symbol". Either way, I am sure it can be done, but it is in shared code, so I was a bit more hesitant to rework that, especially when @yurydelendik says it's outside the scope of this patch :) My conversations with @dblaikie also seemed to indicate it would be a much larger change, only worth it if we were going to have many more complex expressions making use of this functionality. Then again, this patch already grew larger than expected.. I'd say its something we can consider if my "hack" in this patch is needed in at least one more location?

[aardappel]

Updated comment to refer to original header

[aardappel]

If there are no further comments on improvements we can carry out right now, does anyone feel like approving this for merging? :)

[yurydelendik]

If there are no further comments on improvements we can carry out right now, does anyone feel like approving this for merging? :)

The adding of new OP code DW_OP_WASM_location_int seems driven by LLVM implementation detail. I feel that is not necessary. Is it possible to use the alternative encoding suggested above, since we solved plumbing symbol support?

[dschuff]

@yurydelendik is that actually true? Concretely you are proposing that the form of DW_OP_Wasm_location be variadic instead of fixed, right? i.e. it has different fields based on the value of the first field. I don't think there is any precedent for that in DWARF anywhere, is there? e.g. there are different ops for OP_plus and OP_plus_uconst; or OP_call2 and OP_call4 could be just one op with a similar discriminator, but they are not. You could argue that even having OP_Wasm_location as it is (if it didn't need different forms) is inefficient because instead of the discriminator we could just use different ops, and make it smaller.

[aardappel]

@yurydelendik how would you change Descriptions[DW_OP_WASM_location] = Desc(Op::Dwarf4, Op::SizeLEB, Op::SignedSizeLEB); to make it variadic? And there may be further locations that need to support this.
We didn't "solve" plumbing, we circumvented it for the moment :)
When a location is a local, it is still being output with your existing LEB code. So we could make your suggestion happen simply by using DW_OP_WASM_location instead of DW_OP_WASM_location_int.

@dschuff Yes, I could bake the cases of the wasm::TI_ enum into multiple DW_OP_WASM_ tags, be happy to do that as part of this patch. We could then deprecate the existing DW_OP_WASM_location tag. Consumers already need to deal with new tags showing up for globals, might as well do it for locals at the same time then?

[yurydelendik]

In D77353#1972706, @dschuff wrote:

Concretely you are proposing that the form of DW_OP_Wasm_location be variadic instead of fixed, right? i.e. it has different fields based on the value of the first field. I don't think there is any precedent for that in DWARF anywhere, is there?

Closest to variadic args I see is DW_OP_implicit_value. The DWARF sees DW_OP_Wasm_location is an operator by itself (which may have its custom arguments or none). FWIW I was planing to suggest to have something like DW_OP_Wasm_location wasm-local-0, DW_OP_Wasm_location wasm-local-1, .. similar to DWARF's reg0..reg31 to save extra byte.

I argue for this design because the space for the vendor extension is pretty limited (only 32 entries and some are already taken), so we can quickly run out of IDs for DW_OP_Wasm_xxx. I don't see any requirement on amount and kinds of arguments for vendor operators. The limitation on at most 2 arguments with strict types comes from the DWARFExpression.cpp implementation.

[yurydelendik]

In D77353#1972809, @aardappel wrote:

@yurydelendik how would you change Descriptions[DW_OP_WASM_location] = Desc(Op::Dwarf4, Op::SizeLEB, Op::SignedSizeLEB); to make it variadic?

I was hoping to test the code I suggested in the comment above at https://reviews.llvm.org/D77353#1959871 , which changes the above to Descriptions[DW_OP_WASM_location] = Desc(Op::Dwarf4, Op::SizeLEB, Op::WasmLocationArg);. I'll try to test my idea in couple of days.

[aardappel]

So far we only need 2 tags, for locals and globals, and maybe soon a third for stack-relative. I don't see us running out of 32 entries that fast :)

[yurydelendik]

In D77353#1972855, @aardappel wrote:

So far we only need 2 tags, for locals and globals, and maybe soon a third for stack-relative. I don't see us running out of 32 entries that fast :)

Per https://github.com/gcc-mirror/gcc/blob/master/include/dwarf2.def, 22 is already well-known.

Anyway suggested encoding patch can be found at https://gist.github.com/yurydelendik/de99a1f512cca6e685780f07aade416a

[aardappel]

@yurydelendik thanks! that appears to mostly be a merge of this patch and the changes you outlined above?

@dschuff @sbc100 do you prefer this over whats in this patch? (keeping the single WASM dwarf tag in exchange for implementing a variadic argument reader/writer?)

[aardappel]

@paolosev you may have an opinion on this, given that you're already working with this data as well?

[dschuff]

If there really are only 32 codes available for all the user targets, then maybe we should just try to get away with only using one.

Also cc @philip.pfaffe

[paolosev]

In D77353#1978576, @aardappel wrote:

@paolosev you may have an opinion on this, given that you're already working with this data as well?

I also think that if possible we should try to use only one code, since there are only 10 vendor extension codes left (9 if we count our DW_OP_WASM_location).

I am not an expert here, but looking at DW_OP_implicit_value as Yury says, it should be possible to have variable-length arguments (DW_OP_implicit_value expects a ULEB128 size followed by block of that size).

[aardappel]

@dschuff @paolosev thanks for the feedback, seems we have some consensus on going forward with the single variadic tag. I'll merge in Yury's changes.

[aardappel]

@yurydelendik one thing about your patch: the variadic argument was previously declared as SignedSizeLEB and emitted with emitSigned, yet your new code reads it as getULEB128 and stores it in an array of uint64_t (which we can't change since its shared code). It doesn't matter much for the current use case, but we might want to be consistent about this storing signed or unsigned values? I see value in it being signed for future use cases, but given the existing DWARFExpression code it may well have to be unsigned.

[yurydelendik]

In D77353#1987324, @aardappel wrote:

@yurydelendik one thing about your patch: the variadic argument was previously declared as SignedSizeLEB and emitted with emitSigned, yet your new code reads it as getULEB128 and stores it in an array of uint64_t (which we can't change since its shared code). It doesn't matter much for the current use case, but we might want to be consistent about this storing signed or unsigned values? I see value in it being signed for future use cases, but given the existing DWARFExpression code it may well have to be unsigned.

Previously the signed LEB was chosen as universal argument type. For wasm-local, -global, -stack we just need unsigned, so I decided to switch to be unsigned for these location. I have no preference of them be signed/unsigned.

[aardappel]

Changed encoding to use Yury's variadic WasmLocationArg type.

[aardappel]

Ok, will try to make it more consistently unsigned, given that down the line they will be stored as unsigned anyway. But its still messy, given that at least thru one path they arrive as this TargetIndexLocation which is signed.
Made it explicit in the comments for TargetIndex that these are meant to be unsigned.

[aardappel]

Made values more consistently unsigned thru-out.

[sbc100]

New relocation type and handling LGTM.

If one were being meticulous one might land this as three different changes:

1. Rename TargetIndex enum values. NFC.
2. Introduce the new relocation type (albeit with no uses)
3. The actual meat of the change.

Not necessary, I just noticed the logical split.

[aardappel]

@sbc100 I'm a fan of small and focussed commits, but not a fan of new functionality without any uses/tests. Given that this commit is not particularly big, I vote to keep it together.

[dschuff]

LGTM with one nit

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

238–241

I'm not exactly sure what these strings are for, but they should probably be changed to reflect the new naming of the enums?

[aardappel]

updated target index string descriptions

[saugustine]

The comparison on lines 81 and 82 of InputChunks.cpp is always true.

if (rel.Type != R_WASM_GLOBAL_INDEX_LEB ||
    rel.Type != R_WASM_GLOBAL_INDEX_I32) {

This causes build failures:

InputChunks.cpp:81:45: error: overlapping comparisons always evaluate to true [-Werror,-Wtautological-overlap-compare]

[aardappel]

@saugustine thanks, pushed a fix.

The perils of WFH developing with Visual Studio :(

[saugustine]

Appreciate the quick fix. Thanks.

[aardappel]

This has already landed.

lld/test/wasm/debuginfo.test

 
 CHECK: DW_TAG_compile_unit
 CHECK-NEXT:              DW_AT_producer ("clang version 7.0.0 (trunk {{.*}})")
 CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
 CHECK-NEXT:              DW_AT_name ("hi_foo.c")
 
 CHECK:   DW_TAG_variable
 CHECK-NEXT:                DW_AT_name ("y")
-CHECK-NEXT:                DW_AT_type (0x000000a1 "int[2]")
+CHECK-NEXT:                DW_AT_type (0x000000a7 "int[2]")
 CHECK-NEXT:                DW_AT_external (true)
 CHECK-NEXT:                DW_AT_decl_file  ("{{.*}}hi_foo.c")
 CHECK-NEXT:                DW_AT_decl_line  (1)
 CHECK:                     DW_AT_location (DW_OP_addr 0x400)
 
 CHECK:   DW_TAG_array_type
 
 CHECK:     DW_TAG_subrange_type
 
 CHECK:   DW_TAG_base_type
 CHECK-NEXT:                DW_AT_name ("int")
 CHECK-NEXT:                DW_AT_encoding (DW_ATE_signed)
 CHECK-NEXT:                DW_AT_byte_size  (0x04)
 
 CHECK:   DW_TAG_base_type
 CHECK-NEXT:                DW_AT_name ("__ARRAY_SIZE_TYPE__")
 CHECK-NEXT:                DW_AT_byte_size  (0x08)
 CHECK-NEXT:                DW_AT_encoding (DW_ATE_unsigned)
 
 CHECK:   DW_TAG_variable
 CHECK-NEXT:                DW_AT_name ("z")
-CHECK-NEXT:                DW_AT_type (0x000000a1 "int[2]")
+CHECK-NEXT:                DW_AT_type (0x000000a7 "int[2]")
 CHECK-NEXT:                DW_AT_external (true)
 CHECK-NEXT:                DW_AT_decl_file  ("{{.*}}hi_foo.c")
 CHECK-NEXT:                DW_AT_decl_line  (8)
 CHECK-NEXT:                DW_AT_location (DW_OP_addr 0x0)
 
 CHECK:   DW_TAG_subprogram
-CHECK-NEXT:                DW_AT_low_pc 
+CHECK-NEXT:                DW_AT_low_pc
 CHECK-NEXT:                DW_AT_high_pc
 CHECK-NEXT:                DW_AT_frame_base
 CHECK-NEXT:                DW_AT_name ("foo")
 CHECK-NEXT:                DW_AT_decl_file  ("{{.*}}hi_foo.c")
 CHECK-NEXT:                DW_AT_decl_line  (3)
 
 CHECK:     DW_TAG_formal_parameter
 CHECK-NEXT:                  DW_AT_name ("p")
 CHECK-NEXT:                  DW_AT_decl_file  ("{{.*}}hi_foo.c")
 CHECK-NEXT:                  DW_AT_decl_line  (3)
 

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
       existingValue = static_cast<uint32_t>(decodeSLEB128(loc, &bytesRead));
       break;
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_MEMORY_ADDR_I32:
     case R_WASM_FUNCTION_OFFSET_I32:
     case R_WASM_SECTION_OFFSET_I32:
+    case R_WASM_GLOBAL_INDEX_I32:
       existingValue = static_cast<uint32_t>(read32le(loc));
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
 
     if (bytesRead && bytesRead != 5)
       warn("expected LEB at relocation site be 5-byte padded");
 
-    if (rel.Type != R_WASM_GLOBAL_INDEX_LEB) {
+    if (rel.Type != R_WASM_GLOBAL_INDEX_LEB ||
+        rel.Type != R_WASM_GLOBAL_INDEX_I32) {
       uint32_t expectedValue = file->calcExpectedValue(rel);
       if (expectedValue != existingValue)
         warn("unexpected existing value for " + relocTypeToString(rel.Type) +
              ": existing=" + Twine(existingValue) +
              " expected=" + Twine(expectedValue));
     }
   }
 }
for (const WasmRelocation &rel : relocations) {
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
       encodeSLEB128(static_cast<int32_t>(value), loc, 5);
       break;
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_MEMORY_ADDR_I32:
     case R_WASM_FUNCTION_OFFSET_I32:
     case R_WASM_SECTION_OFFSET_I32:
+    case R_WASM_GLOBAL_INDEX_I32:
       write32le(loc, value);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
   }
 }
 

lld/wasm/InputFiles.cpp

return f->getFunctionInputOffset() + f->getFunctionCodeOffset() +
            reloc.Addend;
   }
   case R_WASM_SECTION_OFFSET_I32:
     return reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return reloc.Index;
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
+  case R_WASM_GLOBAL_INDEX_I32:
   case R_WASM_EVENT_INDEX_LEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     return sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
case R_WASM_MEMORY_ADDR_REL_SLEB:
     if (isa<UndefinedData>(sym) || sym->isUndefWeak())
       return 0;
     return cast<DefinedData>(sym)->getVirtualAddress() + reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return typeMap[reloc.Index];
   case R_WASM_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(reloc.Index)->getFunctionIndex();
   case R_WASM_GLOBAL_INDEX_LEB:
+  case R_WASM_GLOBAL_INDEX_I32:
     if (auto gs = dyn_cast<GlobalSymbol>(sym))
       return gs->getGlobalIndex();
     return sym->getGOTIndex();
   case R_WASM_EVENT_INDEX_LEB:
     return getEventSymbol(reloc.Index)->getEventIndex();
   case R_WASM_FUNCTION_OFFSET_I32: {
     auto *f = cast<DefinedFunction>(sym);
     return f->function->outputOffset + f->function->getFunctionCodeOffset() +

lld/wasm/Relocations.cpp

for (const WasmRelocation &reloc : chunk->getRelocations()) {
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
       if (requiresGOTAccess(sym))
         break;
       out.elemSec->addEntry(cast<FunctionSymbol>(sym));
       break;
     case R_WASM_GLOBAL_INDEX_LEB:
+    case R_WASM_GLOBAL_INDEX_I32:
       if (!isa<GlobalSymbol>(sym))
         addGOTEntry(sym);
       break;
     }
 
     if (config->isPic) {
       switch (reloc.Type) {
       case R_WASM_TABLE_INDEX_SLEB:

llvm/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_OP(0xa7, xderef_type, 5, DWARF)
 HANDLE_DW_OP(0xa8, convert, 5, DWARF)
 HANDLE_DW_OP(0xa9, reinterpret, 5, DWARF)
 // Vendor extensions:
 // Extensions for GNU-style thread-local storage.
 HANDLE_DW_OP(0xe0, GNU_push_tls_address, 0, GNU)
 // Extensions for WebAssembly.
 HANDLE_DW_OP(0xed, WASM_location, 0, WASM)
+HANDLE_DW_OP(0xee, WASM_location_int, 0, WASM)
 // The GNU entry value extension.
 HANDLE_DW_OP(0xf3, GNU_entry_value, 0, GNU)
 // Extensions for Fission proposal.
 HANDLE_DW_OP(0xfb, GNU_addr_index, 0, GNU)
 HANDLE_DW_OP(0xfc, GNU_const_index, 0, GNU)
 
 // DWARF languages.
 HANDLE_DW_LANG(0x0001, C89, 0, 2, DWARF)

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 WASM_RELOC(R_WASM_MEMORY_ADDR_I32,       5)
 WASM_RELOC(R_WASM_TYPE_INDEX_LEB,        6)
 WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,      7)
 WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,   8)
 WASM_RELOC(R_WASM_SECTION_OFFSET_I32,    9)
 WASM_RELOC(R_WASM_EVENT_INDEX_LEB,      10)
 WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB, 11)
 WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB, 12)
+WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,     13)

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

enum Encoding : uint8_t {
       Size2 = 1,
       Size4 = 2,
       Size8 = 3,
       SizeLEB = 4,
       SizeAddr = 5,
       SizeRefAddr = 6,
       SizeBlock = 7, ///< Preceding operand contains block size
       BaseTypeRef = 8,
+      WasmLocationArg = 30,
       SignBit = 0x80,
       SignedSize1 = SignBit | Size1,
       SignedSize2 = SignBit | Size2,
       SignedSize4 = SignBit | Size4,
       SignedSize8 = SignBit | Size8,
       SignedSizeLEB = SignBit | SizeLEB,
       SizeNA = 0xFF ///< Unused operands get this encoding.
     };

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MachineLocation.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
if (!includeMinimalInlineScopes()) {
     }
     case TargetFrameLowering::DwarfFrameBase::CFA: {
       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
       addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
       break;
     }
     case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: {
+      // FIXME: duplicated from Target/WebAssembly/WebAssembly.h
+      // don't want to depend on target specific headers in this code?
+      const unsigned TI_GLOBAL_RELOC = 3;
+      if (FrameBase.Location.WasmLoc.Kind == TI_GLOBAL_RELOC) {
+        // These need to be relocatable.
+        assert(FrameBase.Location.WasmLoc.Index == 0);  // Only SP so far.
+        auto SPSym = cast<MCSymbolWasm>(
+          Asm->GetExternalSymbolSymbol("__stack_pointer"));
+        // FIXME: this repeats what WebAssemblyMCInstLower::
+        // GetExternalSymbolSymbol does, since if there's no code that
+        // refers to this symbol, we have to set it here.
+        SPSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
+        // FIXME: need to check subtarget to see if its wasm64, but we
+        // can't cast to WebAssemblySubtarget here.
+        SPSym->setGlobalType(wasm::WasmGlobalType{wasm::WASM_TYPE_I32, true});
+        DIELoc *Loc = new (DIEValueAllocator) DIELoc;
+        addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_WASM_location);
+        addSInt(*Loc, dwarf::DW_FORM_sdata, FrameBase.Location.WasmLoc.Kind);
+        addLabel(*Loc, dwarf::DW_FORM_udata, SPSym);
+        DD->addArangeLabel(SymbolCU(this, SPSym));
+        addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
+        addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
+      } else {
         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
         DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
         DIExpressionCursor Cursor({});
         DwarfExpr.addWasmLocation(FrameBase.Location.WasmLoc.Kind,
-                                FrameBase.Location.WasmLoc.Index);
         DwarfExpr.addExpression(std::move(Cursor));
         addBlock(*SPDie, dwarf::DW_AT_frame_base, DwarfExpr.finalize());
+      }
       break;
     }
     }
   }
 
   // Add name to the name table, we do this here because we're guaranteed
   // to have concrete versions of our DW_TAG_subprogram nodes.
   DD->addSubprogramNames(*CUNode, SP, *SPDie);

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (Value.isInt()) {
     const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
     if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
       return;
     return DwarfExpr.addExpression(std::move(Cursor));
   } else if (Value.isTargetIndexLocation()) {
     TargetIndexLocation Loc = Value.getTargetIndexLocation();
     // TODO TargetIndexLocation is a target-independent. Currently only the WebAssembly-specific
     // encoding is supported.
-    DwarfExpr.addWasmLocation(Loc.Index, Loc.Offset);
+    DwarfExpr.addWasmLocation(Loc.Index, static_cast<uint64_t>(Loc.Offset));
   } else if (Value.isConstantFP()) {
     APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
     DwarfExpr.addUnsignedConstant(RawBytes);
   }
   DwarfExpr.addExpression(std::move(ExprCursor));
 }
 
 void DebugLocEntry::finalize(const AsmPrinter &AP,

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

public:
   /// the fragment described by \c Expr.
   void addFragmentOffset(const DIExpression *Expr);
 
   void emitLegacySExt(unsigned FromBits);
   void emitLegacyZExt(unsigned FromBits);
 
   /// Emit location information expressed via WebAssembly location + offset
   /// The Index is an identifier for locals, globals or operand stack.
-  void addWasmLocation(unsigned Index, int64_t Offset);
+  void addWasmLocation(unsigned Index, uint64_t Offset);
 };
 
 /// DwarfExpression implementation for .debug_loc entries.
 class DebugLocDwarfExpression final : public DwarfExpression {
 
   struct TempBuffer {
     SmallString<32> Bytes;
     std::vector<std::string> Comments;

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

 
 void DwarfExpression::emitLegacyZExt(unsigned FromBits) {
   // (X & (1 << FromBits - 1))
   emitOp(dwarf::DW_OP_constu);
   emitUnsigned((1ULL << FromBits) - 1);
   emitOp(dwarf::DW_OP_and);
 }
 
-void DwarfExpression::addWasmLocation(unsigned Index, int64_t Offset) {
+void DwarfExpression::addWasmLocation(unsigned Index, uint64_t Offset) {
   assert(LocationKind == Implicit || LocationKind == Unknown);
   LocationKind = Implicit;
   emitOp(dwarf::DW_OP_WASM_location);
   emitUnsigned(Index);
-  emitSigned(Offset);
+  emitUnsigned(Offset);
 }

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static DescVector getDescriptions() {
   Descriptions[DW_OP_call_ref] = Desc(Op::Dwarf3, Op::SizeRefAddr);
   Descriptions[DW_OP_form_tls_address] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_call_frame_cfa] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_bit_piece] = Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeLEB);
   Descriptions[DW_OP_implicit_value] =
       Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeBlock);
   Descriptions[DW_OP_stack_value] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_WASM_location] =
-      Desc(Op::Dwarf4, Op::SizeLEB, Op::SignedSizeLEB);
+      Desc(Op::Dwarf4, Op::SizeLEB, Op::WasmLocationArg);
   Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_addrx] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_addr_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_const_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_entry_value] = Desc(Op::Dwarf4, Op::SizeLEB);
 
   Descriptions[DW_OP_convert] = Desc(Op::Dwarf5, Op::BaseTypeRef);
   Descriptions[DW_OP_entry_value] = Desc(Op::Dwarf5, Op::SizeLEB);
case Operation::SizeLEB:
       if (Signed)
         Operands[Operand] = Data.getSLEB128(&Offset);
       else
         Operands[Operand] = Data.getULEB128(&Offset);
       break;
     case Operation::BaseTypeRef:
       Operands[Operand] = Data.getULEB128(&Offset);
       break;
+    case Operation::WasmLocationArg:
+      assert(Operand == 1);
+      switch (Operands[0]) {
+      case 0: case 1: case 2:
+        Operands[Operand] = Data.getULEB128(&Offset);
+        break;
+      case 3: // global as uint32
+         Operands[Operand] = Data.getU32(&Offset);
+         break;
+      default:
+        return false; // Unknown Wasm location
+      }
+      break;
     case Operation::SizeBlock:
       // We need a size, so this cannot be the first operand
       if (Operand == 0)
         return false;
       // Store the offset of the block as the value.
       Operands[Operand] = Offset;
       Offset += Operands[Operand - 1];
       break;
for (unsigned Operand = 0; Operand < 2; ++Operand) {
     if (Size == Operation::BaseTypeRef && U) {
       // For DW_OP_convert the operand may be 0 to indicate that conversion to
       // the generic type should be done. The same holds for DW_OP_reinterpret,
       // which is currently not supported.
       if (Opcode == DW_OP_convert && Operands[Operand] == 0)
         OS << " 0x0";
       else
         prettyPrintBaseTypeRef(U, OS, Operands, Operand);
+    } else if (Size == Operation::WasmLocationArg) {
+      assert(Operand == 1);
+      switch (Operands[0]) {
+      case 0: case 1: case 2:
+      case 3: // global as uint32
+        OS << format(" 0x%" PRIx64, Operands[Operand]);
+        break;
+      default: assert(false);
+      }
     } else if (Size == Operation::SizeBlock) {
       uint64_t Offset = Operands[Operand];
       for (unsigned i = 0; i < Operands[Operand - 1]; ++i)
         OS << format(" 0x%02x", Expr->Data.getU8(&Offset));
     } else {
       if (Signed)
         OS << format(" %+" PRId64, (int64_t)Operands[Operand]);
       else if (Opcode != DW_OP_entry_value &&

llvm/lib/MC/WasmObjectWriter.cpp

 }
 
 // Compute a value to write into the code at the location covered
 // by RelEntry. This value isn't used by the static linker; it just serves
 // to make the object format more readable and more likely to be directly
 // useable.
 uint32_t
 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
-  if (RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_LEB && !RelEntry.Symbol->isGlobal()) {
+  if ((RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_LEB ||
+       RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_I32) &&
+      !RelEntry.Symbol->isGlobal()) {
     assert(GOTIndices.count(RelEntry.Symbol) > 0 && "symbol not found in GOT index space");
     return GOTIndices[RelEntry.Symbol];
   }
 
   switch (RelEntry.Type) {
   case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
   case wasm::R_WASM_TABLE_INDEX_I32: {
     // Provisional value is table address of the resolved symbol itself
     const MCSymbolWasm *Sym = resolveSymbol(*RelEntry.Symbol);
     assert(Sym->isFunction());
     return TableIndices[Sym];
   }
   case wasm::R_WASM_TYPE_INDEX_LEB:
     // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
+  case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
     // Provisional value is function/global/event 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_SECTION_OFFSET_I32: {
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
for (const WasmRelocationEntry &RelEntry : Relocations) {
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_EVENT_INDEX_LEB:
       writePatchableLEB(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
     case wasm::R_WASM_SECTION_OFFSET_I32:
+    case wasm::R_WASM_GLOBAL_INDEX_I32:
       writeI32(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
       writePatchableSLEB(Stream, Value, Offset);
       break;

llvm/lib/Object/RelocationResolver.cpp

static bool supportsWasm32(uint64_t Type) {
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_GLOBAL_INDEX_I32:
     return true;
   default:
     return false;
   }
 }
 
 static uint64_t resolveWasm32(RelocationRef R, uint64_t S, uint64_t A) {
   switch (R.getType()) {
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
   case wasm::R_WASM_TABLE_INDEX_I32:
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_GLOBAL_INDEX_I32:
     // For wasm section, its offset at 0 -- ignoring Value
     return A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 std::pair<bool (*)(uint64_t), RelocationResolver>

llvm/lib/Object/WasmObjectFile.cpp

case wasm::R_WASM_GLOBAL_INDEX_LEB:
       // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
       // symbols to refer to their GOT entries.
       if (!isValidGlobalSymbol(Reloc.Index) &&
           !isValidDataSymbol(Reloc.Index) &&
           !isValidFunctionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation global index",
                                               object_error::parse_failed);
       break;
+    case wasm::R_WASM_GLOBAL_INDEX_I32:
+      if (!isValidGlobalSymbol(Reloc.Index))
+        return make_error<GenericBinaryError>("Bad relocation global index",
+                                              object_error::parse_failed);
+      break;
     case wasm::R_WASM_EVENT_INDEX_LEB:
       if (!isValidEventSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation event index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_I32:
while (RelocCount--) {
 
     // Relocations must fit inside the section, and must appear in order.  They
     // also shouldn't overlap a function/element boundary, but we don't bother
     // to check that.
     uint64_t Size = 5;
     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
         Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
-        Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32)
+        Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
+        Reloc.Type == wasm::R_WASM_GLOBAL_INDEX_I32)
       Size = 4;
     if (Reloc.Offset + Size > EndOffset)
       return make_error<GenericBinaryError>("Bad relocation offset",
                                             object_error::parse_failed);
 
     Section.Relocations.push_back(Reloc);
   }
   if (Ctx.Ptr != Ctx.End)

llvm/lib/ObjectYAML/WasmEmitter.cpp

void WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
 
   encodeULEB128(SectionIndex, OS);
   encodeULEB128(Sec.Relocations.size(), OS);
 
   for (auto Reloc : Sec.Relocations) {
     writeUint8(OS, Reloc.Type);
     encodeULEB128(Reloc.Offset, OS);
     encodeULEB128(Reloc.Index, OS);
-    switch (Reloc.Type) {
-    case wasm::R_WASM_MEMORY_ADDR_LEB:
-    case wasm::R_WASM_MEMORY_ADDR_SLEB:
-    case wasm::R_WASM_MEMORY_ADDR_I32:
-    case wasm::R_WASM_FUNCTION_OFFSET_I32:
-    case wasm::R_WASM_SECTION_OFFSET_I32:
+    if (wasm::relocTypeHasAddend(Reloc.Type)) {
       encodeULEB128(Reloc.Addend, OS);
     }
   }
 }
 
 bool WasmWriter::writeWasm(raw_ostream &OS) {
   // Write headers
   OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));

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

case WebAssembly::fixup_uleb128_i32:
     if (SymA.isFunction())
       return wasm::R_WASM_FUNCTION_INDEX_LEB;
     if (SymA.isEvent())
       return wasm::R_WASM_EVENT_INDEX_LEB;
     return wasm::R_WASM_MEMORY_ADDR_LEB;
   case FK_Data_4:
     if (SymA.isFunction())
       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()))) {
       if (Section->getKind().isText())
         return wasm::R_WASM_FUNCTION_OFFSET_I32;
       else if (!Section->isWasmData())
         return wasm::R_WASM_SECTION_OFFSET_I32;
     }
     return wasm::R_WASM_MEMORY_ADDR_I32;

llvm/lib/Target/WebAssembly/WebAssembly.h

 void initializeWebAssemblyCFGSortPass(PassRegistry &);
 void initializeWebAssemblyCFGStackifyPass(PassRegistry &);
 void initializeWebAssemblyExplicitLocalsPass(PassRegistry &);
 void initializeWebAssemblyLowerBrUnlessPass(PassRegistry &);
 void initializeWebAssemblyRegNumberingPass(PassRegistry &);
 void initializeWebAssemblyPeepholePass(PassRegistry &);
 
 namespace WebAssembly {
-enum TargetIndex { TI_LOCAL_START, TI_GLOBAL_START, TI_OPERAND_STACK_START };
+enum TargetIndex {
+  // Followed by a local index (ULEB).
+  TI_LOCAL,
+  // Followed by an absolute global index (ULEB). DEPRECATED.
+  TI_GLOBAL_FIXED,
+  TI_OPERAND_STACK,
+  // Followed by a compilation unit relative global index (uint32_t)
+  // that will have an associated relocation.
+  TI_GLOBAL_RELOC
+};
 } // end namespace WebAssembly
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/WebAssemblyDebugValueManager.cpp

for (MachineInstr *DBI : reverse(DbgValues)) {
     Clone->getOperand(0).setReg(NewReg);
     MBB->insert(Insert, Clone);
   }
 }
 
 void WebAssemblyDebugValueManager::replaceWithLocal(unsigned LocalId) {
   for (auto *DBI : DbgValues) {
     MachineOperand &Op = DBI->getOperand(0);
-    Op.ChangeToTargetIndex(llvm::WebAssembly::TI_LOCAL_START, LocalId);
+    Op.ChangeToTargetIndex(llvm::WebAssembly::TI_LOCAL, LocalId);
   }
 }

llvm/lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp

 
 TargetFrameLowering::DwarfFrameBase
 WebAssemblyFrameLowering::getDwarfFrameBase(const MachineFunction &MF) const {
   DwarfFrameBase Loc;
   Loc.Kind = DwarfFrameBase::WasmFrameBase;
   const WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
   if (needsSP(MF) && MFI.isFrameBaseVirtual()) {
     unsigned LocalNum = MFI.getFrameBaseLocal();
-    Loc.Location.WasmLoc = {WebAssembly::TI_LOCAL_START, LocalNum};
+    Loc.Location.WasmLoc = {WebAssembly::TI_LOCAL, LocalNum};
   } else {
     // TODO: This should work on a breakpoint at a function with no frame,
     // but probably won't work for traversing up the stack.
-    // TODO: This needs a relocation for correct __stack_pointer
-    Loc.Location.WasmLoc = {WebAssembly::TI_GLOBAL_START, 0};
+    Loc.Location.WasmLoc = {WebAssembly::TI_GLOBAL_RELOC, 0};
   }
   return Loc;
 }

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

bool WebAssemblyInstrInfo::reverseBranchCondition(
 
   Cond.front() = MachineOperand::CreateImm(!Cond.front().getImm());
   return false;
 }
 
 ArrayRef<std::pair<int, const char *>>
 WebAssemblyInstrInfo::getSerializableTargetIndices() const {
   static const std::pair<int, const char *> TargetIndices[] = {
-      {WebAssembly::TI_LOCAL_START, "wasm-local-start"},
-      {WebAssembly::TI_GLOBAL_START, "wasm-global-start"},
-      {WebAssembly::TI_OPERAND_STACK_START, "wasm-operator-stack-start"}};
+      {WebAssembly::TI_LOCAL, "wasm-local"},
+      {WebAssembly::TI_GLOBAL_FIXED, "wasm-global-fixed"},
+      {WebAssembly::TI_OPERAND_STACK, "wasm-operand-stack"},
+      {WebAssembly::TI_GLOBAL_RELOC, "wasm-global-reloc"}};
   return makeArrayRef(TargetIndices);
 }

llvm/test/CodeGen/WebAssembly/debugtest-opt.ll

 ; RUN: llc < %s -filetype=obj -o - | llvm-dwarfdump -
 
 ; To regenerate this file, use approximately the following C code:
 ; int* globl;
 ; void baz(int arg) {
 ;   int locl;
 ;   globl = &locl;
 ; }
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT:                DW_AT_low_pc
 ; CHECK-NEXT:                DW_AT_high_pc
 ;; Check that we fall back to the default frame base (the global)
-; CHECK-NEXT:                DW_AT_frame_base (DW_OP_WASM_location 0x1 +0, DW_OP_stack_value)
+; CHECK-NEXT:                DW_AT_frame_base (DW_OP_WASM_location_int 0x3 0x0, DW_OP_stack_value)
 
 ; TODO: Find a more-reduced test case for The fix in WebAssemblyRegColoring
 
 ; ModuleID = 'debugtest-opt.c'
 source_filename = "debugtest-opt.c"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32"
 

llvm/test/DebugInfo/WebAssembly/dbg-value-dwarfdump.ll

; CHECK: DW_TAG_variable
   %cmp8 = icmp sgt i32 %n, 0, !dbg !21
   br i1 %cmp8, label %for.body, label %for.end, !dbg !24
 
 for.body:                                         ; preds = %entry, %for.body
   %b.011 = phi i32 [ %add, %for.body ], [ 1, %entry ]
   %a.010 = phi i32 [ %b.011, %for.body ], [ 0, %entry ]
   %i.09 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
 
-; CHECK: DW_OP_WASM_location 0x0 +[[LOCAL_1:[0-9]+]]
+; CHECK: DW_OP_WASM_location 0x0 0x[[LOCAL_1:[0-9]+]]
   call void @llvm.dbg.value(metadata i32 %b.011, metadata !16, metadata !DIExpression()), !dbg !19
 
-; CHECK-NOT: DW_OP_WASM_location 0x0 +[[LOCAL_1]]
-; CHECK: DW_OP_WASM_location 0x0 +[[LOCAL_2:[0-9]+]]
+; CHECK-NOT: DW_OP_WASM_location 0x0 0x[[LOCAL_1]]
+; CHECK: DW_OP_WASM_location 0x0 0x[[LOCAL_2:[0-9]+]]
   %add = add nsw i32 %b.011, %a.010, !dbg !26
   %inc = add nuw nsw i32 %i.09, 1, !dbg !28
   call void @llvm.dbg.value(metadata i32 %add, metadata !16, metadata !DIExpression()), !dbg !19
   %exitcond = icmp eq i32 %inc, %n, !dbg !21
   br i1 %exitcond, label %for.end, label %for.body, !dbg !24, !llvm.loop !29
 
 for.end:                                          ; preds = %for.body, %entry
   %b.0.lcssa = phi i32 [ 1, %entry ], [ %add, %for.body ], !dbg !31

llvm/test/MC/WebAssembly/debug-info.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -S --symbols | FileCheck %s
 
 ; CHECK: Format: WASM
 ; CHECK-NEXT:Arch: wasm32
 ; CHECK-NEXT:AddressSize: 32bit
 ; CHECK-NEXT:Sections [
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: TYPE (0x1)
 ; CHECK-NEXT:    Size: 4
 ; CHECK-NEXT:    Offset: 8
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: IMPORT (0x2)
-; CHECK-NEXT:    Size: 58
+; CHECK-NEXT:    Size: 81
 ; CHECK-NEXT:    Offset: 18
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: FUNCTION (0x3)
 ; CHECK-NEXT:    Size: 2
-; CHECK-NEXT:    Offset: 82
+; CHECK-NEXT:    Offset: 105
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: ELEM (0x9)
 ; CHECK-NEXT:    Size: 7
-; CHECK-NEXT:    Offset: 90
+; CHECK-NEXT:    Offset: 113
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: DATACOUNT (0xC)
 ; CHECK-NEXT:    Size: 1
-; CHECK-NEXT:    Offset: 103
+; CHECK-NEXT:    Offset: 126
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CODE (0xA)
 ; CHECK-NEXT:    Size: 4
-; CHECK-NEXT:    Offset: 110
+; CHECK-NEXT:    Offset: 133
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: DATA (0xB)
 ; CHECK-NEXT:    Size: 19
-; CHECK-NEXT:    Offset: 120
+; CHECK-NEXT:    Offset: 143
 ; CHECK-NEXT:    Segments [
 ; CHECK-NEXT:      Segment {
 ; CHECK-NEXT:        Name: .data.foo
 ; CHECK-NEXT:        Size: 4
 ; CHECK-NEXT:        Offset: 0
 ; CHECK-NEXT:      }
 ; CHECK-NEXT:      Segment {
 ; CHECK-NEXT:        Name: .data.ptr2
 ; CHECK-NEXT:        Size: 4
 ; CHECK-NEXT:        Offset: 4
 ; CHECK-NEXT:      }
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 86
-; CHECK-NEXT:    Offset: 145
+; CHECK-NEXT:    Offset: 168
 ; CHECK-NEXT:    Name: .debug_abbrev
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
-; CHECK-NEXT:    Size: 111
-; CHECK-NEXT:    Offset: 251
+; CHECK-NEXT:    Size: 114
+; CHECK-NEXT:    Offset: 274
 ; CHECK-NEXT:    Name: .debug_info
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 121
-; CHECK-NEXT:    Offset: 380
+; CHECK-NEXT:    Offset: 406
 ; CHECK-NEXT:    Name: .debug_str
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 42
-; CHECK-NEXT:    Offset: 518
+; CHECK-NEXT:    Offset: 544
 ; CHECK-NEXT:    Name: .debug_pubnames
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 26
-; CHECK-NEXT:    Offset: 582
+; CHECK-NEXT:    Offset: 608
 ; CHECK-NEXT:    Name: .debug_pubtypes
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 57
-; CHECK-NEXT:    Offset: 630
+; CHECK-NEXT:    Offset: 656
 ; CHECK-NEXT:    Name: .debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
-; CHECK-NEXT:    Size: 88
-; CHECK-NEXT:    Offset: 705
+; CHECK-NEXT:    Size: 91
+; CHECK-NEXT:    Offset: 731
 ; CHECK-NEXT:    Name: linking
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 9
-; CHECK-NEXT:    Offset: 807
+; CHECK-NEXT:    Offset: 836
 ; CHECK-NEXT:    Name: reloc.DATA
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
-; CHECK-NEXT:    Size: 58
-; CHECK-NEXT:    Offset: 833
+; CHECK-NEXT:    Size: 61
+; CHECK-NEXT:    Offset: 862
 ; CHECK-NEXT:    Name: reloc..debug_info
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 915
+; CHECK-NEXT:    Offset: 947
 ; CHECK-NEXT:    Name: reloc..debug_pubnames
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 949
+; CHECK-NEXT:    Offset: 981
 ; CHECK-NEXT:    Name: reloc..debug_pubtypes
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 983
+; CHECK-NEXT:    Offset: 1015
 ; CHECK-NEXT:    Name: reloc..debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 77
-; CHECK-NEXT:    Offset: 1013
+; CHECK-NEXT:    Offset: 1045
 ; CHECK-NEXT:    Name: producers
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Relocations [
 ; CHECK-NEXT:  Section (7) DATA {
 ; CHECK-NEXT:    0x6 R_WASM_MEMORY_ADDR_I32 myextern 0
 ; CHECK-NEXT:    0xF R_WASM_TABLE_INDEX_I32 f2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (9) .debug_info {
 ; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_abbrev 0
 ; CHECK-NEXT:    0xC R_WASM_SECTION_OFFSET_I32 .debug_str 0
 ; CHECK-NEXT:    0x12 R_WASM_SECTION_OFFSET_I32 .debug_str 55
 ; CHECK-NEXT:    0x16 R_WASM_SECTION_OFFSET_I32 .debug_line 0
 ; CHECK-NEXT:    0x1A R_WASM_SECTION_OFFSET_I32 .debug_str 62
 ; CHECK-NEXT:    0x1E R_WASM_FUNCTION_OFFSET_I32 f2 0
 ; CHECK-NEXT:    0x27 R_WASM_SECTION_OFFSET_I32 .debug_str 105
 ; CHECK-NEXT:    0x33 R_WASM_MEMORY_ADDR_I32 foo 0
 ; CHECK-NEXT:    0x3D R_WASM_SECTION_OFFSET_I32 .debug_str 109
 ; CHECK-NEXT:    0x44 R_WASM_SECTION_OFFSET_I32 .debug_str 113
 ; CHECK-NEXT:    0x50 R_WASM_MEMORY_ADDR_I32 ptr2 0
 ; CHECK-NEXT:    0x5B R_WASM_FUNCTION_OFFSET_I32 f2 0
-; CHECK-NEXT:    0x68 R_WASM_SECTION_OFFSET_I32 .debug_str 118
+; CHECK-NEXT:    0x66 R_WASM_GLOBAL_INDEX_I32 __stack_pointer
+; CHECK-NEXT:    0x6B R_WASM_SECTION_OFFSET_I32 .debug_str 118
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (11) .debug_pubnames {
 ; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_info 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (12) .debug_pubtypes {
 ; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_info 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (13) .debug_line {

 ; CHECK-NEXT:    Name: .debug_info
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags [ (0x2)
 ; CHECK-NEXT:      BINDING_LOCAL (0x2)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    ElementIndex: 0x8
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
+; CHECK-NEXT:    Name: __stack_pointer
+; CHECK-NEXT:    Type: GLOBAL (0x2)
+; CHECK-NEXT:    Flags [ (0x10)
+; CHECK-NEXT:      UNDEFINED (0x10)
+; CHECK-NEXT:    ]
+; CHECK-NEXT:    ImportName: __stack_pointer
+; CHECK-NEXT:    ImportModule: env
+; CHECK-NEXT:    ElementIndex: 0x0
+; CHECK-NEXT:  }
+; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: .debug_str
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags [ (0x2)
 ; CHECK-NEXT:      BINDING_LOCAL (0x2)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    ElementIndex: 0x9
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {

llvm/test/MC/WebAssembly/debug-localvar.ll

 !38 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !39 = !DILocation(line: 13, column: 8, scope: !24)
 !40 = !DILocation(line: 15, column: 1, scope: !24)
 
 ; CHECK-LABEL: DW_TAG_compile_unit
 ; CHECK-LABEL:     DW_TAG_subprogram
 ; CHECK-NEXT:                DW_AT_low_pc (0x0000000000000002)
 ; CHECK-NEXT:                DW_AT_high_pc  (0x0000000000000039)
-; CHECK-NEXT:                DW_AT_frame_base (DW_OP_WASM_location 0x0 +1, DW_OP_stack_value)
+; CHECK-NEXT:                DW_AT_frame_base (DW_OP_WASM_location 0x0 0x1, DW_OP_stack_value)
 ; CHECK-NEXT:                DW_AT_name ("foo")
 ; CHECK-NEXT:                DW_AT_decl_file  ("/s/llvm-upstream{{(/|\\)}}debugtest.c")
 ; CHECK-NEXT:                DW_AT_decl_line  (1)
 ; CHECK-NEXT:                DW_AT_prototyped (true)
 ; CHECK-NEXT:                DW_AT_type (0x00000073 "int")
 ; CHECK-NEXT:                DW_AT_external (true)
 ; CHECK-LABEL:     DW_TAG_formal_parameter
 ; CHECK-NEXT:                  DW_AT_location (DW_OP_fbreg +12)

llvm/test/MC/WebAssembly/dwarfdump.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
 
 ; CHECK: .debug_info contents:
-; CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000006b version = 0x0004 abbr_offset = 0x0000 addr_size = 0x04 (next unit at 0x0000006f)
+; CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000006e version = 0x0004 abbr_offset = 0x0000 addr_size = 0x04 (next unit at 0x00000072)
 
 ; CHECK: 0x0000000b: DW_TAG_compile_unit
 ; CHECK-NEXT:              DW_AT_producer ("clang version 6.0.0 (trunk 315924) (llvm/trunk 315960)")
 ; CHECK-NEXT:              DW_AT_language (DW_LANG_C99)
 ; CHECK-NEXT:              DW_AT_name ("test.c")
 ; CHECK-NEXT:              DW_AT_stmt_list  (0x00000000)
 ; CHECK-NEXT:              DW_AT_comp_dir ("/usr/local/google/home/sbc/dev/wasm/simple")
 ; CHECK-NEXT:              DW_AT_GNU_pubnames (true)

 ; CHECK-NEXT:                DW_AT_type (0x00000059 "void()")
 
 ; CHECK: 0x00000059:   DW_TAG_subroutine_type
 ; CHECK-NEXT:                DW_AT_prototyped (true)
 
 ; CHECK: 0x0000005a:   DW_TAG_subprogram
 ; CHECK-NEXT:                DW_AT_low_pc (0x0000000000000002)
 ; CHECK-NEXT:                DW_AT_high_pc  (0x0000000000000004)
-; CHECK-NEXT:                DW_AT_frame_base (DW_OP_WASM_location 0x1 +0, DW_OP_stack_value)
+; CHECK-NEXT:                DW_AT_frame_base (DW_OP_WASM_location 0x3 0x0, DW_OP_stack_value)
 ; CHECK-NEXT:                DW_AT_name ("f2")
 ; CHECK-NEXT:                DW_AT_decl_file  ("/usr/local/google/home/sbc/dev/wasm/simple{{[/\\]}}test.c")
 ; CHECK-NEXT:                DW_AT_decl_line  (2)
 ; CHECK-NEXT:                DW_AT_prototyped (true)
 ; CHECK-NEXT:                DW_AT_external   (true)
 
-; CHECK: 0x0000006e:   NULL
+; CHECK: 0x00000071:   NULL
 
 target triple = "wasm32-unknown-unknown"
 
 source_filename = "test.c"
 
 @myextern = external global i32, align 4
 @foo = hidden global i32* @myextern, align 4, !dbg !0
 @ptr2 = hidden global void ()* @f2, align 4, !dbg !6

llvm/tools/llvm-readobj/WasmDumper.cpp

void WasmDumper::printRelocation(const SectionRef &Section,
   Reloc.getTypeName(RelocTypeName);
   const wasm::WasmRelocation &WasmReloc = Obj->getWasmRelocation(Reloc);
 
   StringRef SymName;
   symbol_iterator SI = Reloc.getSymbol();
   if (SI != Obj->symbol_end())
     SymName = unwrapOrError(Obj->getFileName(), SI->getName());
 
-  bool HasAddend = false;
-  switch (RelocType) {
-  case wasm::R_WASM_MEMORY_ADDR_LEB:
-  case wasm::R_WASM_MEMORY_ADDR_SLEB:
-  case wasm::R_WASM_MEMORY_ADDR_I32:
-  case wasm::R_WASM_FUNCTION_OFFSET_I32:
-  case wasm::R_WASM_SECTION_OFFSET_I32:
-    HasAddend = true;
-    break;
-  default:
-    break;
-  }
+  bool HasAddend = wasm::relocTypeHasAddend(static_cast<uint32_t>(RelocType));
+
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printNumber("Type", RelocTypeName, RelocType);
     W.printHex("Offset", Reloc.getOffset());
     if (!SymName.empty())
       W.printString("Symbol", SymName);
     else
       W.printHex("Index", WasmReloc.Index);