[ELF] - Implemented -znotext

[grimar]

Summary

gold linker manual describes them as:

-z text Do not permit relocations in read-only segments
-z notext Permit relocations in read-only segments (default)

In LLD default is to not permit them. Patch implements -z notext.

[ruiu]

What is a program do you want to use this for?

[grimar]

In D30530#690725, @ruiu wrote:

What is a program do you want to use this for?

Linux kernel uses text relocations when KASLR (Kernel address space layout randomization) is enabled.

[ruiu]

Does it pass -z text?

[grimar]

In D30530#690735, @ruiu wrote:

Does it pass -z text?

No, we have no way not to fail with text relocations now.
ld.bfd accepts them by default. We - dont.
I think solution for them would be to pass -z notext.

[ruiu]

ELF/Driver.cpp

272

Use llvm::reverse and return early.

ELF/SyntheticSections.cpp

1109–1110

I don't think you need to check if there's actually text relocations. Set it unconditionally as long as Config->ZText is true.

[grimar]

• Addressed review comments.

[grimar]

ELF/Driver.cpp

272

That would not work out of box with filtered.
I prepared patch for that: D30570

[grimar]

• Reimplemented getZOption()

[grimar]

ELF/Driver.cpp

270

This can be reused, for example for "relro" vs "norelro", "execstack" vs "noexecstack" etc.

[ruiu]

ELF/Driver.cpp

614

Do you actually need -z notext? You can just write hasZOption(Args, "text") like other options.

[grimar]

ELF/Driver.cpp

614

The way other -z options implemented is incorrect I believe.
There are few options thatmake a pairs, like -z text/notext, -z execstack/noexecstack, -z relro/norelro, -z combreloc/nocombreloc.
Don't we want to be consistent and override previous -z options like we do for regular ones ?

[ruiu]

ELF/Driver.cpp

614

Strictly speaking that is true, but for now focusing on -z text is better.

[grimar]

• Addressed review comments.

[ruiu]

LGTM

ELF/Config.h

struct Configuration {
   bool EhFrameHdr;
   bool EmitRelocs;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool FatalWarnings;
   bool GcSections;
   bool GdbIndex;
   bool GnuHash;
+  bool HasTextRel = false;
   bool ICF;
   bool Mips64EL = false;
   bool MipsN32Abi = false;
   bool NoGnuUnique;
   bool NoUndefinedVersion;
   bool Nostdlib;
   bool OFormatBinary;
   bool Omagic;
struct Configuration {
   bool WarnMissingEntry;
   bool ZCombreloc;
   bool ZExecstack;
   bool ZNocopyreloc;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
+  bool ZText;
   bool ExitEarly;
   bool ZWxneeded;
   DiscardPolicy Discard;
   SortSectionPolicy SortSection;
   StripPolicy Strip;
   UnresolvedPolicy UnresolvedSymbols;
   Target2Policy Target2;
   BuildIdKind BuildId = BuildIdKind::None;

ELF/Driver.cpp

 
 static bool hasZOption(opt::InputArgList &Args, StringRef Key) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (Key == Arg->getValue())
       return true;
   return false;
 }
 
+static bool getZTextOption(opt::InputArgList &Args) {
+  bool ZText = true;
+  for (auto *Arg : Args.filtered(OPT_z)) {
+    StringRef S = Arg->getValue();
+    if (S == "text")
+      ZText = true;
+    else if (S == "notext")
+      ZText = false;
+  }
+  return ZText;
+}
+
 static uint64_t getZOptionValue(opt::InputArgList &Args, StringRef Key,
                                 uint64_t Default) {
   for (auto *Arg : Args.filtered(OPT_z)) {
     StringRef Value = Arg->getValue();
     size_t Pos = Value.find("=");
     if (Pos != StringRef::npos && Key == Value.substr(0, Pos)) {
       Value = Value.substr(Pos + 1);
       uint64_t Result;
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->ZCombreloc = !hasZOption(Args, "nocombreloc");
   Config->ZExecstack = hasZOption(Args, "execstack");
   Config->ZNocopyreloc = hasZOption(Args, "nocopyreloc");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = !hasZOption(Args, "norelro");
   Config->ZStackSize = getZOptionValue(Args, "stack-size", 0);
+  Config->ZText = getZTextOption(Args);
   Config->ZWxneeded = hasZOption(Args, "wxneeded");
 
   if (Config->LTOO > 3)
     error("invalid optimization level for LTO: " + getString(Args, OPT_lto_O));
   if (Config->LTOPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (Config->ThinLTOJobs == 0)
     error("--thinlto-jobs: number of threads must be > 0");

ELF/Relocations.cpp

static RelExpr adjustExpr(const elf::ObjectFile<ELFT> &File, SymbolBody &Body,
 
   if (IsWrite || isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, S, RelOff))
     return Expr;
 
   // This relocation would require the dynamic linker to write a value to read
   // only memory. We can hack around it if we are producing an executable and
   // the refered symbol can be preemepted to refer to the executable.
   if (Config->Shared || (Config->pic() && !isRelExpr(Expr))) {
+    if (Config->ZText)
       error(S.getLocation<ELFT>(RelOff) + ": can't create dynamic relocation " +
             toString(Type) + " against " +
             (Body.getName().empty() ? "local symbol in readonly segment"
                                     : "symbol '" + toString(Body) + "'") +
             " defined in " + toString(Body.File));
+    Config->HasTextRel = true;
     return Expr;
   }
   if (Body.getVisibility() != STV_DEFAULT) {
     error(S.getLocation<ELFT>(RelOff) + ": cannot preempt symbol '" +
           toString(Body) + "' defined in " + toString(Body.File));
     return Expr;
   }
   if (Body.isObject()) {

ELF/SyntheticSections.cpp

add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
          In<ELFT>::GotPlt});
     add({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
   }
 
   add({DT_SYMTAB, In<ELFT>::DynSymTab});
   add({DT_SYMENT, sizeof(Elf_Sym)});
   add({DT_STRTAB, In<ELFT>::DynStrTab});
   add({DT_STRSZ, In<ELFT>::DynStrTab->getSize()});
+  if (Config->HasTextRel)
+    add({DT_TEXTREL, (uint64_t)0});
   if (In<ELFT>::GnuHashTab)
     add({DT_GNU_HASH, In<ELFT>::GnuHashTab});
   if (In<ELFT>::HashTab)
     add({DT_HASH, In<ELFT>::HashTab});
 
   if (Out::PreinitArray) {
     add({DT_PREINIT_ARRAY, Out::PreinitArray});
     add({DT_PREINIT_ARRAYSZ, Out::PreinitArray, Entry::SecSize});

test/ELF/ztext-text-notext.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: ld.lld -z notext %t.o -o %t -shared
+# RUN: llvm-readobj  -dynamic-table -r %t | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:    Section {{.*}} .rela.dyn {
+# CHECK-NEXT:      0x1000 R_X86_64_RELATIVE - 0x1000
+# CHECK-NEXT:    }
+# CHECK-NEXT:  ]
+# CHECK: DynamicSection [
+# CHECK: 0x0000000000000016 TEXTREL 0x0
+
+# RUN: not ld.lld -z notext -z text %t.o -o %t -shared 2>&1 | FileCheck %s --check-prefix=ERR
+# ERR: can't create dynamic relocation R_X86_64_64 against local symbol in readonly segment
+
+foo:
+.quad foo