[MSP430] Get the DWARF pointer size from MCAsmInfo instead of DataLayout.

[kuilpd]

Summary

This change will allow to put code pointers in DWARF info fields that are larger than actual pointer size, e.g. 16-bit pointers into 32-bit fields.

The need for this came up while creating support for MSP430 in LLDB. MSP430-GCC already generates DWARF info with 32-bit fields, so this change is necessary for LLDB to maintain compatibility with both GCC and LLVM binaries. Moreover, right now in LLDB there is no support for having DWARF pointer size different from ELF header type, e.g. 16-bit DWARF info within ELF32, and it seems there is no such thing as ELF16.

Since other mainline targets are made to have the same pointer size in both MCAsmInfo and DataLayout, there is no need to change anything there.

[asl]

The change looks good from MSP430 perspective. We will need it in any case (or something similar) for MSP430X case as there we're having 16-bit platform with 20-bit pointers. Apparently it turned out that there is no such thing as "ELF16" and msp430-gcc already generates ELF32 for MSP430 target.

[dblaikie]

What's the difference between these two things? (like, why are they different for MSP430? I guess the data layout represents how big a pointer is in a struct, but what does the "code pointer size" represent/why is it the right answer?)

Equally/also, this seems like an lldb bug that could be fixed there, though arguably we would want to emit it the same as GCC for GDB compatibility anyway (if GDB can't cope with the 2 byte pointers already - have you tested that?).

Also there's a few codepaths that include assertions about pointer sizes being 4 or 8 bytes, so they'd presumably have resulted in crashes for MSP430 before? So sounds like those codepaths are untested, and perhaps should be tested? (could you add that test coverage?) & maybe it'd be good to unify all the callers so this is only done in one place instead of 5?

[asl]

@dblaikie as far as I can see, there are several interconnected issues here.

First of all, ELF could be 32-bit or 64-bit (EI_CLASS field in ELF header), there are no 16-bit ELF files defined around and I do not think it's a good idea to invent something new here. Next, LLDB indeed assumes that pointer size coincides with ELF class and I would not consider it as a bug :) And it seems there is no way to specify that inside ELF file that ELF32 file could contain 16-bit pointers.

We are seeing a precedent of msp430-gcc to generate 32-bit pointers inside ELF32 file for MSP430 architecture and eventually we need to be able to mix-and-match linking with such objects as they could be in e.g. CRT, etc.

So, it seems we need a way to distinguish between "platform address size" that it used for code generation, optimizations, etc. and "address size used for DWARF emission" (both for data and code!). Currently LLVM assumes that they are the same and the patch allows a platform to override it. Even more, MSP430X extention uses 20-bit pointers, so we'd end with something similar here one way or another.

It seems currently they things a bit messy in how we're emitting DWARF data (see https://discourse.llvm.org/t/what-is-a-codepointersize-and-how-does-it-relate-to-dwarf/64825 for example)

If you're overseeing better solution of the problem, then it would be good to hear how :)

I'm also tagging @probinson for some insights

[dblaikie]

In D148042#4278656, @asl wrote:

@dblaikie as far as I can see, there are several interconnected issues here.

First of all, ELF could be 32-bit or 64-bit (EI_CLASS field in ELF header), there are no 16-bit ELF files defined around and I do not think it's a good idea to invent something new here.

Agreed.

Next, LLDB indeed assumes that pointer size coincides with ELF class and I would not consider it as a bug :)

I would - DWARF has a field for pointer size & it doesn't have to be/isn't tied to the ELF class.

And it seems there is no way to specify that inside ELF file that ELF32 file could contain 16-bit pointers.

There is at the DWARF level.

But I guess you mean for the actual code in an ELF32 file you have to have 32 bit pointers for relocations to be applied, etc? So what does it mean for for the program to have 16 bit pointers but be using 32 bit relocations?

We are seeing a precedent of msp430-gcc to generate 32-bit pointers inside ELF32 file for MSP430 architecture and eventually we need to be able to mix-and-match linking with such objects as they could be in e.g. CRT, etc.

The ability to mix and match doesn't seem like "we have to do what GCC does" - it might still mean that there can/should be fixes to consumers. But equally I'm generally a fan of "do whatever GCC does" when it comes to DWARF, since it's far too broad to say "consumers should handle anything the DWARF spec allows".

So, it seems we need a way to distinguish between "platform address size" that it used for code generation, optimizations, etc. and "address size used for DWARF emission" (both for data and code!).

I still don't know if we should/do need to distinguish those things, but maybe we do. I'm still not sure how the 16 bit pointers work (disregarding DWARF for a minute) with a 32 bit ELF file...

Currently LLVM assumes that they are the same and the patch allows a platform to override it. Even more, MSP430X extention uses 20-bit pointers, so we'd end with something similar here one way or another.

It seems currently they things a bit messy in how we're emitting DWARF data (see https://discourse.llvm.org/t/what-is-a-codepointersize-and-how-does-it-relate-to-dwarf/64825 for example)

Ah, yeah, that thread discusses some of the directions I'd have in mind.

If this is a regression, it'd be good to have context for where these things were changed to use DataLayout (a link to the commit(s)) and an explanation of why changing them back won't harm whatever motivated them to be changed to use DataLayout in the first place.

Then, yes, as mentioned in that thread, adding a single entry point for these things would be important (just fixing the 5 sites directly seems like a bad idea if these should all be kept in sync and there are easy ways to mistakenly use the wrong value as has been the case in the past, perhaps).

But I'd like to understand the problem better too/first - it doesn't seem right to me that DWARF would need a different size from the system/target itself. (& no, I don't especially know what the "codepointer" size is as distinct from the address size either)

[kuilpd]

In D148042#4281618, @dblaikie wrote:

Next, LLDB indeed assumes that pointer size coincides with ELF class and I would not consider it as a bug :)

I would - DWARF has a field for pointer size & it doesn't have to be/isn't tied to the ELF class.

And it seems there is no way to specify that inside ELF file that ELF32 file could contain 16-bit pointers.

There is at the DWARF level.

DWARF has a pointer size field, but ELF doesn't. When parsing ELF header, LLDB just assumes the pointer size to be the same as ELF type, 32 or 64 bit, no other options.
https://github.com/llvm/llvm-project/blob/main/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.cpp#L120
16-bit pointers can be put in ELF32, but LLDB fails to read them while trying to extract them as 32-bit values. Wouldn't call it a bug per se, it's just how it's made, seeing as right now only ELF32 and ELF64 exist.
LLDB does use the DWARF's pointer size when extracting DWARF information, but if DWARF says it has 16-bit pointers when LLDB already assumed it's 32-bit because of ELF32, it breaks things. Can't remember which exact things, but a lot of debug info stops working. Sometimes LLDB uses ELF pointer width, sometimes DWARF, everything is interleaved there as it assumes the sizes in both are the same.
And if there is no DWARF information in the file, there seems to be no way of specifying in an ELF32 header that it has 16-bit pointers.

But I guess you mean for the actual code in an ELF32 file you have to have 32 bit pointers for relocations to be applied, etc? So what does it mean for for the program to have 16 bit pointers but be using 32 bit relocations?

I'm not sure, but I haven't encountered any problems. Pointers are just treated as 32-bit wide in ELF/DWARF information only, but once all the information has been correctly loaded by LLDB, it uses the pointer size that is specified for the target architecture.
https://github.com/llvm/llvm-project/blob/main/lldb/source/Utility/ArchSpec.cpp#L158

So, it seems we need a way to distinguish between "platform address size" that it used for code generation, optimizations, etc. and "address size used for DWARF emission" (both for data and code!).

I still don't know if we should/do need to distinguish those things, but maybe we do. I'm still not sure how the 16 bit pointers work (disregarding DWARF for a minute) with a 32 bit ELF file...

Right now as I understand the pointer size in DataLayout is used for code generation, and CodePointerSize in MCAsmInfo if used for DWARF purposes, namely in AsmPrinter, so there is already a distinction. But since for all other targets these values seem to be the same it might have been used interchangeably, so this patch suggest to actually use CodePointerSize in DWARF-related information.

If this is a regression, it'd be good to have context for where these things were changed to use DataLayout (a link to the commit(s)) and an explanation of why changing them back won't harm whatever motivated them to be changed to use DataLayout in the first place.

From what I've found, these were initially written using DataLayout, because CodePointerSize didn't exist yet. But when it was introduced, most DWARF-related code was rewritten using it, but I assume that not in all places.
For example, DwarfDebug.cpp used to use DataLayout as well:
https://github.com/llvm/llvm-project/blob/release/4.x/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1694
but it got changed to CodePointerSize here and in all other places where DataLayout was used:
https://github.com/llvm/llvm-project/blob/release/5.x/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L1747
So I think the changes this patch suggests just fix what was overlooked. It just never broke any code because the values are the same for other targets.
This might be the commit that changed things, just not all of them:
https://github.com/llvm/llvm-project/commit/dc77b2e960b6b6d4622c89ee8d324848ac6a0609

Then, yes, as mentioned in that thread, adding a single entry point for these things would be important (just fixing the 5 sites directly seems like a bad idea if these should all be kept in sync and there are easy ways to mistakenly use the wrong value as has been the case in the past, perhaps).

If the patch just fixes what was overlooked, then changing directly is the way to go. But maybe CodePointerSize should be renamed to DWARFCodePointerSize or something else to avoid confusion from now on.

