[CodeView] Emit static data members as S_CONSTANTs.

[akhuang]

Summary

We used to only emit static const data members in CodeView as
S_CONSTANTS when they were used; this patch makes it so they are always emitted.

I changed CodeViewDebug.cpp to find the static const members from the
class debug info instead of creating DIGlobalVariables in the IR
whenever a static const data member is used.

Bug: https://bugs.llvm.org/show_bug.cgi?id=47580

[dblaikie]

I'll probably leave the llvm/CodeView parts of this for @rnk - but for the clang parts, they should have corresponding clang test coverage & I'd be curious to see the test for that to understand what the IR was before/after this change. (& to understand if/how either of those differ from the DWARF IR)

[akhuang]

In D89072#2320209, @dblaikie wrote:

I'll probably leave the llvm/CodeView parts of this for @rnk - but for the clang parts, they should have corresponding clang test coverage & I'd be curious to see the test for that to understand what the IR was before/after this change. (& to understand if/how either of those differ from the DWARF IR)

Oh, I forgot to update the clang tests. The clang change reverts https://reviews.llvm.org/D62167, which made the IR for CodeView different (adding DIGlobalVariables for static members).

[akhuang]

Update clang test for static data members, and make it test the general cases
on the windows target as well.

[dblaikie]

clang/test/CodeGenCXX/debug-info-static-member.cpp

144–147

Bug or feature? If it's a bug, probably should at least make this comment a "FIXME"

[rnk]

clang/test/CodeGenCXX/debug-info-static-member.cpp

144–147

Feature. The easiest way to understand it is to hallucinate the C++17 inline keyword on MSVC static const integer data members with inline initializers. This metadata is probably emitted in MS mode, but it probably comes later on.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

3149

Let's move this past the continue so we don't construct the name unless the value is non-null.

3171

This makes me suspect that we still have bugs in the original S_CONSTANT code. Looks like this is a pre-existing bug:

$ cat t.cpp
static const signed int gv_signed = 0xFFFFFFFF;
const signed int useit2() { return gv_signed; }

$ clang-cl -c -Z7 t.cpp  && llvm-pdbutil dump -symbols t.obj | grep -A1 S_CONST
       0 | S_CONSTANT [size = 28] `gv_signed`
           type = 0x1000 (const int), value = 18446744073709551615

$ cl -c -Z7 t.cpp  && llvm-pdbutil dump -symbols t.obj | grep -A1 S_CONST
Microsoft (R) C/C++ Optimizing Compiler Version 19.27.29111 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

t.cpp
       0 | S_CONSTANT [size = 21] `gv_signed`
           type = 0x1000 (const int), value = -1

Can you re-structure this so that we aren't duplicating the calls to mapEncodedInteger in two places? mapEncodedInteger takes an APInt, which carries a sign already. We just have to use the type information to correct the sign on Value.

[akhuang]

address comments

[akhuang]

clang/test/CodeGenCXX/debug-info-static-member.cpp

144–147

Oh, ok. I don't think the metadata for const_va is emitted anywhere in MS mode though. I guess it should be.

[dblaikie]

clang/test/CodeGenCXX/debug-info-static-member.cpp

144–147

Not quite sure I follow - even though it's "inline" and thus the actual storage for the variable isn't emitted here (because it's just emitted anywhere it's needed, so the definition can be ignored)...

Oh, because the definition is the only root holding the type alive in this file - yeah, if the definition is ignored, the type won't be emitted, etc. Fair enough. Test might be fixed to be more portable by making the type referenced otherwise (eg: declaring a variable that is a pointer to this type, maybe)

Oh, but right... yeah, the virtual dtor is there specifically to test the case where there is no type definition.

As to "const_va is not emitted anywhere in MS mode" - I'd have expected it to be emitted if the type definition is emitted:

!6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "x", file: !3, line: 1, size: 8, flags: DIFlagTypePassByValue, elements: !7, identifier: "_ZTS1x")
!7 = !{!8}
!8 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !6, file: !3, line: 1, baseType: !9, flags: DIFlagStaticMember, extraData: i32 42)

Something like that. But, yeah, if you use a type to hold some constants but never emit the type definition anywhere - then you'd never get the static member, I suppose.

[rnk]

Looks good with a test for explicit zero initialization.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

3159

What about zero constants like:

struct Foo {
  static const int sdm = 0;
};

I think isNullValue just compares against zero, so that's not quite right. Maybe structure it as if ConstantInt / else if ConstantFP / else continue?

[rnk]

It seems like there are related test failures according to the Phabricator/Jenkins automation. Is that a true positive? Please confirm either way before landing.

[akhuang]

Whoops, forgot to check the tests. Apparently mapEncodedInteger asserts if a signed APInt is not less than 0. I just removed the assert because it doesn't seem necessary?

[akhuang]

Fix test failures; remove assert for signed APSInts.

[rnk]

lgtm

Please fix this case in a follow-up, though:

static const signed int gv_signed = 0xFFFFFFFF;
const signed int useit2() { return gv_signed; }

I think your APSInt code only works on static data member constants.

[akhuang]

Patch to emit signed ints for other S_CONSTANTs: https://reviews.llvm.org/D90199

[akhuang]

Reverted because my copied isUnsignedDIType function had problems (guess I copied it at first but then was messing with the code); I moved it to DebugHandlerBase.h so it doesn't need to be copied.

[akhuang]

Moved isUnsignedDIType to DebugHandlerBase to avoid copying it.

clang/lib/CodeGen/CGDebugInfo.cpp

if (CGM.getCodeGenOpts().EmitCodeView) {
       llvm::DIType *EDTy =
           getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
       assert (EDTy->getTag() == llvm::dwarf::DW_TAG_enumeration_type);
       (void)EDTy;
       return;
     }
   }
 
-  llvm::DIScope *DContext = nullptr;
-
   // Do not emit separate definitions for function local consts.
   if (isa<FunctionDecl>(VD->getDeclContext()))
     return;
 
-  // Emit definition for static members in CodeView.
   VD = cast<ValueDecl>(VD->getCanonicalDecl());
   auto *VarD = dyn_cast<VarDecl>(VD);
   if (VarD && VarD->isStaticDataMember()) {
     auto *RD = cast<RecordDecl>(VarD->getDeclContext());
     getDeclContextDescriptor(VarD);
     // Ensure that the type is retained even though it's otherwise unreferenced.
     //
     // FIXME: This is probably unnecessary, since Ty should reference RD
     // through its scope.
     RetainedTypes.push_back(
         CGM.getContext().getRecordType(RD).getAsOpaquePtr());
 
-    if (!CGM.getCodeGenOpts().EmitCodeView)
-      return;
-
-    // Use the global scope for static members.
-    DContext = getContextDescriptor(
-        cast<Decl>(CGM.getContext().getTranslationUnitDecl()), TheCU);
-  } else {
-    DContext = getDeclContextDescriptor(VD);
   }
+  llvm::DIScope *DContext = getDeclContextDescriptor(VD);
 
   auto &GV = DeclCache[VD];
   if (GV)
     return;
   llvm::DIExpression *InitExpr = nullptr;
   if (CGM.getContext().getTypeSize(VD->getType()) <= 64) {
     // FIXME: Add a representation for integer constants wider than 64 bits.
     if (Init.isInt())

clang/test/CodeGenCXX/debug-info-static-member.cpp

-// RUN: %clangxx -target x86_64-unknown-unknown -g %s -emit-llvm -S -o - | FileCheck %s
-// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++98 %s -emit-llvm -S -o - | FileCheck %s
-// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++11 %s -emit-llvm -S -o - | FileCheck %s
-// RUN: %clang_cc1 -triple x86_64-windows-msvc -gcodeview -debug-info-kind=limited %s -emit-llvm -o - | FileCheck --check-prefix MSVC %s
+// RUN: %clangxx -target x86_64-unknown-unknown -g %s -emit-llvm -S -o - | FileCheck --check-prefixes=CHECK,NOT-MS %s
+// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++98 %s -emit-llvm -S -o - | FileCheck --check-prefixes=CHECK,NOT-MS %s
+// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++11 %s -emit-llvm -S -o - | FileCheck --check-prefixes=CHECK,NOT-MS %s
+// RUN: %clangxx -target x86_64-windows-msvc -g %s -emit-llvm -S -o - | FileCheck --check-prefixes=CHECK %s
 // PR14471
 
-// CHECK: @_ZN1C1aE = dso_local global i32 4, align 4, !dbg [[A:![0-9]+]]
-// CHECK: @_ZN1C1bE = dso_local global i32 2, align 4, !dbg [[B:![0-9]+]]
-// CHECK: @_ZN1C1cE = dso_local global i32 1, align 4, !dbg [[C:![0-9]+]]
+// CHECK: @{{.*}}a{{.*}} = dso_local global i32 4, align 4, !dbg [[A:![0-9]+]]
+// CHECK: @{{.*}}b{{.*}} = dso_local global i32 2, align 4, !dbg [[B:![0-9]+]]
+// CHECK: @{{.*}}c{{.*}} = dso_local global i32 1, align 4, !dbg [[C:![0-9]+]]
 
 enum X {
   Y
 };
 class C
 {
   static int a;
   const static bool const_a = true;

 
 // The definition of C::a drives the emission of class C, which is
 // why the definition of "a" comes before the declarations while
 // "b" and "c" come after.
 
 // CHECK: [[A]] = !DIGlobalVariableExpression(var: [[AV:.*]], expr: !DIExpression())
 // CHECK: [[AV]] = distinct !DIGlobalVariable(name: "a",
 // CHECK-SAME:                                declaration: ![[DECL_A:[0-9]+]])
-// MSVC: distinct !DIGlobalVariable(name: "a"
 //
-// CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "X"{{.*}}, identifier: "_ZTS1X")
+// CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "X"{{.*}})
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "anon_static_decl_struct"
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "anon_static_decl_var"
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "static_decl_templ<int>"
 // CHECK-NOT:              DIFlagFwdDecl
 // CHECK-SAME:             ){{$}}
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "static_decl_templ_var"
 
 int C::a = 4;
 // CHECK: [[B]] = !DIGlobalVariableExpression(var: [[BV:.*]], expr: !DIExpression())
 // CHECK: [[BV]] = distinct !DIGlobalVariable(name: "b",
 // CHECK-SAME:                                declaration: ![[DECL_B:[0-9]+]])
-// MSVC: distinct !DIGlobalVariable(name: "b"
 // CHECK: ![[DECL_B]] = !DIDerivedType(tag: DW_TAG_member, name: "b"
 // CHECK-NOT:                                 size:
 // CHECK-NOT:                                 align:
 // CHECK-NOT:                                 offset:
 // CHECK-SAME:                                flags: DIFlagProtected | DIFlagStaticMember)
 //
-// CHECK: !DICompositeType(tag: DW_TAG_class_type, name: "C"{{.*}}, identifier: "_ZTS1C")
+// CHECK: !DICompositeType(tag: DW_TAG_class_type, name: "C"{{.*}})
 //
 // CHECK: ![[DECL_A]] = !DIDerivedType(tag: DW_TAG_member, name: "a"
 // CHECK-NOT:                                 size:
 // CHECK-NOT:                                 align:
 // CHECK-NOT:                                 offset:
 // CHECK-SAME:                                flags: DIFlagStaticMember)
 //
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "const_a"

 // CHECK-SAME:           extraData: i32 18)
 //
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "x_a"
 // CHECK-SAME:           flags: DIFlagPublic | DIFlagStaticMember)
 
 int C::b = 2;
 // CHECK: [[C]] = !DIGlobalVariableExpression(var: [[CV:.*]], expr: !DIExpression())
 // CHECK: [[CV]] = distinct !DIGlobalVariable(name: "c", {{.*}} declaration: ![[DECL_C]])
-// MSVC: distinct !DIGlobalVariable(name: "c"
 int C::c = 1;
 
 int main()
 {
         C instance_C;
         instance_C.d = 8;
         return C::c;
 }
 
 // CHECK-NOT: !DIGlobalVariable(name: "anon_static_decl_var"
 
 // Test this in an anonymous namespace to ensure the type is retained even when
 // it doesn't get automatically retained by the string type reference machinery.
 namespace {
 struct anon_static_decl_struct {
   static const int anon_static_decl_var = 117;
 };
 }
 
 int ref() {
   return anon_static_decl_struct::anon_static_decl_var;
 }
 
-// In MSVC, static data members should be emitted as global variables when used.
-// MSVC: !DIGlobalVariableExpression(var: [[ANON_STATIC_DECL:![0-9]+]],
-// MSVC-SAME: !DIExpression(DW_OP_constu, 117, DW_OP_stack_value)
-// MSVC: [[ANON_STATIC_DECL]] = distinct !DIGlobalVariable(name: "anon_static_decl_var"
-// MSVC: !DIGlobalVariableExpression(var: [[STATIC_DECL_TEMPL:![0-9]+]]
-// MSVC-SAME: !DIExpression(DW_OP_constu, 7, DW_OP_stack_value)
-// MSVC: [[STATIC_DECL_TEMPL]] = distinct !DIGlobalVariable(name: "static_decl_templ_var"
-
 template<typename T>
 struct static_decl_templ {
   static const int static_decl_templ_var = 7;
 };
 
 template<typename T>
 const int static_decl_templ<T>::static_decl_templ_var;
 
 int static_decl_templ_ref() {
   return static_decl_templ<int>::static_decl_templ_var;
 }
 
 // Verify that even when a static member declaration is created lazily when
 // creating the definition, the declaration line is that of the canonical
 // declaration, not the definition. Also, since we look at the canonical
 // definition, we should also correctly emit the constant value (42) into the
 // debug info.
 struct V {
   virtual ~V(); // cause the definition of 'V' to be omitted by no-standalone-debug optimization
   static const int const_va = 42;
 };
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "const_va",
-// CHECK-SAME:           line: [[@LINE-3]]
-// CHECK-SAME:           extraData: i32 42
+
+// const_va is not emitted for MS targets.
+// NOT-MS: !DIDerivedType(tag: DW_TAG_member, name: "const_va",
+// NOT-MS-SAME:           line: [[@LINE-5]]
+// NOT-MS-SAME:           extraData: i32 42
 const int V::const_va;
 
 namespace x {
 struct y {
 // CHECK: !DIGlobalVariable(name: "z",
 // CHECK-SAME:              scope: [[NS_X:![0-9]+]]
 // CHECK: [[NS_X]] = !DINamespace(name: "x"
   static int z;
 };
 int y::z;
 }

llvm/include/llvm/CodeGen/DebugHandlerBase.h

public:
   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
 
   /// Return Label immediately following the instruction.
   MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
 
   /// If this type is derived from a base type then return base type size.
   static uint64_t getBaseTypeSize(const DIType *Ty);
 
+  /// Return true if type encoding is unsigned.
+  static bool isUnsignedDIType(const DIType *Ty);
+
   const InstructionOrdering &getInstOrdering() const { return InstOrdering; }
 };
 
 } // namespace llvm
 
 #endif

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   DenseMap<const DIScope*, std::unique_ptr<GlobalVariableList> > ScopeGlobals;
 
   // Array of global variables which  need to be emitted into a COMDAT section.
   SmallVector<CVGlobalVariable, 1> ComdatVariables;
 
   // Array of non-COMDAT global variables.
   SmallVector<CVGlobalVariable, 1> GlobalVariables;
 
+  /// List of static const data members to be emitted as S_CONSTANTs.
+  SmallVector<const DIDerivedType *, 4> StaticConstMembers;
+
   /// The set of comdat .debug$S sections that we've seen so far. Each section
   /// must start with a magic version number that must only be emitted once.
   /// This set tracks which sections we've already opened.
   DenseSet<MCSectionCOFF *> ComdatDebugSections;
 
   /// Switch to the appropriate .debug$S section for GVSym. If GVSym, the symbol
   /// of an emitted global value, is in a comdat COFF section, this will switch
   /// to a new .debug$S section in that comdat. This method ensures that the
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
 
   void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
 
   void emitDebugInfoForRetainedTypes();
 
   void emitDebugInfoForUDTs(
       const std::vector<std::pair<std::string, const DIType *>> &UDTs);
 
+  void collectDebugInfoForGlobals();
   void emitDebugInfoForGlobals();
   void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals);
   void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV);
+  void emitStaticConstMemberList();
 
   /// Opens a subsection of the given kind in a .debug$S codeview section.
   /// Returns an end label for use with endCVSubsection when the subsection is
   /// finished.
   MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
   void endCVSubsection(MCSymbol *EndLabel);
 
   /// Opens a symbol record of the given kind. Returns an end label for use with

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

void CodeViewDebug::endModule() {
 
   emitInlineeLinesSubsection();
 
   // Emit per-function debug information.
   for (auto &P : FnDebugInfo)
     if (!P.first->isDeclarationForLinker())
       emitDebugInfoForFunction(P.first, *P.second);
 
-  // Emit global variable debug information.
-  setCurrentSubprogram(nullptr);
-  emitDebugInfoForGlobals();
+  // Get types used by globals without emitting anything.
+  // This is meant to collect all static const data members so they can be
+  // emitted as globals.
+  collectDebugInfoForGlobals();
 
   // Emit retained types.
   emitDebugInfoForRetainedTypes();
 
+  // Emit global variable debug information.
+  setCurrentSubprogram(nullptr);
+  emitDebugInfoForGlobals();
+
   // Switch back to the generic .debug$S section after potentially processing
   // comdat symbol sections.
   switchToDebugSectionForSymbol(nullptr);
 
   // Emit UDT records for any types used by global variables.
   if (!GlobalUDTs.empty()) {
     MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
     emitDebugInfoForUDTs(GlobalUDTs);
void CodeViewDebug::clear() {
   CompleteTypeIndices.clear();
   ScopeGlobals.clear();
 }
 
 void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
                                       const DIDerivedType *DDTy) {
   if (!DDTy->getName().empty()) {
     Info.Members.push_back({DDTy, 0});
+
+    // Collect static const data members.
+    if ((DDTy->getFlags() & DINode::FlagStaticMember) ==
+        DINode::FlagStaticMember)
+      StaticConstMembers.push_back(DDTy);
+
     return;
   }
 
   // An unnamed member may represent a nested struct or union. Attempt to
   // interpret the unnamed member as a DICompositeType possibly wrapped in
   // qualifier types. Add all the indirect fields to the current record if that
   // succeeds, and drop the member if that fails.
   assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
for (const auto *GVE : CU->getGlobalVariables()) {
         // Emit this global variable in a single global symbol section.
         VariableList = &GlobalVariables;
       CVGlobalVariable CVGV = {DIGV, GV};
       VariableList->emplace_back(std::move(CVGV));
     }
   }
 }
 
+void CodeViewDebug::collectDebugInfoForGlobals() {
+  for (const CVGlobalVariable &CVGV : GlobalVariables) {
+    const DIGlobalVariable *DIGV = CVGV.DIGV;
+    const DIScope *Scope = DIGV->getScope();
+    getCompleteTypeIndex(DIGV->getType());
+    getFullyQualifiedName(Scope, DIGV->getName());
+  }
+
+  for (const CVGlobalVariable &CVGV : ComdatVariables) {
+    const DIGlobalVariable *DIGV = CVGV.DIGV;
+    const DIScope *Scope = DIGV->getScope();
+    getCompleteTypeIndex(DIGV->getType());
+    getFullyQualifiedName(Scope, DIGV->getName());
+  }
+}
+
 void CodeViewDebug::emitDebugInfoForGlobals() {
   // First, emit all globals that are not in a comdat in a single symbol
   // substream. MSVC doesn't like it if the substream is empty, so only open
   // it if we have at least one global to emit.
   switchToDebugSectionForSymbol(nullptr);
-  if (!GlobalVariables.empty()) {
+  if (!GlobalVariables.empty() || !StaticConstMembers.empty()) {
     OS.AddComment("Symbol subsection for globals");
     MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
     emitGlobalVariableList(GlobalVariables);
+    emitStaticConstMemberList();
     endCVSubsection(EndLabel);
   }
 
   // Second, emit each global that is in a comdat into its own .debug$S
   // section along with its own symbol substream.
   for (const CVGlobalVariable &CVGV : ComdatVariables) {
     const GlobalVariable *GV = CVGV.GVInfo.get<const GlobalVariable *>();
     MCSymbol *GVSym = Asm->getSymbol(GV);

 // Emit each global variable in the specified array.
 void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) {
   for (const CVGlobalVariable &CVGV : Globals) {
     // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
     emitDebugInfoForGlobal(CVGV);
   }
 }
 
+void CodeViewDebug::emitStaticConstMemberList() {
+  for (const DIDerivedType *DTy : StaticConstMembers) {
+    const DIScope *Scope = DTy->getScope();
+
+    APSInt Value;
+    if (const ConstantInt *CI =
+            dyn_cast_or_null<ConstantInt>(DTy->getConstant()))
+      Value = APSInt(CI->getValue(),
+                     DebugHandlerBase::isUnsignedDIType(DTy->getBaseType()));
+    else if (const ConstantFP *CFP =
+                 dyn_cast_or_null<ConstantFP>(DTy->getConstant()))
+      Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true);
+    else
+      continue;
+
+    std::string QualifiedName = getFullyQualifiedName(Scope, DTy->getName());
+
+    MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT);
+    OS.AddComment("Type");
+    OS.emitInt32(getTypeIndex(DTy->getBaseType()).getIndex());
+    OS.AddComment("Value");
+
+    // Encoded integers shouldn't need more than 10 bytes.
+    uint8_t Data[10];
+    BinaryStreamWriter Writer(Data, llvm::support::endianness::little);
+    CodeViewRecordIO IO(Writer);
+    cantFail(IO.mapEncodedInteger(Value));
+    StringRef SRef((char *)Data, Writer.getOffset());
+    OS.emitBinaryData(SRef);
+
+    OS.AddComment("Name");
+    emitNullTerminatedSymbolName(OS, QualifiedName);
+    endSymbolRecord(SConstantEnd);
+  }
+}
+
 void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
   const DIGlobalVariable *DIGV = CVGV.DIGV;
 
   const DIScope *Scope = DIGV->getScope();
   // For static data members, get the scope from the declaration.
   if (const auto *MemberDecl = dyn_cast_or_null<DIDerivedType>(
           DIGV->getRawStaticDataMemberDeclaration()))
     Scope = MemberDecl->getScope();
   std::string QualifiedName = getFullyQualifiedName(Scope, DIGV->getName());
 
   if (const GlobalVariable *GV =
           CVGV.GVInfo.dyn_cast<const GlobalVariable *>()) {
     // DataSym record, see SymbolRecord.h for more info. Thread local data
     // happens to have the same format as global data.
     MCSymbol *GVSym = Asm->getSymbol(GV);
     SymbolKind DataSym = GV->isThreadLocal()
                              ? (DIGV->isLocalToUnit() ? SymbolKind::S_LTHREAD32
                                                       : SymbolKind::S_GTHREAD32)
                              : (DIGV->isLocalToUnit() ? SymbolKind::S_LDATA32
                                                       : SymbolKind::S_GDATA32);
     MCSymbol *DataEnd = beginSymbolRecord(DataSym);

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) {
   // of this since they're a different type of qualification on the type.
   if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
       BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
     return Ty->getSizeInBits();
 
   return getBaseTypeSize(BaseType);
 }
 
+bool DebugHandlerBase::isUnsignedDIType(const DIType *Ty) {
+  if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
+    // FIXME: Enums without a fixed underlying type have unknown signedness
+    // here, leading to incorrectly emitted constants.
+    if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
+      return false;
+
+    // (Pieces of) aggregate types that get hacked apart by SROA may be
+    // represented by a constant. Encode them as unsigned bytes.
+    return true;
+  }
+
+  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
+    dwarf::Tag T = (dwarf::Tag)Ty->getTag();
+    // Encode pointer constants as unsigned bytes. This is used at least for
+    // null pointer constant emission.
+    // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
+    // here, but accept them for now due to a bug in SROA producing bogus
+    // dbg.values.
+    if (T == dwarf::DW_TAG_pointer_type ||
+        T == dwarf::DW_TAG_ptr_to_member_type ||
+        T == dwarf::DW_TAG_reference_type ||
+        T == dwarf::DW_TAG_rvalue_reference_type)
+      return true;
+    assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
+           T == dwarf::DW_TAG_volatile_type ||
+           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
+    assert(DTy->getBaseType() && "Expected valid base type");
+    return isUnsignedDIType(DTy->getBaseType());
+  }
+
+  auto *BTy = cast<DIBasicType>(Ty);
+  unsigned Encoding = BTy->getEncoding();
+  assert((Encoding == dwarf::DW_ATE_unsigned ||
+          Encoding == dwarf::DW_ATE_unsigned_char ||
+          Encoding == dwarf::DW_ATE_signed ||
+          Encoding == dwarf::DW_ATE_signed_char ||
+          Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
+          Encoding == dwarf::DW_ATE_boolean ||
+          (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
+           Ty->getName() == "decltype(nullptr)")) &&
+         "Unsupported encoding");
+  return Encoding == dwarf::DW_ATE_unsigned ||
+         Encoding == dwarf::DW_ATE_unsigned_char ||
+         Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
+         Ty->getTag() == dwarf::DW_TAG_unspecified_type;
+}
+
 static bool hasDebugInfo(const MachineModuleInfo *MMI,
                          const MachineFunction *MF) {
   if (!MMI->hasDebugInfo())
     return false;
   auto *SP = MF->getFunction().getSubprogram();
   if (!SP)
     return false;
   assert(SP->getUnit());

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 }
 
 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
   assert(Ty);
 
   addSourceLine(Die, Ty->getLine(), Ty->getFile());
 }
 
-/// Return true if type encoding is unsigned.
-static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
-  if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
-    // FIXME: Enums without a fixed underlying type have unknown signedness
-    // here, leading to incorrectly emitted constants.
-    if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
-      return false;
-
-    // (Pieces of) aggregate types that get hacked apart by SROA may be
-    // represented by a constant. Encode them as unsigned bytes.
-    return true;
-  }
-
-  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
-    dwarf::Tag T = (dwarf::Tag)Ty->getTag();
-    // Encode pointer constants as unsigned bytes. This is used at least for
-    // null pointer constant emission.
-    // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
-    // here, but accept them for now due to a bug in SROA producing bogus
-    // dbg.values.
-    if (T == dwarf::DW_TAG_pointer_type ||
-        T == dwarf::DW_TAG_ptr_to_member_type ||
-        T == dwarf::DW_TAG_reference_type ||
-        T == dwarf::DW_TAG_rvalue_reference_type)
-      return true;
-    assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
-           T == dwarf::DW_TAG_volatile_type ||
-           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
-    assert(DTy->getBaseType() && "Expected valid base type");
-    return isUnsignedDIType(DD, DTy->getBaseType());
-  }
-
-  auto *BTy = cast<DIBasicType>(Ty);
-  unsigned Encoding = BTy->getEncoding();
-  assert((Encoding == dwarf::DW_ATE_unsigned ||
-          Encoding == dwarf::DW_ATE_unsigned_char ||
-          Encoding == dwarf::DW_ATE_signed ||
-          Encoding == dwarf::DW_ATE_signed_char ||
-          Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
-          Encoding == dwarf::DW_ATE_boolean ||
-          (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
-           Ty->getName() == "decltype(nullptr)")) &&
-         "Unsupported encoding");
-  return Encoding == dwarf::DW_ATE_unsigned ||
-         Encoding == dwarf::DW_ATE_unsigned_char ||
-         Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
-         Ty->getTag() == dwarf::DW_TAG_unspecified_type;
-}
-
 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
   assert(MO.isFPImm() && "Invalid machine operand!");
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
   APFloat FPImm = MO.getFPImm()->getValueAPF();
 
   // Get the raw data form of the floating point.
   const APInt FltVal = FPImm.bitcastToAPInt();
   const char *FltPtr = (const char *)FltVal.getRawData();
void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
                                  const DIType *Ty) {
   addConstantValue(Die, CI->getValue(), Ty);
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
                                  const DIType *Ty) {
   assert(MO.isImm() && "Invalid machine operand!");
 
-  addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
+  addConstantValue(Die, DD->isUnsignedDIType(Ty), MO.getImm());
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
-  addConstantValue(Die, isUnsignedDIType(DD, Ty), Val);
+  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
   // FIXME: This is a bit conservative/simple - it emits negative values always
   // sign extended to 64 bits rather than minimizing the number of bytes.
   addUInt(Die, dwarf::DW_AT_const_value,
           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
-  addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
+  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
   unsigned CIBitWidth = Val.getBitWidth();
   if (CIBitWidth <= 64) {
     addConstantValue(Die, Unsigned,
                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
     return;
for (const auto *Element : Elements) {
         } else if (DDTy->isStaticMember()) {
           getOrCreateStaticMemberDIE(DDTy);
         } else if (Tag == dwarf::DW_TAG_variant_part) {
           // When emitting a variant part, wrap each member in
           // DW_TAG_variant.
           DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
           if (const ConstantInt *CI =
               dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
-            if (isUnsignedDIType(DD, Discriminator->getBaseType()))
+            if (DD->isUnsignedDIType(Discriminator->getBaseType()))
               addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
             else
               addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
           }
           constructMemberDIE(Variant, DDTy);
         } else {
           constructMemberDIE(Buffer, DDTy);
         }
if (auto *Element = dyn_cast_or_null<DINode>(Elements[i])) {
         constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
                                     IdxTy);
     }
   }
 }
 
 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
   const DIType *DTy = CTy->getBaseType();
-  bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
+  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
   if (DTy) {
     if (DD->getDwarfVersion() >= 3)
       addType(Buffer, DTy);
     if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
       addFlag(Buffer, dwarf::DW_AT_enum_class);
   }
 
   auto *Context = CTy->getScope();

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

while (!S.empty()) {
         return EC;
     };
   }
   return Error::success();
 }
 
 void CodeViewRecordIO::emitEncodedSignedInteger(const int64_t &Value,
                                                 const Twine &Comment) {
-  assert(Value < 0 && "Encoded integer is not signed!");
   if (Value >= std::numeric_limits<int8_t>::min()) {
     Streamer->emitIntValue(LF_CHAR, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 1);
     incrStreamedLen(3);
   } else if (Value >= std::numeric_limits<int16_t>::min()) {
     Streamer->emitIntValue(LF_SHORT, 2);
     emitComment(Comment);
if (Value < LF_NUMERIC) {
     Streamer->emitIntValue(LF_UQUADWORD, 2);
     emitComment(Comment);
     Streamer->emitIntValue(Value, 8);
     incrStreamedLen(6);
   }
 }
 
 Error CodeViewRecordIO::writeEncodedSignedInteger(const int64_t &Value) {
-  assert(Value < 0 && "Encoded integer is not signed!");
   if (Value >= std::numeric_limits<int8_t>::min()) {
     if (auto EC = Writer->writeInteger<uint16_t>(LF_CHAR))
       return EC;
     if (auto EC = Writer->writeInteger<int8_t>(Value))
       return EC;
   } else if (Value >= std::numeric_limits<int16_t>::min()) {
     if (auto EC = Writer->writeInteger<uint16_t>(LF_SHORT))
       return EC;

llvm/test/DebugInfo/COFF/global-constants.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
 
 ; // C++ source to regenerate:
 ; namespace Test1 {
 ; const float TestConst1 = 3.14;
 ; }
 ; struct S {
 ;   static const int TestConst2 = -10;
+;   // Unused static consts should still be emitted.
+;   static const int TestConst3 = 3;
+;   static constexpr int TestConst 4 = 4;
 ;   enum { SEnum = 42 };
 ; };
 ; enum TestEnum : int {
 ;   ENUM_A = 2147000000,
 ;   ENUM_B = -2147000000,
 ; };
 ; void useConst(int);
 ; void foo() {

 ; ASM-NEXT:   .long 4099                    # Type
 ; ASM-NEXT:   .byte 0x04, 0x80, 0xc3, 0xf5  # Value
 ; ASM-NEXT:   .byte 0x48, 0x40
 ; ASM-NEXT:   .asciz  "Test1::TestConst1"     # Name
 ; ASM-NEXT:   .p2align  2
 
 ; ASM:        .short  4359                    # Record kind: S_CONSTANT
 ; ASM-NEXT:   .long 4101                    # Type
-; ASM-NEXT:   .byte 0x0a, 0x80, 0xf6, 0xff  # Value
-; ASM-NEXT:   .byte 0xff, 0xff, 0xff, 0xff
-; ASM-NEXT:   .byte 0xff, 0xff
-; ASM-NEXT:   .asciz  "S::TestConst2"         # Name
-; ASM-NEXT:   .p2align  2
-
-; ASM:        .short  4359                    # Record kind: S_CONSTANT
-; ASM-NEXT:   .long 4110                    # Type
 ; ASM-NEXT:   .byte 0x0a, 0x80, 0x40, 0x61  # Value
 ; ASM-NEXT:   .byte 0x07, 0x80, 0xff, 0xff
 ; ASM-NEXT:   .byte 0xff, 0xff
 ; ASM-NEXT:   .asciz  "ENUM_B"                # Name
 ; ASM-NEXT:   .p2align  2
 ; ASM-NOT:    .asciz "S::SEnum"             # Name
 
+; ASM:        .short  4359                    # Record kind: S_CONSTANT
+; ASM-NEXT:   .long 4105                    # Type
+; ASM-NEXT:   .byte 0x00, 0x80, 0xf6        # Value
+; ASM-NEXT:   .asciz  "S::TestConst2"         # Name
+; ASM-NEXT:   .p2align  2
+
 ; OBJ:        CodeViewDebugInfo [
 ; OBJ:          Section: .debug$S
 ; OBJ:          Magic: 0x4
 ; OBJ:          Subsection [
 ; OBJ:            SubSectionType: Symbols (0xF1)
 ; OBJ:            ConstantSym {
 ; OBJ-NEXT:         Kind: S_CONSTANT (0x1107)
 ; OBJ-NEXT:         Type: const float (0x1003)
 ; OBJ-NEXT:         Value: 1078523331
 ; OBJ-NEXT:         Name: Test1::TestConst1
 ; OBJ-NEXT:       }
 ; OBJ-NEXT:       ConstantSym {
 ; OBJ-NEXT:         Kind: S_CONSTANT (0x1107)
-; OBJ-NEXT:         Type: const int (0x1005)
-; OBJ-NEXT:         Value: 18446744073709551606
-; OBJ-NEXT:         Name: S::TestConst2
-; OBJ-NEXT:       }
-; OBJ-NEXT:       ConstantSym {
-; OBJ-NEXT:         Kind: S_CONSTANT (0x1107)
-; OBJ-NEXT:         Type: TestEnum (0x100E)
+; OBJ-NEXT:         Type: TestEnum (0x1005)
 ; OBJ-NEXT:         Value: 18446744071562551616
 ; OBJ-NEXT:         Name: ENUM_B
 ; OBJ-NEXT:       }
 ; OBJ-NOT:          Name: S::SEnum
+; OBJ-NEXT:       ConstantSym {
+; OBJ-NEXT:         Kind: S_CONSTANT (0x1107)
+; OBJ-NEXT:         Type: const int (0x1009)
+; OBJ-NEXT:         Value: -10
+; OBJ-NEXT:         Name: S::TestConst2
+; OBJ-NEXT:       }
 
 ; ModuleID = 'a.cpp'
 source_filename = "a.cpp"
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.25.28614"
 
 ; Function Attrs: noinline optnone uwtable
 define dso_local void @"?foo@@YAXXZ"() #0 !dbg !31 {

 
 attributes #0 = { noinline optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!26, !27, !28, !29}
 !llvm.ident = !{!30}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 11.0.0 (https://github.com/llvm/llvm-project.git 202f144bffd0be254a829924195e1b8ebabcbb79)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !15, globals: !16, nameTableKind: None)
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 12.0.0 (https://github.com/llvm/llvm-project.git 34cd06a9b3bddaa7a989c606bbf1327ee651711c)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !17, globals: !18, nameTableKind: None)
 !1 = !DIFile(filename: "a.cpp", directory: "F:\\llvm-project\\__test", checksumkind: CSK_MD5, checksum: "a1dbf3aabea9e8f9d1be48f60287942f")
-!2 = !{!3, !11}
-!3 = !DICompositeType(tag: DW_TAG_enumeration_type, scope: !4, file: !1, line: 6, baseType: !8, size: 32, elements: !9, identifier: ".?AW4<unnamed-enum-SEnum>@S@@")
+!2 = !{!3, !13}
+!3 = !DICompositeType(tag: DW_TAG_enumeration_type, scope: !4, file: !1, line: 8, baseType: !8, size: 32, elements: !11, identifier: ".?AW4<unnamed-enum-SEnum>@S@@")
 !4 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !1, line: 4, size: 8, flags: DIFlagTypePassByValue, elements: !5, identifier: ".?AUS@@")
-!5 = !{!6, !3}
+!5 = !{!6, !9, !10, !3}
 !6 = !DIDerivedType(tag: DW_TAG_member, name: "TestConst2", scope: !4, file: !1, line: 5, baseType: !7, flags: DIFlagStaticMember, extraData: i32 -10)
 !7 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !8)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!9 = !{!10}
-!10 = !DIEnumerator(name: "SEnum", value: 42)
-!11 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "TestEnum", file: !1, line: 8, baseType: !8, size: 32, elements: !12, identifier: ".?AW4TestEnum@@")
-!12 = !{!13, !14}
-!13 = !DIEnumerator(name: "ENUM_A", value: 2147000000)
-!14 = !DIEnumerator(name: "ENUM_B", value: -2147000000)
-!15 = !{!4}
-!16 = !{!17, !22, !24}
-!17 = !DIGlobalVariableExpression(var: !18, expr: !DIExpression(DW_OP_constu, 1078523331, DW_OP_stack_value))
-!18 = distinct !DIGlobalVariable(name: "TestConst1", scope: !19, file: !1, line: 2, type: !20, isLocal: true, isDefinition: true)
-!19 = !DINamespace(name: "Test1", scope: null)
-!20 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !21)
-!21 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
-!22 = !DIGlobalVariableExpression(var: !23, expr: !DIExpression(DW_OP_constu, 18446744073709551606, DW_OP_stack_value))
-!23 = distinct !DIGlobalVariable(name: "TestConst2", scope: !0, file: !1, line: 5, type: !7, isLocal: true, isDefinition: true, declaration: !6)
+!9 = !DIDerivedType(tag: DW_TAG_member, name: "TestConst3", scope: !4, file: !1, line: 6, baseType: !7, flags: DIFlagStaticMember, extraData: i32 3)
+!10 = !DIDerivedType(tag: DW_TAG_member, name: "TestConst4", scope: !4, file: !1, line: 7, baseType: !7, flags: DIFlagStaticMember, extraData: i32 4)
+!11 = !{!12}
+!12 = !DIEnumerator(name: "SEnum", value: 42)
+!13 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "TestEnum", file: !1, line: 10, baseType: !8, size: 32, elements: !14, identifier: ".?AW4TestEnum@@")
+!14 = !{!15, !16}
+!15 = !DIEnumerator(name: "ENUM_A", value: 2147000000)
+!16 = !DIEnumerator(name: "ENUM_B", value: -2147000000)
+!17 = !{!4}
+!18 = !{!19, !24}
+!19 = !DIGlobalVariableExpression(var: !20, expr: !DIExpression(DW_OP_constu, 1078523331, DW_OP_stack_value))
+!20 = distinct !DIGlobalVariable(name: "TestConst1", scope: !21, file: !1, line: 2, type: !22, isLocal: true, isDefinition: true)
+!21 = !DINamespace(name: "Test1", scope: null)
+!22 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !23)
+!23 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
 !24 = !DIGlobalVariableExpression(var: !25, expr: !DIExpression(DW_OP_constu, 18446744071562551616, DW_OP_stack_value))
-!25 = distinct !DIGlobalVariable(name: "ENUM_B", scope: !0, file: !1, line: 10, type: !11, isLocal: true, isDefinition: true)
+!25 = distinct !DIGlobalVariable(name: "ENUM_B", scope: !0, file: !1, line: 12, type: !13, isLocal: true, isDefinition: true)
 !26 = !{i32 2, !"CodeView", i32 1}
 !27 = !{i32 2, !"Debug Info Version", i32 3}
 !28 = !{i32 1, !"wchar_size", i32 2}
 !29 = !{i32 7, !"PIC Level", i32 2}
-!30 = !{!"clang version 11.0.0 (https://github.com/llvm/llvm-project.git 202f144bffd0be254a829924195e1b8ebabcbb79)"}
-!31 = distinct !DISubprogram(name: "foo", linkageName: "?foo@@YAXXZ", scope: !1, file: !1, line: 13, type: !32, scopeLine: 13, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !34)
+!30 = !{!"clang version 12.0.0 (https://github.com/llvm/llvm-project.git 34cd06a9b3bddaa7a989c606bbf1327ee651711c)"}
+!31 = distinct !DISubprogram(name: "foo", linkageName: "?foo@@YAXXZ", scope: !1, file: !1, line: 15, type: !32, scopeLine: 15, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !34)
 !32 = !DISubroutineType(types: !33)
 !33 = !{null}
 !34 = !{}
-!35 = !DILocation(line: 14, scope: !31)
-!36 = !DILocation(line: 15, scope: !31)
-!37 = !DILocation(line: 16, scope: !31)
-!38 = !DILocation(line: 17, scope: !31)
-!39 = !DILocation(line: 18, scope: !31)
+!35 = !DILocation(line: 16, scope: !31)
+!36 = !DILocation(line: 17, scope: !31)
+!37 = !DILocation(line: 18, scope: !31)
+!38 = !DILocation(line: 19, scope: !31)
+!39 = !DILocation(line: 20, scope: !31)

llvm/test/DebugInfo/COFF/types-array-unsized.ll

 ; RUN: llc -filetype=obj < %s | llvm-readobj --codeview - | FileCheck %s
 ; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj --codeview - | FileCheck %s
 
 ; We should emit two array types: one used to describe the static data member,
 ; and the other used by the S_GDATA32 for the definition.
 
 ; // Build with: clang-cl a.cpp /c /Z7 /clang:-S /clang:-emit-llvm
 ; struct Foo {
 ;   static const char str[];
 ; };
 ; const char Foo::str[] = "asdf";
 ; Foo f; // FIXME: only needed to force emit 'Foo'
 
 ; CHECK:      CodeViewTypes [
+; CHECK:        Array ([[ARRAY_COMPLETE:0x.*]]) {
+; CHECK-NEXT:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK-NEXT:     ElementType: const char ({{.*}})
+; CHECK-NEXT:     IndexType: unsigned __int64 (0x23)
+; CHECK-NEXT:     SizeOf: 5
+; CHECK-NEXT:     Name:
+; CHECK-NEXT:   }
+; CHECK:      ]
 ; CHECK:        Array ([[ARRAY_FWD:0x.*]]) {
 ; CHECK-NEXT:     TypeLeafKind: LF_ARRAY (0x1503)
 ; CHECK-NEXT:     ElementType: const char ({{.*}})
 ; CHECK-NEXT:     IndexType: unsigned __int64 (0x23)
 ; CHECK-NEXT:     SizeOf: 0
-; CHECK-NEXT:     Name: 
+; CHECK-NEXT:     Name:
 ; CHECK-NEXT:   }
-; CHECK:        FieldList (0x1003) {
+; CHECK:        FieldList (0x1004) {
 ; CHECK-NEXT:     TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK-NEXT:     StaticDataMember {
 ; CHECK-NEXT:       TypeLeafKind: LF_STMEMBER (0x150E)
 ; CHECK-NEXT:       AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:       Type: [[ARRAY_FWD]]
 ; CHECK-NEXT:       Name: str
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
-; CHECK:        Array ([[ARRAY_COMPLETE:0x.*]]) {
-; CHECK-NEXT:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK-NEXT:     ElementType: const char ({{.*}})
-; CHECK-NEXT:     IndexType: unsigned __int64 (0x23)
-; CHECK-NEXT:     SizeOf: 5
-; CHECK-NEXT:     Name: 
-; CHECK-NEXT:   }
-; CHECK:      ]
 
 ; CHECK:          GlobalData {
 ; CHECK-NEXT:       Kind: S_GDATA32 (0x110D)
 ; CHECK-NEXT:       DataOffset: ?str@Foo@@2QBDB+0x0
 ; CHECK-NEXT:       Type: [[ARRAY_COMPLETE]]
 ; CHECK-NEXT:       DisplayName: Foo::str
 ; CHECK-NEXT:       LinkageName: ?str@Foo@@2QBDB
 ; CHECK-NEXT:     }