[ELF2] Fill up local symbols field correctly

[davide]

Summary

Only visibility is missing at this point, but that doesn't seem to be a big deal.

[• rafael]

ELF/Writer.cpp

700 ↗

(On Diff #35035)

This doesn't handle SHN_XINDEX.

There is getExtendedSymbolTableIndex to help with that.

703 ↗

(On Diff #35035)

Instead of the loop you should be able to do just Chunks[SecIndex], like we do in createSymbolBody.

[davide]

Addressing Rafael's comments.

[• rafael]

ELF/Writer.cpp

761 ↗

(On Diff #35039)

This variable is now unused.

[davide]

Remove unused variable.

[• rafael]

LGTM with a nit.

ELF/Writer.cpp

764 ↗

(On Diff #35040)

You have just used Section :-)

lld/trunk/ELF/InputFiles.h

const SymbolBody *getSymbolBody(uint32_t SymbolIndex) const {
     uint32_t FirstNonLocal = this->Symtab->sh_info;
     if (SymbolIndex < FirstNonLocal)
       return nullptr;
     return SymbolBodies[SymbolIndex - FirstNonLocal]->getReplacement();
   }
 
   Elf_Sym_Range getLocalSymbols();
 
+  const Elf_Shdr *getSymbolTable() { return this->Symtab; };
+  ArrayRef<Elf_Word> getSymbolTableShndx() { return SymtabSHNDX; };
+
 private:
   void initializeChunks();
   void initializeSymbols();
 
   SymbolBody *createSymbolBody(StringRef StringTable, const Elf_Sym *Sym);
 
   // List of all chunks defined by this file.
   std::vector<SectionChunk<ELFT> *> Chunks;

lld/trunk/ELF/Writer.cpp

private:
   llvm::StringTableBuilder StrTabBuilder;
 };
 
 template <class ELFT> class Writer;
 
 template <class ELFT>
 class SymbolTableSection final : public OutputSectionBase<ELFT::Is64Bits> {
 public:
+  typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
   SymbolTableSection(Writer<ELFT> &W, SymbolTable &Table,
                      StringTableSection<ELFT::Is64Bits> &StrTabSec)
       : OutputSectionBase<ELFT::Is64Bits>(
             StrTabSec.isDynamic() ? ".dynsym" : ".symtab",
             StrTabSec.isDynamic() ? SHT_DYNSYM : SHT_SYMTAB,
if (!B.isUsedInRegularObj())
     return false;
   uint8_t V = B.getMostConstrainingVisibility();
   if (V != STV_DEFAULT && V != STV_PROTECTED)
     return false;
   return true;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
+  const OutputSection<ELFT> *Out = nullptr;
+  const SectionChunk<ELFT> *Section = nullptr;
   Buf += sizeof(Elf_Sym);
 
   // All symbols with STB_LOCAL binding precede the weak and global symbols.
   // .dynsym only contains global symbols.
   if (!Config->DiscardAll && !StrTabSec.isDynamic()) {
     for (const std::unique_ptr<ObjectFileBase> &FileB :
          Table.getObjectFiles()) {
       auto &File = cast<ObjectFile<ELFT>>(*FileB);
       Elf_Sym_Range Syms = File.getLocalSymbols();
       for (const Elf_Sym &Sym : Syms) {
         auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
+        uint32_t SecIndex = Sym.st_shndx;
         ErrorOr<StringRef> SymName = Sym.getName(File.getStringTable());
         ESym->st_name = (SymName) ? StrTabSec.getFileOff(*SymName) : 0;
-        ESym->st_value = Sym.st_value;
         ESym->st_size = Sym.st_size;
+        ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
+        if (SecIndex == SHN_XINDEX)
+          SecIndex = File.getObj()->getExtendedSymbolTableIndex(
+              &Sym, File.getSymbolTable(), File.getSymbolTableShndx());
+        ArrayRef<SectionChunk<ELFT> *> Chunks = File.getChunks();
+        Section = Chunks[SecIndex];
+        assert(Section != nullptr);
+        Out = Section->getOutputSection();
+        assert(Out != nullptr);
+        ESym->st_shndx = Out->getSectionIndex();
+        ESym->st_value =
+            Out->getVA() + Section->getOutputSectionOff() + Sym.st_value;
         Buf += sizeof(Elf_Sym);
       }
     }
   }
 
   for (auto &P : Table.getSymbols()) {
     StringRef Name = P.first;
     Symbol *Sym = P.second;
     SymbolBody *Body = Sym->Body;
     if (!includeInSymtab(*Body))
       continue;
     const Elf_Sym &InputSym = cast<ELFSymbolBody<ELFT>>(Body)->Sym;
 
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
     ESym->st_name = StrTabSec.getFileOff(Name);
 
-    const SectionChunk<ELFT> *Section = nullptr;
-    const OutputSection<ELFT> *Out = nullptr;
+    Out = nullptr;
+    Section = nullptr;
 
     switch (Body->kind()) {
     case SymbolBody::DefinedRegularKind:
       Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedCommonKind:
       Out = &W.getBSS();
       break;

lld/trunk/test/elf2/local-dynamic.s

 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: blah
-// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Value: 0x1000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: foo
-// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Value: 0x1000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: goo
-// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Value: 0x1000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: _start
 // CHECK-NEXT:     Value: 0x1000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0

lld/trunk/test/elf2/local.s

 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: blah
-// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Value: 0x11000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: foo
-// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Value: 0x11000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: goo
-// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Value: 0x11000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: _start
 // CHECK-NEXT:     Value: 0x11000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0