But I'd like to understand the problem better too/first - it doesn't seem right to me that DWARF would need a different size from the system/target itself. (& no, I don't especially know what the "codepointer" size is as distinct from the address size either)

The need is to simplify implementation of 16-bit targets for use in LLDB.
This way:

1. There is no need to change how LLDB handles ELF headers
2. Allows compatibility with GCC binaries (for MSP430, specifically)
3. Doesn't change anything for other targets

[dblaikie]

If the patch just fixes what was overlooked, then changing directly is the way to go.

The hope/desire would be to make it harder to overlook, by not having the DWARF code reach out to these various config places & just have to "know" which one was the right one - but have it handled once in DwarfDebug and then only consult that everywhere else.

Could you look up the original commits that overlooked this and include references to them here? It'd help provide context for this change for both the review and commit/history later on. (explain how we got here, demonstrate these were overlooked/the changes proposed are consistent with that previous work, etc)

[kuilpd]

Shortened access to MCAsmInfo.

[kuilpd]

In D148042#4287909, @dblaikie wrote:

If the patch just fixes what was overlooked, then changing directly is the way to go.

The hope/desire would be to make it harder to overlook, by not having the DWARF code reach out to these various config places & just have to "know" which one was the right one - but have it handled once in DwarfDebug and then only consult that everywhere else.

Could you look up the original commits that overlooked this and include references to them here? It'd help provide context for this change for both the review and commit/history later on. (explain how we got here, demonstrate these were overlooked/the changes proposed are consistent with that previous work, etc)

As far as I could find, these changes were initially suggested in D11969 (for different reasons, though) but were abandoned, then reintroduced in D30879.
However, not everything was reintroduced, like for example line 137 in AsmPrinterDwarf.cpp from D11969.

Regarding single entry point, I made it look a bit better (just like in D30879). On top of that I could make a getCodePointerSize() in AsmPrinter.h which would take the pointer size from MCAsmInfo, right next to getPointerSize() function which takes the pointer size from DataLayout. But at this point there is already an entry point, it's just in MCAsmInfo.

[kuilpd]

Ping.

[dblaikie]

Not sure these elements are sufficiently well documented/specified to make this super reliable in terms of the chances this property will regress in the future - but at least eliminating all the calls as you've done here gives a better chance that someone'll copy from an existing use case rather than introducing a novel one.

llvm/lib/Target/MSP430/MCTargetDesc/MSP430MCAsmInfo.cpp

19–24

I wouldn't justify this from a "what LLDB assumes" - again, we could "just" fix LLDB if that's the problem.

23–24

It's not really compatibility with GCC binaries though - the DWARF could be different between the two compilers and that could be supported by consumers.

Maybe the simplest wording would be something like "Since this is what GCC does, we'll do it to since it's likely a better/well tested path for DWARF consumers like GDB and LLDB, rather than something that might be novel though possibly more technically correct"?

[kuilpd]

Reworded the explanation commentary.

llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp

 //===- llvm/CodeGen/AddressPool.cpp - Dwarf Debug Framework ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AddressPool.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include <utility>
 
 using namespace llvm;
 
 unsigned AddressPool::getIndex(const MCSymbol *Sym, bool TLS) {
   resetUsedFlag(true);
   auto IterBool =
       Pool.insert(std::make_pair(Sym, AddressPoolEntry(Pool.size(), TLS)));
   return IterBool.first->second.Number;
 }
 
 MCSymbol *AddressPool::emitHeader(AsmPrinter &Asm, MCSection *Section) {
-  static const uint8_t AddrSize = Asm.getDataLayout().getPointerSize();
+  static const uint8_t AddrSize = Asm.MAI->getCodePointerSize();
 
   MCSymbol *EndLabel =
       Asm.emitDwarfUnitLength("debug_addr", "Length of contribution");
   Asm.OutStreamer->AddComment("DWARF version number");
   Asm.emitInt16(Asm.getDwarfVersion());
   Asm.OutStreamer->AddComment("Address size");
   Asm.emitInt8(AddrSize);
   Asm.OutStreamer->AddComment("Segment selector size");
void AddressPool::emit(AsmPrinter &Asm, MCSection *AddrSection) {
 
   for (const auto &I : Pool)
     Entries[I.second.Number] =
         I.second.TLS
             ? Asm.getObjFileLowering().getDebugThreadLocalSymbol(I.first)
             : MCSymbolRefExpr::create(I.first, Asm.OutContext);
 
   for (const MCExpr *Entry : Entries)
-    Asm.OutStreamer->emitValue(Entry, Asm.getDataLayout().getPointerSize());
+    Asm.OutStreamer->emitValue(Entry, Asm.MAI->getCodePointerSize());
 
   if (EndLabel)
     Asm.OutStreamer->emitLabel(EndLabel);
 }

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 }
 
 unsigned int AsmPrinter::getDwarfOffsetByteSize() const {
   return dwarf::getDwarfOffsetByteSize(
       OutStreamer->getContext().getDwarfFormat());
 }
 
 dwarf::FormParams AsmPrinter::getDwarfFormParams() const {
-  return {getDwarfVersion(), uint8_t(getPointerSize()),
+  return {getDwarfVersion(), uint8_t(MAI->getCodePointerSize()),
           OutStreamer->getContext().getDwarfFormat(),
           doesDwarfUseRelocationsAcrossSections()};
 }
 
 unsigned int AsmPrinter::getUnitLengthFieldByteSize() const {
   return dwarf::getUnitLengthFieldByteSize(
       OutStreamer->getContext().getDwarfFormat());
 }

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

 unsigned AsmPrinter::GetSizeOfEncodedValue(unsigned Encoding) const {
   if (Encoding == dwarf::DW_EH_PE_omit)
     return 0;
 
   switch (Encoding & 0x07) {
   default:
     llvm_unreachable("Invalid encoded value.");
   case dwarf::DW_EH_PE_absptr:
-    return MF->getDataLayout().getPointerSize();
+    return MAI->getCodePointerSize();
   case dwarf::DW_EH_PE_udata2:
     return 2;
   case dwarf::DW_EH_PE_udata4:
     return 4;
   case dwarf::DW_EH_PE_udata8:
     return 8;
   }
 }

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/TargetFrameLowering.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/MC/MCAsmInfo.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/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
if (Expr) {
       DwarfExpr->addFragmentOffset(Expr);
     }
 
     if (Global) {
       const MCSymbol *Sym = Asm->getSymbol(Global);
       // 16-bit platforms like MSP430 and AVR take this path, so sink this
       // assert to platforms that use it.
       auto GetPointerSizedFormAndOp = [this]() {
-        unsigned PointerSize = Asm->getDataLayout().getPointerSize();
+        unsigned PointerSize = Asm->MAI->getCodePointerSize();
         assert((PointerSize == 4 || PointerSize == 8) &&
                "Add support for other sizes if necessary");
         struct FormAndOp {
           dwarf::Form Form;
           dwarf::LocationAtom Op;
         };
         return PointerSize == 4
                    ? FormAndOp{dwarf::DW_FORM_data4, dwarf::DW_OP_const4u}

llvm/lib/Target/MSP430/MCTargetDesc/MSP430MCAsmInfo.cpp

 //===----------------------------------------------------------------------===//
 
 #include "MSP430MCAsmInfo.h"
 using namespace llvm;
 
 void MSP430MCAsmInfo::anchor() { }
 
 MSP430MCAsmInfo::MSP430MCAsmInfo(const Triple &TT) {
-  CodePointerSize = 2;
+  // Since MSP430-GCC already generates 32-bit DWARF information, we will
+  // also store 16-bit pointers as 32-bit pointers in DWARF, because using
+  // 32-bit DWARF pointers is already a working and tested path for LLDB
+  // as well.
+  CodePointerSize = 4;
   CalleeSaveStackSlotSize = 2;
 
   CommentString = ";";
   SeparatorString = "{";
 
   AlignmentIsInBytes = false;
   UsesELFSectionDirectiveForBSS = true;
 
   SupportsDebugInformation = true;
 
   ExceptionsType = ExceptionHandling::DwarfCFI;
 }

llvm/test/DebugInfo/MSP430/cu-ranges.ll

 ; RUN: llc -O0 -mtriple=msp430 -filetype=obj %s -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; Ported from generic test to cover 2-byte address size case
+; Check that 16-bit addresses of MSP430 are properly stored
+; in 32-bit DWARF fields
 
 ; Check that we emit ranges for this which has a non-traditional section and a normal section.
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_ranges
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_low_pc
 ; CHECK: DW_AT_high_pc
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_low_pc
 ; CHECK: DW_AT_high_pc
 
 ; CHECK: .debug_ranges contents:
-; CHECK-NEXT: 00000000 0000 0030
-; CHECK-NEXT: 00000000 0000 0030
+; CHECK-NEXT: 00000000 00000000 00000030
+; CHECK-NEXT: 00000000 00000000 00000030
 ; CHECK-NEXT: 00000000 <End of list>
 
 ; Function Attrs: nounwind uwtable
 define i32 @foo(i32 %a) #0 section "__TEXT,__foo" !dbg !4 {
 entry:
   %a.addr = alloca i32, align 4
   store i32 %a, ptr %a.addr, align 4
   call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !13, metadata !DIExpression()), !dbg !14

llvm/test/DebugInfo/MSP430/dwarf-basics-v5.ll

 ; RUN: llc -generate-arange-section -minimize-addr-in-v5=Ranges --filetype=obj -o %t < %s
 ; RUN: llvm-dwarfdump --debug-info -debug-aranges -debug-addr %t | FileCheck %s
 ; RUN: llvm-dwarfdump --verify %t
 
 ; This file was based on output of
 ;
-;   clang -target msp430 -S -emit-llvm -gdwarf-5 -Os dwarf-basics-v5.c
+;   clang -target msp430-elf -S -emit-llvm -gdwarf-5 -Os dwarf-basics-v5.c
 ;
 ; for the following dwarf-basics-v5.c
 ;
 ;   struct X {
 ;     void *a;
 ;   };
 ;
 ;   int f(long y, struct X *p)
 ;   {
 ;     return 42;
 ;   }
 ;
 
 ; CHECK: file format elf32-msp430
 
 ; CHECK: .debug_info contents:
-; CHECK: Compile Unit: length = 0x{{.*}}, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x02 (next unit at 0x{{.*}})
+; CHECK: Compile Unit: length = 0x{{.*}}, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x{{.*}})
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK:   DW_AT_producer    ("clang version 14.0.0 (git@...)")
-; CHECK:   DW_AT_language    (DW_LANG_C99)
+; CHECK:   DW_AT_producer    ("clang version 17.0.0 (git@...)")
+; CHECK:   DW_AT_language    (DW_LANG_C11)
 ; CHECK:   DW_AT_name        ("dwarf-basics-v5.c")
 ; CHECK:   DW_AT_str_offsets_base    (0x00000008)
 ; CHECK:   DW_AT_stmt_list   (0x{{.*}})
 ; CHECK:   DW_AT_comp_dir    ("/tmp")
 ; CHECK:   DW_AT_low_pc      (0x{{.*}})
 ; CHECK:   DW_AT_high_pc     (0x{{.*}})
 ; CHECK:   DW_AT_addr_base   (0x00000008)
 ; CHECK:   DW_AT_loclists_base       (0x0000000c)
 
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_low_pc    (0x{{.*}})
 ; CHECK:     DW_AT_high_pc   (0x{{.*}})
 ; CHECK:     DW_AT_frame_base        (DW_OP_reg1 SP)
 ; CHECK:     DW_AT_call_all_calls    (true)
 ; CHECK:     DW_AT_name      ("f")
 ; CHECK:     DW_AT_decl_file ("/tmp{{[/\\]}}dwarf-basics-v5.c")
 ; CHECK:     DW_AT_decl_line (5)
 ; CHECK:     DW_AT_prototyped (true)
 ; CHECK:     DW_AT_type      (0x{{.*}} "int")
 ; CHECK:     DW_AT_external  (true)
 
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_location        (indexed (0x0) loclist = 0x{{.*}}:
-; CHECK:            [0x0000, 0x0004): DW_OP_reg12 R12)
+; CHECK:            [0x00000000, 0x00000004): DW_OP_reg12 R12)
 ; CHECK:         DW_AT_name    ("y")
 ; CHECK:         DW_AT_decl_file       ("/tmp{{[/\\]}}dwarf-basics-v5.c")
 ; CHECK:         DW_AT_decl_line       (5)
 ; CHECK:         DW_AT_type    (0x{{.*}} "long")
 
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_location        (DW_OP_reg14 R14)
 ; CHECK:         DW_AT_name    ("p")

 
 ; CHECK:       NULL
 
 ; CHECK:     DW_TAG_pointer_type
 
 ; CHECK:     NULL
 
 ; CHECK:      .debug_aranges contents:
-; CHECK-NEXT: Address Range Header: length = 0x{{.*}}, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x02, seg_size = 0x00
-; CHECK-NEXT: [0x0000, 0x0006)
+; CHECK-NEXT: Address Range Header: length = 0x{{.*}}, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
+; CHECK-NEXT: [0x00000000, 0x00000006)
 
 ; CHECK:      .debug_addr contents:
-; CHECK-NEXT: Address table header: length = 0x{{.*}}, format = DWARF32, version = 0x0005, addr_size = 0x02, seg_size = 0x00
+; CHECK-NEXT: Address table header: length = 0x{{.*}}, format = DWARF32, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 ; CHECK-NEXT: Addrs: [
-; CHECK-NEXT: 0x0000
+; CHECK-NEXT: 0x00000000
 ; CHECK-NEXT: ]
 
 ; ModuleID = 'dwarf-basics-v5.c'
 source_filename = "dwarf-basics-v5.c"
 target datalayout = "e-m:e-p:16:16-i32:16-i64:16-f32:16-f64:16-a:8-n8:16-S16"
-target triple = "msp430"
+target triple = "msp430-unknown-unknown-elf"
 
-%struct.X = type { i8* }
-
-; Function Attrs: mustprogress nofree norecurse nosync nounwind optsize readnone willreturn
-define dso_local i16 @f(i32 noundef %y, %struct.X* nocapture noundef readnone %p) local_unnamed_addr #0 !dbg !6 {
-entry:
-  call void @llvm.dbg.value(metadata i32 %y, metadata !17, metadata !DIExpression()), !dbg !19
-  call void @llvm.dbg.value(metadata %struct.X* %p, metadata !18, metadata !DIExpression()), !dbg !19
+; Function Attrs: mustprogress nofree norecurse nosync nounwind optsize willreturn memory(none)
+define dso_local i16 @f(i32 noundef %0, ptr nocapture noundef readnone %1) local_unnamed_addr #0 !dbg !6 {
+  call void @llvm.dbg.value(metadata i32 %0, metadata !17, metadata !DIExpression()), !dbg !19
+  call void @llvm.dbg.value(metadata ptr %1, metadata !18, metadata !DIExpression()), !dbg !19
   ret i16 42, !dbg !20
 }
 
-; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
 
-attributes #0 = { mustprogress nofree norecurse nosync nounwind optsize readnone willreturn "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
-attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #0 = { mustprogress nofree norecurse nosync nounwind optsize willreturn memory(none) "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!2, !3, !4}
 !llvm.ident = !{!5}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0 (git@...)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!0 = distinct !DICompileUnit(language: DW_LANG_C11, file: !1, producer: "clang version 17.0.0 (git@...)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "dwarf-basics-v5.c", directory: "/tmp", checksumkind: CSK_MD5, checksum: "ead340d457001e2ce340630cfa3a9cb8")
 !2 = !{i32 7, !"Dwarf Version", i32 5}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = !{i32 1, !"wchar_size", i32 2}
-!5 = !{!"clang version 14.0.0 (git@...)"}
+!5 = !{!"clang version 17.0.0 (git@...)"}
 !6 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 5, type: !7, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !16)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!9, !10, !11}
 !9 = !DIBasicType(name: "int", size: 16, encoding: DW_ATE_signed)
 !10 = !DIBasicType(name: "long", size: 32, encoding: DW_ATE_signed)
 !11 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 16)
 !12 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "X", file: !1, line: 1, size: 16, elements: !13)
 !13 = !{!14}
 !14 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !12, file: !1, line: 2, baseType: !15, size: 16)
 !15 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 16)
 !16 = !{!17, !18}
 !17 = !DILocalVariable(name: "y", arg: 1, scope: !6, file: !1, line: 5, type: !10)
 !18 = !DILocalVariable(name: "p", arg: 2, scope: !6, file: !1, line: 5, type: !11)
 !19 = !DILocation(line: 0, scope: !6)
 !20 = !DILocation(line: 7, column: 3, scope: !6)
+

llvm/test/DebugInfo/MSP430/dwarf-basics.ll

 ;   {
 ;     return 42;
 ;   }
 ;
 
 ; CHECK: file format elf32-msp430
 
 ; CHECK: .debug_info contents:
-; CHECK: Compile Unit: length = 0x{{.*}}, format = DWARF32, version = 0x0003, abbr_offset = 0x0000, addr_size = 0x02 (next unit at 0x{{.*}})
+; CHECK: Compile Unit: length = 0x{{.*}}, format = DWARF32, version = 0x0003, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x{{.*}})
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_AT_producer    ("clang version 11.0.0 (git@...)")
 ; CHECK:   DW_AT_language    (DW_LANG_C99)
 ; CHECK:   DW_AT_name        ("dwarf-basics.c")
 ; CHECK:   DW_AT_stmt_list   (0x{{.*}})
 ; CHECK:   DW_AT_comp_dir    ("/tmp")
 ; CHECK:   DW_AT_low_pc      (0x{{.*}})
 ; CHECK:   DW_AT_high_pc     (0x{{.*}})
 
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_low_pc    (0x{{.*}})
 ; CHECK:     DW_AT_high_pc   (0x{{.*}})
 ; CHECK:     DW_AT_frame_base        (DW_OP_reg1 SP)
 ; CHECK:     DW_AT_name      ("f")
 ; CHECK:     DW_AT_decl_file ("/tmp{{[/\\]}}dwarf-basics.c")
 ; CHECK:     DW_AT_decl_line (5)
 ; CHECK:     DW_AT_prototyped        (0x01)
 ; CHECK:     DW_AT_type      (0x{{.*}} "int")
 ; CHECK:     DW_AT_external  (0x01)
 
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_location        (0x{{.*}}:
-; CHECK:            [0x0000, 0x0004): DW_OP_reg12 R12)
+; CHECK:            [0x00000000, 0x00000004): DW_OP_reg12 R12)
 ; CHECK:         DW_AT_name    ("y")
 ; CHECK:         DW_AT_decl_file       ("/tmp{{[/\\]}}dwarf-basics.c")
 ; CHECK:         DW_AT_decl_line       (5)
 ; CHECK:         DW_AT_type    (0x{{.*}} "long int")
 
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_location        (DW_OP_reg14 R14)
 ; CHECK:         DW_AT_name    ("p")

llvm/test/DebugInfo/MSP430/ranges_always.ll

 ; RUN: llc -O0 %s -mtriple=msp430 -filetype=obj -o - -minimize-addr-in-v5=Ranges \
 ; RUN:   | llvm-dwarfdump -debug-info -debug-addr -debug-rnglists -v - \
 ; RUN:   | FileCheck --check-prefix=CHECK --check-prefix=RNG \
 ; RUN:     --implicit-check-not=DW_TAG --implicit-check-not=NULL --implicit-check-not=_pc %s
 
 ; RUN: llc -O0 %s -mtriple=msp430 -filetype=obj -o - -minimize-addr-in-v5=Expressions \
 ; RUN:   | llvm-dwarfdump -debug-info -debug-addr -debug-rnglists -v - \
 ; RUN:   | FileCheck --check-prefix=CHECK --check-prefix=EXPRORFORM --check-prefix=EXPR\
 ; RUN:     --implicit-check-not=DW_TAG --implicit-check-not=NULL --implicit-check-not=_pc %s
 
 ; RUN: llc -O0 %s -mtriple=msp430 -filetype=obj -o - -minimize-addr-in-v5=Form \
 ; RUN:   | llvm-dwarfdump -debug-info -debug-addr -debug-rnglists -v - \
 ; RUN:   | FileCheck --check-prefix=CHECK --check-prefix=EXPRORFORM --check-prefix=FORM \
 ; RUN:     --implicit-check-not=DW_TAG --implicit-check-not=NULL --implicit-check-not=_pc %s
 
 ; Ported from X86 test to cover 2-byte address size case
+; Check that 16-bit addresses of MSP430 are properly stored
+; in 32-bit DWARF fields
 
 ; Generated from the following source. f4 is used to put a hole in the CU
 ; ranges while keeping f2 and f4 in the same section (as opposed to
 ; -ffunction-sections, which would produce CU ranges, but each function would
 ; be in a different section, so unable to share addresses). The call to f1 at
 ; the start of f3 ensures the range for the inlined subroutine doesn't share
 ; the starting address with f3 (so it can be improved by using a rnglist to
 ; allow it to share an address it wouldn't already be sharing).

 ; void f5() {
 ; }
 ; __attribute__((section(".other"))) void f6() {
 ; }
 
 ; CHECK-LABEL: .debug_info contents:
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_AT_low_pc
-; CHECK-SAME: (0x0000)
+; CHECK-SAME: (0x00000000)
 ; RNG:     DW_AT_ranges
 ; RNG-SAME:  (indexed (0x3) rangelist = [[CU_RANGE:.*]]
 ; EXPRORFORM: DW_AT_ranges
 ; EXPRORFORM-SAME: (indexed (0x0) rangelist = [[CU_RANGE:.*]]
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_low_pc
-; CHECK-SAME:  (indexed (00000000) address = 0x0000 ".text")
+; CHECK-SAME:  (indexed (00000000) address = 0x00000000 ".text")
 ; CHECK:     DW_AT_high_pc
 ; CHECK-SAME:  (0x00000002)
 ; CHECK:     DW_AT_name
 ; CHECK-SAME:  "f1"
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_name
 ; CHECK-SAME:  "f2"
 ; CHECK:   DW_TAG_subprogram
 ; EXPR:      DW_AT_low_pc
 ; EXPR-SAME:   (DW_OP_addrx 0x0, DW_OP_const4u 0x2, DW_OP_plus)
 ; FORM:      DW_AT_low_pc
-; FORM-SAME:   [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0x2 address = 0x0002 ".text")
+; FORM-SAME:   [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0x2 address = 0x00000002 ".text")
 ; EXPRORFORM: DW_AT_high_pc
 ; EXPRORFORM-SAME: (0x0000000a)
 ; RNG:       DW_AT_ranges
 ; RNG-SAME:    (indexed (0x0) rangelist = [[F3_RANGE:.*]]
 ; CHECK:     DW_AT_name
 ; CHECK-SAME: "f3"
 ; CHECK:     DW_TAG_inlined_subroutine
 ; EXPR:        DW_AT_low_pc
 ; EXPR-SAME:     [DW_FORM_exprloc] (DW_OP_addrx 0x0, DW_OP_const4u 0x6, DW_OP_plus)
 ; FORM:        DW_AT_low_pc
-; FORM-SAME:     [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0x6 address = 0x0006 ".text")
+; FORM-SAME:     [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0x6 address = 0x00000006 ".text")
 ; EXPRORFORM:  DW_AT_high_pc
 ; EXPRORFORM-SAME: (0x00000004)
 ; RNG:         DW_AT_ranges
 ; RNG-SAME:      (indexed (0x1) rangelist = [[INL_RANGE:.*]]
 ; CHECK:     DW_TAG_call_site
 ; RNG:         DW_AT_call_return_pc
-; RNG-SAME:      (indexed (00000001) address = 0x0006 ".text")
+; RNG-SAME:      (indexed (00000001) address = 0x00000006 ".text")
 ; EXPR:        DW_AT_call_return_pc
 ; EXPR-SAME:     [DW_FORM_exprloc] (DW_OP_addrx 0x0, DW_OP_const4u 0x6, DW_OP_plus)
 ; FORM:        DW_AT_call_return_pc
-; FORM-SAME:     [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0x6 address = 0x0006 ".text")
+; FORM-SAME:     [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0x6 address = 0x00000006 ".text")
 ; CHECK:     DW_TAG_call_site
 ; RNG:         DW_AT_call_return_pc
-; RNG-SAME:      (indexed (00000002) address = 0x000a ".text")
+; RNG-SAME:      (indexed (00000002) address = 0x0000000a ".text")
 ; EXPR:        DW_AT_call_return_pc
 ; EXPR-SAME:     [DW_FORM_exprloc] (DW_OP_addrx 0x0, DW_OP_const4u 0xa, DW_OP_plus)
 ; FORM:        DW_AT_call_return_pc
-; FORM-SAME:     [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0xa address = 0x000a ".text")
+; FORM-SAME:     [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0xa address = 0x0000000a ".text")
 ; CHECK:     NULL
 ; CHECK:   DW_TAG_subprogram
 ; EXPR:      DW_AT_low_pc
 ; EXPR-SAME:   [DW_FORM_exprloc] (DW_OP_addrx 0x0, DW_OP_const4u 0xe, DW_OP_plus)
 ; FORM:      DW_AT_low_pc
-; FORM-SAME:   [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0xe address = 0x000e ".text")
+; FORM-SAME:   [DW_FORM_LLVM_addrx_offset] (indexed (00000000) + 0xe address = 0x0000000e ".text")
 ; EXPRORFORM: DW_AT_high_pc
 ; EXPRORFORM-SAME: (0x00000002)
 ; RNG:       DW_AT_ranges
 ; RNG-SAME:    (indexed (0x2) rangelist = [[F5_RANGE:.*]]
 ; CHECK:     DW_AT_name
 ; CHECK-SAME:  "f5"
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (
 ; RNG-SAME: 00000003
 ; EXPRORFORM-SAME: 00000001
-; CHECK: ) address = 0x0000 ".other")
+; CHECK: ) address = 0x00000000 ".other")
 ; CHECK:     DW_AT_high_pc
 ; CHECK-SAME:  (0x00000006)
 ; CHECK:     DW_AT_name
 ; CHECK-SAME: "f6"
 ; CHECK:       DW_TAG_inlined_subroutine
 ; RNG:           DW_AT_low_pc
-; RNG-SAME:        (indexed (00000003) address = 0x0000 ".other")
+; RNG-SAME:        (indexed (00000003) address = 0x00000000 ".other")
 ; EXPRORFORM:    DW_AT_low_pc
-; EXPRORFORM-SAME: (indexed (00000001) address = 0x0000 ".other")
+; EXPRORFORM-SAME: (indexed (00000001) address = 0x00000000 ".other")
 ; CHECK:         DW_AT_high_pc
 ; CHECK-SAME:      (0x00000004)
 ; CHECK:       DW_TAG_call_site
 ; CHECK:         DW_AT_call_return_pc
 ; CHECK:       NULL
 ; CHECK:   NULL
 
 ; CHECK-LABEL: .debug_addr contents:
 ; CHECK: 0x00000000: Address table
 ; CHECK-NEXT: Addrs: [
-; CHECK-NEXT: 0x0000
-; RNG-NEXT:   0x0006
-; RNG-NEXT:   0x000a
-; CHECK-NEXT: 0x0000
-; RNG-NEXT:   0x0004
+; CHECK-NEXT: 0x00000000
+; RNG-NEXT:   0x00000006
+; RNG-NEXT:   0x0000000a
+; CHECK-NEXT: 0x00000000
+; RNG-NEXT:   0x00000004
 ; CHECK-NEXT: ]
 
 ; CHECK-LABEL: .debug_rnglists contents:
 ; RNG: 0x00000000: range list header: {{.*}}, offset_entry_count = 0x00000004
 ; EXPRORFORM: 0x00000000: range list header: {{.*}}, offset_entry_count = 0x00000001
 ; CHECK: ranges:
 ; RNG-NEXT:   [[F3_RANGE]]: [DW_RLE_base_addressx]:
-; RNG-SAME:                   0x0000
+; RNG-SAME:                   0x00000000
 ; RNG-NEXT:                 [DW_RLE_offset_pair  ]
 ; RNG-NEXT:                 [DW_RLE_end_of_list  ]
 
 ; RNG-NEXT:   [[INL_RANGE]]: [DW_RLE_base_addressx]:
-; RNG-SAME:                    0x0000
+; RNG-SAME:                    0x00000000
 ; RNG-NEXT:                  [DW_RLE_offset_pair  ]
 ; RNG-NEXT:                  [DW_RLE_end_of_list  ]
 
 ; RNG-NEXT:   [[F5_RANGE]]: [DW_RLE_base_addressx]:
-; RNG-SAME:                   0x0000
+; RNG-SAME:                   0x00000000
 ; RNG-NEXT:                 [DW_RLE_offset_pair  ]
 ; RNG-NEXT:                 [DW_RLE_end_of_list  ]
 
 ; CHECK-NEXT: [[CU_RANGE]]: [DW_RLE_base_addressx]:
-; CHECK-SAME:                 0x0000
+; CHECK-SAME:                 0x00000000
 ; CHECK-NEXT:               [DW_RLE_offset_pair  ]
 ; CHECK-NEXT:               [DW_RLE_offset_pair  ]
 ; RNG-NEXT:                 [DW_RLE_startx_length]:
-; RNG-SAME:                   0x0003
+; RNG-SAME:                   0x00000003
 ; EXPRORFORM-NEXT:          [DW_RLE_startx_length]:
-; EXPRORFORM-SAME:            0x0001
+; EXPRORFORM-SAME:            0x00000001
 ; CHECK-NEXT:               [DW_RLE_end_of_list  ]
 
 ; Function Attrs: mustprogress noinline nounwind optnone uwtable
 define dso_local void @_Z2f1v() local_unnamed_addr #0 !dbg !7 {
 entry:
   ret void, !dbg !12
 }