[DWARF] Add linkagename to hash

[ayermolo]

Summary

Originally encountered with RUST, but also there are cases with distributed LTO
where debug info dwo units contain structurally the same debug information, with
difference in DW_AT_linkage_name. This causes collision on DWO ID.

[ayermolo]

nit

[dblaikie]

Sounds good

[ayermolo]

rebase

[ayermolo]

rebase

[ayermolo]

rebase

llvm/lib/CodeGen/AsmPrinter/DIEHashAttributes.def

 HANDLE_DIE_HASH_ATTR(DW_AT_upper_bound)
 HANDLE_DIE_HASH_ATTR(DW_AT_use_location)
 HANDLE_DIE_HASH_ATTR(DW_AT_use_UTF8)
 HANDLE_DIE_HASH_ATTR(DW_AT_variable_parameter)
 HANDLE_DIE_HASH_ATTR(DW_AT_virtuality)
 HANDLE_DIE_HASH_ATTR(DW_AT_visibility)
 HANDLE_DIE_HASH_ATTR(DW_AT_vtable_elem_location)
 HANDLE_DIE_HASH_ATTR(DW_AT_type)
-
+HANDLE_DIE_HASH_ATTR(DW_AT_linkage_name)
 #undef HANDLE_DIE_HASH_ATTR

llvm/test/DebugInfo/X86/convert-loclist.ll

 ; RUN: llc -mtriple=x86_64 -filetype=obj < %s \
 ; RUN:   | llvm-dwarfdump -debug-info -debug-loclists - | FileCheck %s
 ; RUN: llc -mtriple=x86_64 -split-dwarf-file=foo.dwo -filetype=obj -dwarf-op-convert=Enable < %s \
 ; RUN:   | llvm-dwarfdump -debug-info -debug-loclists - | FileCheck --check-prefix=SPLIT --check-prefix=CHECK %s
 ; RUN: llc -mtriple=x86_64 -split-dwarf-file=foo.dwo -filetype=asm -dwarf-op-convert=Enable < %s \
 ; RUN:   | FileCheck --check-prefix=ASM %s
 
 ; A bit of a brittle test - this is testing the specific DWO_id. The
 ; alternative would be to test two files with different DW_OP_convert values &
 ; ensuring the DWO IDs differ when the DW_OP_convert parameter differs.
 
 ; So if this test ends up being a brittle pain to maintain, updating the DWO ID
 ; often - add another IR file with a different DW_OP_convert that's otherwise
 ; identical and demonstrate that they have different DWO IDs.
 
-; SPLIT: 0x00000000: Compile Unit: {{.*}} DWO_id = 0xa6edbf487b0a7acf
+; SPLIT: 0x00000000: Compile Unit: {{.*}} DWO_id = 0x4dbee91db55385db
 
 ; Regression testing a fairly quirky bug where instead of hashing (see above),
 ; extra bytes would be emitted into the output assembly in no
 ; particular/intentional section - so let's check they don't show up at all:
 ; ASM-NOT: .asciz  "\200\200\200"
 ; ASM:      .byte   10                              # Loc expr size
 ; ASM-NEXT: .byte   17                              # DW_OP_consts
 ; ASM-NEXT: .byte   7                               # 7

llvm/test/DebugInfo/X86/fission-hash-local.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 < %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o - \
 ; RUN:   | llvm-dwarfdump - | FileCheck --check-prefix=H1 %s
 ; RUN: llc -split-dwarf-file=foo.dwo -O0 < %p/../Inputs/fission-hash-local2.ll -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o - \
 ; RUN:   | llvm-dwarfdump - | FileCheck --check-prefix=H2 %s
 
 ; Testing that the location of a local variable in a global function is hashed
 ; fission-hash-local2.ll is identical except for the value of the local
 ; variable (local.ll uses the constant 7 in the llvm.dbg.value below, local2.ll
 ; uses the constant 9) so it should have a different dwo_id, seen below.
 
 ; Original source:
 ; void f1() {
 ;   int i = 7; // or 9
 ; }
 
-; H1: DW_AT_GNU_dwo_id  (0x03a55a70550ee09b)
-; H2: DW_AT_GNU_dwo_id  (0x826fcafbddebc96b)
+; H1: DW_AT_GNU_dwo_id  (0xc1220cf66b1190ad)
+; H2: DW_AT_GNU_dwo_id  (0xf66067a0cf366f0e)
 
 ; Function Attrs: norecurse nounwind readnone uwtable
 define dso_local void @_Z2f1v() local_unnamed_addr !dbg !7 {
 entry:
   call void @llvm.dbg.value(metadata i32 7, metadata !11, metadata !DIExpression()), !dbg !13
   ret void, !dbg !14
 }
 

llvm/test/DebugInfo/X86/sret.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s --check-prefix=CHECK-DWO
 
 ; Based on the debuginfo-tests/sret.cpp code.
 
-; CHECK-DWO: DW_AT_GNU_dwo_id (0xa58a336e896549f1)
-; CHECK-DWO: DW_AT_GNU_dwo_id (0xa58a336e896549f1)
+; CHECK-DWO: DW_AT_GNU_dwo_id (0x7db1cc8453a47c44)
+; CHECK-DWO: DW_AT_GNU_dwo_id (0x7db1cc8453a47c44)
 
 ; RUN: llc -O0 -fast-isel=true -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -debug-info - | FileCheck -check-prefixes=CHECK,FASTISEL %s
 ; RUN: llc -O0 -fast-isel=false -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -debug-info - | FileCheck -check-prefixes=CHECK,SDAG %s
 ; CHECK: _ZN1B9AInstanceEv
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location (0x00000000
 ; FASTISEL-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg6 RBP-32, DW_OP_deref
 ; FASTISEL-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg5 RDI+0

llvm/unittests/CodeGen/DIEHashTest.cpp

TEST_F(DIEHashTest, TrivialType) {
   Unnamed.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
 
   // Line and file number are ignored.
   Unnamed.addValue(Alloc, dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, One);
   Unnamed.addValue(Alloc, dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, One);
   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 
   // The exact same hash GCC produces for this DIE.
-  ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res);
+  ASSERT_EQ(0x715305CE6CFD9AD1ULL, MD5Res);
 }
 
 // struct foo { };
 TEST_F(DIEHashTest, NamedType) {
   DIE &Foo = *DIE::get(Alloc, dwarf::DW_TAG_structure_type);
   DIEInteger One(1);
   DIEString FooStr = getString("foo");
   Foo.addValue(Alloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp, FooStr);
   Foo.addValue(Alloc, dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, One);
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 
   // The exact same hash GCC produces for this DIE.
-  ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res);
+  ASSERT_EQ(0xD566DBD2CA5265FFULL, MD5Res);
 }
 
 // namespace space { struct foo { }; }
 TEST_F(DIEHashTest, NamespacedType) {
   DIE &CU = *DIE::get(Alloc, dwarf::DW_TAG_compile_unit);
 
   auto Space = DIE::get(Alloc, dwarf::DW_TAG_namespace);
   DIEInteger One(1);
TEST_F(DIEHashTest, MemberFuncFlag) {
   Func->addValue(Alloc, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present,
                  One);
 
   A.addChild(std::move(Func));
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(A);
 
   // The exact same hash GCC produces for this DIE.
-  ASSERT_EQ(0x8f78211ddce3df10ULL, MD5Res);
+  ASSERT_EQ(0x8F78211DDCE3DF10ULL, MD5Res);
 }
 
 // Derived from:
 // struct A {
 //   const static int PI = -3;
 // };
 // A a;
 TEST_F(DIEHashTest, MemberSdata) {
TEST_F(DIEHashTest, MemberSdata) {
   PI->addValue(Alloc, dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, One);
   PI->addValue(Alloc, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present,
                One);
   PI->addValue(Alloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, NegThree);
 
   A.addChild(std::move(PI));
 
   uint64_t MD5Res = DIEHash().computeTypeSignature(A);
-  ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res);
+  ASSERT_EQ(0x9A216000DD3788A7ULL, MD5Res);
 }
 
 // Derived from:
 // struct A {
 //   const static float PI = 3.14;
 // };
 // A a;
 TEST_F(DIEHashTest, MemberBlock) {
TEST_F(DIEHashTest, MemberBlock) {
   PIBlock.addValue(Alloc, (dwarf::Attribute)0, dwarf::DW_FORM_data1, Blk4);
 
   PI->addValue(Alloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_block1,
                &PIBlock);
 
   A.addChild(std::move(PI));
 
   uint64_t MD5Res = DIEHash(this->getAsmPrinter()).computeTypeSignature(A);
-  ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res);
+  ASSERT_EQ(0x493AF53AD3D3F651ULL, MD5Res);
 }
 }