[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.

Patch implements support for option using existent expression evaluator we have for linkerscript.
So that means this patch supports full math in --defsym expressions.

This fixes PR32350

[grimar]

• Removed useless change.

[ruiu]

This doesn't look good as you changed too many places for this little feature. Do you really have to support expressions that contain operators? I think you can start with supporting an assignments that consist of only two symbols in the form of -defsym=<sym1>=<sym2>.

[grimar]

In D32082#727317, @ruiu wrote:

This doesn't look good as you changed too many places for this little feature. Do you really have to support expressions that contain operators? I think you can start with supporting an assignments that consist of only two symbols in the form of -defsym=<sym1>=<sym2>.

Ok, I just was interested if our linkerscript parsing code can be easily adopted to use for this option. I read your comment in PR32350, you wrote it's "tricky", I was interested "how much" :)
So if it is too much I'll prepare separate patch for simpler cases (1 and/or 3 from your comment).

[grimar]

D32171 is on review instead

ELF/Config.h

 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf {
 
+class DefinedRegular;
 class InputFile;
 struct Symbol;
 
 enum ELFKind {
   ELFNoneKind,
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,

 // can be found in version script if it is used for link.
 struct VersionDefinition {
   llvm::StringRef Name;
   uint16_t Id = 0;
   std::vector<SymbolVersion> Globals;
   size_t NameOff = 0; // Offset in the string table
 };
 
+// For --defsym=symbol=expression
+struct Defsym {
+  llvm::StringRef Name;
+  llvm::StringRef Expr;
+  DefinedRegular *Sym;
+};
+
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   InputFile *FirstElf = nullptr;
   uint8_t OSABI = 0;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
   llvm::StringMap<uint64_t> SectionStartMap;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef LTOAAPipeline;
   llvm::StringRef LTONewPmPasses;
   llvm::StringRef MapFile;
   llvm::StringRef OutputFile;
   llvm::StringRef OptRemarksFilename;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   llvm::StringRef ThinLTOCacheDir;
   std::string RPath;
+  std::vector<Defsym> Defsym;
   std::vector<VersionDefinition> VersionDefinitions;
   std::vector<llvm::StringRef> AuxiliaryList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> SymbolOrderingFile;
   std::vector<llvm::StringRef> Undefined;
   std::vector<SymbolVersion> VersionScriptGlobals;
   std::vector<SymbolVersion> VersionScriptLocals;
   std::vector<uint8_t> BuildIdVector;

ELF/Driver.cpp

static std::vector<StringRef> getLines(MemoryBufferRef MB) {
   for (StringRef S : Arr) {
     S = S.trim();
     if (!S.empty())
       Ret.push_back(S);
   }
   return Ret;
 }
 
+static std::vector<Defsym> getDefsym(opt::InputArgList &Args) {
+  std::vector<Defsym> Ret;
+  for (auto *Arg : Args.filtered(OPT_defsym)) {
+    Defsym Sym;
+    std::tie(Sym.Name, Sym.Expr) = StringRef(Arg->getValue()).split('=');
+    Ret.push_back(Sym);
+  }
+  return Ret;
+}
+
 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->AuxiliaryList = getArgs(Args, OPT_auxiliary);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
   Config->DefineCommon = getArg(Args, OPT_define_common, OPT_no_define_common,
                                 !Args.hasArg(OPT_relocatable));
+  Config->Defsym = getDefsym(Args);
   Config->Demangle = getArg(Args, OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Discard = getDiscard(Args);
   Config->DynamicLinker = getDynamicLinker(Args);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->Entry = getString(Args, OPT_entry);

ELF/Options.td

def color_diagnostics: F<"color-diagnostics">,
   HelpText<"Use colors in diagnostics">;
 
 def color_diagnostics_eq: J<"color-diagnostics=">,
   HelpText<"Use colors in diagnostics">;
 
 def define_common: F<"define-common">,
   HelpText<"Assign space to common symbols">;
 
+def defsym: J<"defsym=">, HelpText<"Create a global symbol using expression">;
+
 def demangle: F<"demangle">, HelpText<"Demangle symbol names">;
 
 def disable_new_dtags: F<"disable-new-dtags">,
   HelpText<"Disable new dynamic tags">;
 
 def discard_all: F<"discard-all">, HelpText<"Delete all local symbols">;
 
 def discard_locals: F<"discard-locals">,

ELF/ScriptParser.h

 #define LLD_ELF_SCRIPT_PARSER_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
+uint64_t calcDefsym(MemoryBufferRef MB);
+
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);
 
 // Parses a version script.
 void readVersionScript(MemoryBufferRef MB);
 
 void readDynamicList(MemoryBufferRef MB);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/ScriptParser.cpp

 using namespace llvm::ELF;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
 static bool isUnderSysroot(StringRef Path);
 
 namespace {
-class ScriptParser final : ScriptLexer {
+class ScriptParser : ScriptLexer {
 public:
   ScriptParser(MemoryBufferRef MB)
       : ScriptLexer(MB),
         IsUnderSysroot(isUnderSysroot(MB.getBufferIdentifier())) {}
 
   void readLinkerScript();
   void readVersionScript();
   void readDynamicList();
 
+protected:
+  Expr readExpr();
+
+  bool DefsymMode = false;
+
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
private:
   SymbolAssignment *readProvideOrAssignment(StringRef Tok);
   void readSort();
   AssertCommand *readAssert();
   Expr readAssertExpr();
 
   uint64_t readMemoryAssignment(StringRef, StringRef, StringRef);
   std::pair<uint32_t, uint32_t> readMemoryAttributes();
 
-  Expr readExpr();
   Expr readExpr1(Expr Lhs, int MinPrec);
   StringRef readParenLiteral();
   Expr readPrimary();
+  llvm::Optional<Expr> readPrimaryOpt(StringRef Tok, std::string &Location);
   Expr readTernary(Expr Cond);
   Expr readParenExpr();
 
   // For parsing version script.
   std::vector<SymbolVersion> readVersionExtern();
   void readAnonymousDeclaration();
   void readVersionDeclaration(StringRef VerStr);
 
   std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
   readSymbols();
 
   bool IsUnderSysroot;
 };
+
+class DefsymParser : public ScriptParser {
+public:
+  DefsymParser(MemoryBufferRef MB) : ScriptParser(MB) { DefsymMode = true; }
+  Expr DefsymParser::readExpression() { return readExpr(); }
+};
+
 } // namespace
 
 static bool isUnderSysroot(StringRef Path) {
   if (Config->Sysroot == "")
     return false;
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;

 
 StringRef ScriptParser::readParenLiteral() {
   expect("(");
   StringRef Tok = next();
   expect(")");
   return Tok;
 }
 
-Expr ScriptParser::readPrimary() {
-  if (peek() == "(")
-    return readParenExpr();
-
-  if (consume("~")) {
-    Expr E = readPrimary();
-    return [=] { return ~E().getValue(); };
-  }
-  if (consume("-")) {
-    Expr E = readPrimary();
-    return [=] { return -E().getValue(); };
-  }
-
-  StringRef Tok = next();
-  std::string Location = getCurrentLocation();
-
+llvm::Optional<Expr> ScriptParser::readPrimaryOpt(StringRef Tok,
+                                                  std::string &Location) {
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ABSOLUTE") {
     Expr Inner = readParenExpr();
     return [=] {
       ExprValue I = Inner();
       I.ForceAbsolute = true;
       return I;
if (Tok == "SIZEOF") {
     return [=] { return Script->getOutputSectionSize(Name); };
   }
   if (Tok == "SIZEOF_HEADERS")
     return [=] { return elf::getHeaderSize(); };
 
   // Tok is the dot.
   if (Tok == ".")
     return [=] { return Script->getSymbolValue(Location, Tok); };
+  return None;
+}
+
+Expr ScriptParser::readPrimary() {
+  if (peek() == "(")
+    return readParenExpr();
+
+  if (consume("~")) {
+    Expr E = readPrimary();
+    return [=] { return ~E().getValue(); };
+  }
+  if (consume("-")) {
+    Expr E = readPrimary();
+    return [=] { return -E().getValue(); };
+  }
+
+  StringRef Tok = next();
+  std::string Location = getCurrentLocation();
+
+  // Expression parser also can be used for --defsym option.
+  // In that case only arithmetic operations are supported, in compare
+  // with regular linkerscript expressions. Here we avoid proccessing
+  // of optional commands if parser is in defsym evaluation mode.
+  if (!DefsymMode)
+    if (Optional<Expr> Opt = readPrimaryOpt(Tok, Location))
+      return *Opt;
 
   // Tok is a literal number.
   if (Optional<uint64_t> Val = parseInt(Tok))
     return [=] { return *Val; };
 
   // Tok is a symbol name.
-  if (!isValidCIdentifier(Tok))
+  if (!isValidCIdentifier(Tok) || (DefsymMode && Tok == "."))
     setError("malformed number: " + Tok);
+  if (Error)
+    return {};
+
+  if (!DefsymMode)
     Script->Opt.ReferencedSymbols.push_back(Tok);
   return [=] { return Script->getSymbolValue(Location, Tok); };
 }
 
 Expr ScriptParser::readTernary(Expr Cond) {
   Expr L = readExpr();
   expect(":");
   Expr R = readExpr();
   return [=] { return Cond().getValue() ? L() : R(); };
for (char C : next().lower()) {
     if (Invert)
       NegFlags |= Flag;
     else
       Flags |= Flag;
   }
   return {Flags, NegFlags};
 }
 
+uint64_t elf::calcDefsym(MemoryBufferRef MB) {
+  return DefsymParser(MB).readExpression()().getValue();
+}
+
 void elf::readLinkerScript(MemoryBufferRef MB) {
   ScriptParser(MB).readLinkerScript();
 }
 
 void elf::readVersionScript(MemoryBufferRef MB) {
   ScriptParser(MB).readVersionScript();
 }
 
 void elf::readDynamicList(MemoryBufferRef MB) {
   ScriptParser(MB).readDynamicList();
 }

ELF/Writer.cpp

 #include "Writer.h"
 #include "Config.h"
 #include "Filesystem.h"
 #include "LinkerScript.h"
 #include "MapFile.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Relocations.h"
+#include "ScriptParser.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/raw_ostream.h"
template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
 
   ElfSym::Bss = Add("__bss_start");
   ElfSym::End1 = Add("end");
   ElfSym::End2 = Add("_end");
   ElfSym::Etext1 = Add("etext");
   ElfSym::Etext2 = Add("_etext");
   ElfSym::Edata1 = Add("edata");
   ElfSym::Edata2 = Add("_edata");
+
+  for (Defsym &DS : Config->Defsym)
+    DS.Sym = Symtab<ELFT>::X->addAbsolute(DS.Name, STV_DEFAULT, STB_GLOBAL);
 }
 
 // Sort input sections by section name suffixes for
 // __attribute__((init_priority(N))).
 static void sortInitFini(OutputSection *S) {
   if (S)
     reinterpret_cast<OutputSection *>(S)->sortInitFini();
 }
template <class ELFT> void Writer<ELFT>::fixPredefinedSymbols() {
   if (LastRO)
     Set(ElfSym::Etext1, ElfSym::Etext2, LastRO->First, LastRO->p_filesz);
   if (LastRW)
     Set(ElfSym::Edata1, ElfSym::Edata2, LastRW->First, LastRW->p_filesz);
 
   if (ElfSym::Bss)
     ElfSym::Bss->Section = findSection(".bss");
 
+  for (Defsym &DS : Config->Defsym)
+    DS.Sym->Value = calcDefsym({DS.Expr, Saver.save("--defsym=" + DS.Name)});
+
   // Setup MIPS _gp_disp/__gnu_local_gp symbols which should
   // be equal to the _gp symbol's value.
   if (Config->EMachine == EM_MIPS) {
     if (!ElfSym::MipsGp->Value) {
       // Find GP-relative section with the lowest address
       // and use this address to calculate default _gp value.
       uint64_t Gp = -1;
       for (const OutputSection *OS : OutputSections)

test/ELF/defsym.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld %t.o -o %t --defsym=val1=1+0x2 --defsym=val2=foo+1
+# RUN: llvm-readobj -t -s %t | FileCheck %s
+
+# CHECK:      Symbol {
+# CHECK:        Name: foo
+# CHECK-NEXT:   Value: 0x201000
+# CHECK:      Symbol {
+# CHECK:        Name: val1
+# CHECK-NEXT:   Value: 0x3
+# CHECK:      Symbol {
+# CHECK:        Name: val2
+# CHECK-NEXT:   Value: 0x201001
+
+# RUN: not ld.lld %t.o -o %t --defsym=val1=1[ 2>&1 | \
+# RUN:   FileCheck --check-prefix=ERR1 %s
+# ERR1: --defsym=val1:1: malformed number: 1[
+
+# RUN: not ld.lld %t.o -o %t --defsym=val2=. 2>&1 | \
+# RUN:   FileCheck --check-prefix=ERR2 %s
+# ERR2: --defsym=val2:1: malformed number: .
+
+.globl foo
+.type foo, @function
+foo:
+ nop
+
+_start: