[ELF] - Do not produce duplicate values in .gdb_index's constant pool area.

[grimar]

Summary

I found this when builded llc binary using gcc 5.4.1 + LLD.
gcc produces duplicate entries in .debug_gnu_pubtypes section, ex:

UnifyFunctionExitNodes.cpp.o has:
0x0000ac07 EXTERNAL TYPE "std::success_type<void*>"
0x0000ac07 EXTERNAL TYPE "std::success_type<void*>"

clang produces single entry here:
0x0000d291 EXTERNAL TYPE "std::__success_type<void *>"

If we link output from gcc with LLD, that would produce excessive duplicate
entries in .gdb_index constant pool area. That does not seem affect gdb work,
but makes .gdb_index larger than it can be.

I also checked that gold filters out such duplicates too.

Patch fixes the issue and also simplifies how we store CU index + attributes,
previously they were stored separatelly, that doesn't make sense.

[grimar]

Latest available release of GCC (7.1.0) is also affected: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80628

[grimar]

• Addressed review comments.

[grimar]

Rui, that had LGTM from Rafael about a week ago. Do you have objections about landing this ?

[grimar]

Ping.

[ruiu]

LGTM

ELF/SyntheticSections.h

 
 #ifndef LLD_ELF_SYNTHETIC_SECTION_H
 #define LLD_ELF_SYNTHETIC_SECTION_H
 
 #include "EhFrame.h"
 #include "GdbIndex.h"
 #include "InputSection.h"
 #include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/MC/StringTableBuilder.h"
 
 namespace lld {
 namespace elf {
 
 class SyntheticSection : public InputSection {
 public:
   SyntheticSection(uint64_t Flags, uint32_t Type, uint32_t Alignment,
public:
   // Pairs of [CU Offset, CU length].
   std::vector<std::pair<uint64_t, uint64_t>> CompilationUnits;
 
   llvm::StringTableBuilder StringPool;
 
   GdbHashTab SymbolTable;
 
   // The CU vector portion of the constant pool.
-  std::vector<std::vector<std::pair<uint32_t, uint8_t>>> CuVectors;
+  std::vector<llvm::SmallSetVector<uint32_t, 8>> CuVectors;
 
   std::vector<AddressEntry> AddressArea;
 
 private:
   void readDwarf(InputSection *Sec);
 
   uint32_t CuTypesOffset;
   uint32_t SymTabOffset;

ELF/SyntheticSections.cpp

for (std::pair<StringRef, uint8_t> &Pair : NamesAndTypes) {
     uint32_t Hash = hash(Pair.first);
     size_t Offset = StringPool.add(Pair.first);
 
     bool IsNew;
     GdbSymbol *Sym;
     std::tie(IsNew, Sym) = SymbolTable.add(Hash, Offset);
     if (IsNew) {
       Sym->CuVectorIndex = CuVectors.size();
-      CuVectors.push_back({{CuId, Pair.second}});
-      continue;
+      CuVectors.push_back({});
     }
 
-    CuVectors[Sym->CuVectorIndex].push_back({CuId, Pair.second});
+    CuVectors[Sym->CuVectorIndex].insert(CuId | (Pair.second << 24));
   }
 }
 
 void GdbIndexSection::finalizeContents() {
   if (Finalized)
     return;
   Finalized = true;
 
   for (InputSectionBase *S : InputSections)
     if (InputSection *IS = dyn_cast<InputSection>(S))
       if (IS->OutSec && IS->Name == ".debug_info")
         readDwarf(IS);
 
   SymbolTable.finalizeContents();
 
   // GdbIndex header consist from version fields
   // and 5 more fields with different kinds of offsets.
   CuTypesOffset = CuListOffset + CompilationUnits.size() * CompilationUnitSize;
   SymTabOffset = CuTypesOffset + AddressArea.size() * AddressEntrySize;
 
   ConstantPoolOffset =
       SymTabOffset + SymbolTable.getCapacity() * SymTabEntrySize;
 
-  for (std::vector<std::pair<uint32_t, uint8_t>> &CuVec : CuVectors) {
+  for (llvm::SmallSetVector<uint32_t, 8> &CuVec : CuVectors) {
     CuVectorsOffset.push_back(CuVectorsSize);
     CuVectorsSize += OffsetTypeSize * (CuVec.size() + 1);
   }
   StringPoolOffset = ConstantPoolOffset + CuVectorsSize;
 
   StringPool.finalizeInOrder();
 }
 
if (Sym) {
       size_t CuVectorOffset = CuVectorsOffset[Sym->CuVectorIndex];
       write32le(Buf, NameOffset);
       write32le(Buf + 4, CuVectorOffset);
     }
     Buf += 8;
   }
 
   // Write the CU vectors into the constant pool.
-  for (std::vector<std::pair<uint32_t, uint8_t>> &CuVec : CuVectors) {
+  for (llvm::SmallSetVector<uint32_t, 8> &CuVec : CuVectors) {
     write32le(Buf, CuVec.size());
     Buf += 4;
-    for (std::pair<uint32_t, uint8_t> &P : CuVec) {
-      uint32_t Index = P.first;
-      uint8_t Flags = P.second;
-      Index |= Flags << 24;
-      write32le(Buf, Index);
+    for (uint32_t Val : CuVec) {
+      write32le(Buf, Val);
       Buf += 4;
     }
   }
 
   StringPool.write(Buf);
 }
 
 bool GdbIndexSection::empty() const {

test/ELF/gdb-index-dup-types.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld --gdb-index -e main %t.o -o %t
+# RUN: llvm-dwarfdump -debug-dump=gdb_index %t | FileCheck %s
+
+## Testcase is based on output produced by gcc version 5.4.1 20160904
+## it has duplicate entries in .debug_gnu_pubtypes which seems to be
+## compiler bug. In that case it is useless to have them in .gdb_index
+## and we filter such entries out to reduce size of .gdb_index.
+
+## CHECK: Constant pool offset = {{.*}}, has 1 CU vectors:
+## CHECK-NOT: 0(0x0): 0x90000000 0x90000000
+
+.section .debug_abbrev,"",@progbits
+ .byte 1                       # Abbreviation Code
+ .byte 17                      # DW_TAG_compile_unit
+ .byte 0                       # DW_CHILDREN_no
+ .byte 16                      # DW_AT_stmt_list
+ .byte 23                      # DW_FORM_sec_offset
+ .ascii "\260B"                # DW_AT_GNU_dwo_name
+ .byte 14                      # DW_FORM_strp
+ .byte 27                      # DW_AT_comp_dir
+ .byte 14                      # DW_FORM_strp
+ .ascii "\264B"                # DW_AT_GNU_pubnames
+ .byte 25                      # DW_FORM_flag_present
+ .ascii "\261B"                # DW_AT_GNU_dwo_id
+ .byte 7                       # DW_FORM_data8
+ .ascii "\263B"                # DW_AT_GNU_addr_base
+ .byte 23                      # DW_FORM_sec_offset
+ .byte 0                       # EOM(1)
+ .byte 0                       # EOM(2)
+ .byte 0                       # EOM(3)
+
+.section .debug_info,"",@progbits
+.Lcu_begin0:
+ .long 32                       # Length of Unit
+ .short 4                       # DWARF version number
+ .long .debug_abbrev            # Offset Into Abbrev. Section
+ .byte 8                        # Address Size (in bytes)
+ .byte 1                        # Abbrev [1] 0xb:0x19 DW_TAG_compile_unit
+ .long 0                        # DW_AT_stmt_list
+ .long 0                        # DW_AT_GNU_dwo_name
+ .long 0                        # DW_AT_comp_dir
+ .quad 0                        # DW_AT_GNU_dwo_id
+ .long 0                        # DW_AT_GNU_addr_base
+
+.section .debug_gnu_pubtypes,"",@progbits
+.long .LpubTypes_end0-.LpubTypes_begin0 # Length of Public Types Info
+.LpubTypes_begin0:
+ .short 2                      # DWARF Version
+ .long .Lcu_begin0             # Offset of Compilation Unit Info
+ .long 36                      # Compilation Unit Length
+ .long 36                      # DIE offset
+ .byte 144                     # Kind: TYPE, STATIC
+ .asciz "int"                  # External Name
+ .long 36                      # DIE offset
+ .byte 144                     # Kind: TYPE, STATIC
+ .asciz "int"                  # External Name
+ .long 0                       # End Mark
+.LpubTypes_end0: