[ELF] - Simplify implementation of constant pool when building .gdb_index

[grimar]

Summary

https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html says:
"A CU vector in the constant pool is a sequence of offset_type values. The first value is the number of CU indices in the vector. Each subsequent value is the index and symbol attributes of a CU in the CU list."

Previously we keeped 2 values until the end, what was useless. Initially was a part of D32647,
though it is possible to split out. Patch do that.

[ruiu]

LGTM

lld/trunk/ELF/SyntheticSections.h

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<std::vector<uint32_t>> CuVectors;
 
   std::vector<AddressEntry> AddressArea;
 
 private:
   void readDwarf(InputSection *Sec);
 
   uint32_t CuTypesOffset;
   uint32_t SymTabOffset;

lld/trunk/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].push_back((Pair.second << 24) |
+                                            (uint32_t)CuId);
   }
 }
 
 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 (std::vector<uint32_t> &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 (std::vector<uint32_t> &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 {