[ELF] - Implemented --defsym option

[grimar]

Summary

gnu ld description of option is:

--defsym=symbol=expression
Create a global symbol in the output file, containing the absolute address given by expression. You may use this option as many times as necessary to define multiple symbols in the command line. A limited form of arithmetic is supported for the expression in this context: you may give a hexadecimal constant or the name of an existing symbol, or use "+" and "-" to add or subtract hexadecimal constants or symbols. If you need more elaborate expressions, consider using the linker command language from a script. Note: there should be no white space between symbol, the equals sign ("="), and expression.

In compare with D32082, this patch does not support math expressions and absolute symbols. It implemented via code similar to --wrap.
That covers 1 of 3 possible --defsym cases.

[davide]

ELF/SymbolTable.cpp

174–178

this bit is untested.

[grimar]

• Addressed review comment.

ELF/SymbolTable.cpp

174–178

Fixed.

[grimar]

• Updated testcase to show we can use aliasing.

test/ELF/defsym.s

17

Forgot to mention this moment. We have 2 symbols 'foo1' in output here. That is because I don't
change name of alias symbol body in alias().
To change the name in symtab I think I need to make SymbolBody::Name public
and remove getter, that allows to set new name, but also involves changes in many places. Do we want it ?
Aliasing itself works without that I believe.

[ruiu]

ELF/Driver.cpp

884

I'd support just 1.

887

Make this a function that returns a vector of pair<StringRef, StringRef> and use alias function in link().

[grimar]

• Addressed review comments.

ELF/Driver.cpp

884

Done.

887

Done.

[ruiu]

Generally looking good, a few nits.

Please remove "#2" from the patch title. It's not relevant for people who will be reading this patch after you submit this, as they don't know and don't care about how many you have tried before.

ELF/Driver.cpp

887

Expr is not an expr, but a symbol name, so Expr is not a good name. I'd name them From and To.

889

Remove =.

Since we expect a symbol name, the error should be something like error("-defsym: symbol name expected, but got " + To);

ELF/Options.td

28

"Define a symbol alias"

ELF/SymbolTable.cpp

176

= is not part of the option name but a separator.

Also, we are not handling an expression, so don't use the word "expression".

Error message should be error("-defsym: undefined symbol: " + Name);

[grimar]

• Addressed review comments.

ELF/Driver.cpp

887

Done.

889

Done.

ELF/Options.td

28

Done.

ELF/SymbolTable.cpp

176

Done.

[ruiu]

LGTM

ELF/Driver.cpp

if (S.getAsInteger(0, V)) {
     error("-image-base: number expected, but got " + S);
     return 0;
   }
   if ((V % Config->MaxPageSize) != 0)
     warn("-image-base: address isn't multiple of page size: " + S);
   return V;
 }
 
+// Function used to handle --defsym= option. It can be one of 3:
+// 1) --defsym=name=alias
+// 2) --defsym=name=integer
+// 3) --defsym=name=expression
+// We support first two. Alias implemented very similar to --wrap option,
+// second form simply creates an absolute symbol. We do not support
+// expressions with math for simplicity.
+template <class ELFT> static void handleDefsym(opt::InputArgList &Args) {
+  std::vector<std::pair<StringRef, StringRef>> Ret;
+  for (auto *Arg : Args.filtered(OPT_defsym)) {
+    StringRef Name;
+    StringRef Expr;
+    std::tie(Name, Expr) = StringRef(Arg->getValue()).split('=');
+
+    if (isValidCIdentifier(Expr)) {
+      Symtab<ELFT>::X->alias(Name, Expr);
+      continue;
+    }
+
+    uint64_t Val;
+    if (!Expr.getAsInteger(0, Val)) {
+      DefinedRegular *DR =
+          Symtab<ELFT>::X->addAbsolute(Name, STV_DEFAULT, STB_GLOBAL);
+      DR->Value = Val;
+      continue;
+    }
+
+    error("--defsym=: number expected, but got " + Expr);
+  }
+}
+
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
   elf::Symtab<ELFT>::X = &Symtab;
   Target = createTarget();
 
   Config->MaxPageSize = getMaxPageSize(Args);
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // Some symbols (such as __ehdr_start) are defined lazily only when there
   // are undefined symbols for them, so we add these to trigger that logic.
   for (StringRef Sym : Script->Opt.ReferencedSymbols)
     Symtab.addUndefined(Sym);
 
   for (auto *Arg : Args.filtered(OPT_wrap))
     Symtab.wrap(Arg->getValue());
 
+  // Handle --defsym=sym=expr option.
+  handleDefsym<ELFT>(Args);
+
   // Now that we have a complete list of input files.
   // Beyond this point, no new files are added.
   // Aggregate all input sections into one place.
   for (elf::ObjectFile<ELFT> *F : Symtab.getObjectFiles())
     for (InputSectionBase *S : F->getSections())
       if (S && S != &InputSection::Discarded)
         InputSections.push_back(S);
   for (BinaryFile *F : Symtab.getBinaryFiles())

ELF/Options.td

 
 def build_id: F<"build-id">, HelpText<"Generate build ID note">;
 
 def build_id_eq: J<"build-id=">, HelpText<"Generate build ID note">;
 
 def compress_debug_sections : J<"compress-debug-sections=">,
   HelpText<"Compress DWARF debug sections">;
 
+def defsym: J<"defsym=">, HelpText<"Create a global symbol alias or absolute symbol">;
+
 def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Add a directory to the library search path">;
 
 def O: Joined<["-"], "O">, HelpText<"Optimize output file size">;
 
 def Tbss: S<"Tbss">, HelpText<"Same as --section-start with .bss as the sectionname">;
 
 def Tdata: S<"Tdata">, HelpText<"Same as --section-start with .data as the sectionname">;

ELF/SymbolTable.h

public:
   void scanShlibUndefined();
   void scanVersionScript();
 
   SymbolBody *find(StringRef Name);
   SymbolBody *findInCurrentDSO(StringRef Name);
 
   void trace(StringRef Name);
   void wrap(StringRef Name);
+  void alias(StringRef Alias, StringRef Name);
 
 private:
   std::vector<SymbolBody *> findByVersion(SymbolVersion Ver);
   std::vector<SymbolBody *> findAllByVersion(SymbolVersion Ver);
 
   llvm::StringMap<std::vector<SymbolBody *>> &getDemangledSyms();
   void handleAnonymousVersion();
   void assignExactVersion(SymbolVersion Ver, uint16_t VersionId,

ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable<ELFT>::wrap(StringRef Name) {
 
   // We rename symbols by replacing the old symbol's SymbolBody with the new
   // symbol's SymbolBody. This causes all SymbolBody pointers referring to the
   // old symbol to instead refer to the new symbol.
   memcpy(Real->Body.buffer, Sym->Body.buffer, sizeof(Sym->Body));
   memcpy(Sym->Body.buffer, Wrap->Body.buffer, sizeof(Wrap->Body));
 }
 
+// Creates alias for symbol. Used to implement --defsym=SYM=ALIAS
+template <class ELFT>
+void SymbolTable<ELFT>::alias(StringRef Alias, StringRef Name) {
+  SymbolBody *B = find(Name);
+  if (!B) {
+    error("undefined symbol '" + Name + "' used in --defsym= expression");
+    return;
+  }
+  Symbol *Sym = B->symbol();
+  Symbol *AliasSym = addUndefined(Alias);
+  memcpy(AliasSym->Body.buffer, Sym->Body.buffer, sizeof(AliasSym->Body));
+}
+
 static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
   if (VA == STV_DEFAULT)
     return VB;
   if (VB == STV_DEFAULT)
     return VA;
   return std::min(VA, VB);
 }
 

test/ELF/defsym.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: ld.lld -o %t %t.o --defsym=foo2=foo1 --defsym=foo3=0x456
+# RUN: llvm-readobj -t -s %t | FileCheck %s
+
+# CHECK:      Symbol {
+# CHECK:        Name: foo1
+# CHECK-NEXT:   Value: [[ADDR:.*]]
+# CHECK-NEXT:   Size:
+# CHECK-NEXT:   Binding: Global
+# CHECK-NEXT:   Type:
+# CHECK-NEXT:   Other:
+# CHECK-NEXT:   Section: Absolute
+# CHECK-NEXT: }
+# CHECK-NEXT: Symbol {
+# CHECK-NEXT:   Name: foo1
+# CHECK-NEXT:   Value: [[ADDR]]
+# CHECK-NEXT:   Size:
+# CHECK-NEXT:   Binding: Global
+# CHECK-NEXT:   Type:
+# CHECK-NEXT:   Other:
+# CHECK-NEXT:   Section: Absolute
+# CHECK-NEXT: }
+# CHECK-NEXT: Symbol {
+# CHECK-NEXT:   Name: foo3
+# CHECK-NEXT:   Value: 0x456
+# CHECK-NEXT:   Size:
+# CHECK-NEXT:   Binding: Global
+# CHECK-NEXT:   Type:
+# CHECK-NEXT:   Other:
+# CHECK-NEXT:   Section: Absolute
+# CHECK-NEXT: }
+
+# RUN: not ld.lld -o %t %t.o --defsym=foo2=foo1+1 2>&1 | FileCheck %s -check-prefix=ERR
+# ERR: error: --defsym=: number expected, but got foo1+1
+
+.globl foo1
+ foo1 = 0x123