ELF: Consistently return SymbolBody * from SymbolTable::add functions.

For historical reasons, some add* functions for SymbolTable returns a
pointer to a SymbolBody, while some are not. This patch is to make them
consistently return a pointer to a newly added symbol.

git-svn-id: https://llvm.org/svn/llvm-project/lld/trunk@257211 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 17 insertions, 14 deletions

diff --git a/ELF/SymbolTable.cpp b/ELF/SymbolTable.cpp
index 01738d07e..7c0f9ae38 100644
--- a/ELF/SymbolTable.cpp
+++ b/ELF/SymbolTable.cpp
@@ -101,17 +101,20 @@ SymbolBody *SymbolTable<ELFT>::addUndefinedOpt(StringRef Name) {
 }
 
 template <class ELFT>
-void SymbolTable<ELFT>::addAbsolute(StringRef Name,
-                                    typename ELFFile<ELFT>::Elf_Sym &ESym) {
-  resolve(new (Alloc) DefinedRegular<ELFT>(Name, ESym, nullptr));
+SymbolBody *SymbolTable<ELFT>::addAbsolute(StringRef Name, Elf_Sym &ESym) {
+  // Pass nullptr because absolute symbols have no corresponding input sections.
+  auto *Sym = new (Alloc) DefinedRegular<ELFT>(Name, ESym, nullptr);
+  resolve(Sym);
+  return Sym;
 }
 
 template <class ELFT>
-void SymbolTable<ELFT>::addSynthetic(StringRef Name,
-                                     OutputSectionBase<ELFT> &Section,
-                                     typename ELFFile<ELFT>::uintX_t Value) {
+SymbolBody *SymbolTable<ELFT>::addSynthetic(StringRef Name,
+                                            OutputSectionBase<ELFT> &Section,
+                                            uintX_t Value) {
   auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Value, Section);
   resolve(Sym);
+  return Sym;
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
@@ -119,10 +122,7 @@ void SymbolTable<ELFT>::addSynthetic(StringRef Name,
 // file's symbol table. Such symbols are useful for some linker-defined symbols.
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addIgnored(StringRef Name) {
-  auto *Sym = new (Alloc)
-      DefinedRegular<ELFT>(Name, ElfSym<ELFT>::IgnoreUndef, nullptr);
-  resolve(Sym);
-  return Sym;
+  return addAbsolute(Name, ElfSym<ELFT>::IgnoreUndef);
 }
 
 // Rename SYM as __wrap_SYM. The original symbol is preserved as __real_SYM.
diff --git a/ELF/SymbolTable.h b/ELF/SymbolTable.h
index f240d81f5..117e95725 100644
--- a/ELF/SymbolTable.h
+++ b/ELF/SymbolTable.h
@@ -31,6 +31,9 @@ class Undefined;
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in resolve().
 template <class ELFT> class SymbolTable {
+  typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
+  typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
+
 public:
   SymbolTable();
 
@@ -50,11 +53,11 @@ public:
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
-  void addAbsolute(StringRef Name,
-                   typename llvm::object::ELFFile<ELFT>::Elf_Sym &ESym);
-  void addSynthetic(StringRef Name, OutputSectionBase<ELFT> &Section,
-                    typename llvm::object::ELFFile<ELFT>::uintX_t Value);
+  SymbolBody *addAbsolute(StringRef Name, Elf_Sym &ESym);
+  SymbolBody *addSynthetic(StringRef Name, OutputSectionBase<ELFT> &Section,
+                           uintX_t Value);
   SymbolBody *addIgnored(StringRef Name);
+
   void scanShlibUndefined();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);