[ELF] - Implemented -z noreloc-overflow.

[grimar]

Summary

-z noreloc-overflow is a specific feature used in linux kernel, for example,
when KASLR (Kernel address space layout randomization) is enabled.

For supporting KALSR, kernel should be build as PIE.
Currently configuration checks if noreloc-overflow is available before doing that.
(https://github.com/torvalds/linux/blob/master/arch/x86/boot/compressed/Makefile#L51).

Then loader handles the produced relative dynamic relocations by itself.
(https://github.com/torvalds/linux/blob/master/arch/x86/boot/compressed/misc.c#L173).

So what this patch do is allows producing relocations against RO segement, that is where
we fail now.

[grimar]

• Fixed mistypes in comment.

[ruiu]

The fact that the name does not correspond what it does is actually a bit alarming. It could be a sign that something is wrong. Did you know why it was named "noreloc-overflow"?

[grimar]

In D30256#683650, @ruiu wrote:

The fact that the name does not correspond what it does is actually a bit alarming. It could be a sign that something is wrong. Did you know why it was named "noreloc-overflow"?

Yes. I am sorry, now I see that patch was very confusing. They use it for different thing:
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=bfd/elf64-x86-64.c;h=a058eca3abf03cc2f79601d170b2d6b9f9c459e5;hb=HEAD#l2594
They do not allow to use some relocations as dynamic because they can overflow in runtime
and report "recompile with fPIC" error instead. To avoid that error, they have this flag.
There is a single relocation in kernel I see that is fixed by that option for them, but we resolve this relocation statically, so at least for my case it was never a problem.

Issue I tried to solve in this patch is different. Issue is that we restrict creating the relocations against RO sections. Though self-relocatable binaries
for kernel wants to have that. For that case I supposed it is fine to ignore all kinds of checks for dynamic relocations under this option. Now I am not sure
that was good idea.

May be we should just allow relocations against text segment when --no-dynamic-linker is given ? That also solves kernel problem and delegates a problem
of handling of such relocation to users generally, what should not be a trouble in that case, because if user specifies no-dynamic-linker, it knows he will
need to handle them anyways. What do you think ?

ELF/Config.h

struct Configuration {
   bool Trace;
   bool Verbose;
   bool WarnCommon;
   bool WarnMissingEntry;
   bool ZCombreloc;
   bool ZExecstack;
   bool ZNocopyreloc;
   bool ZNodelete;
+  bool ZNorelocOverflow;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   bool ExitEarly;
   bool ZWxneeded;
   DiscardPolicy Discard;
   SortSectionPolicy SortSection;
   StripPolicy Strip = StripPolicy::None;

ELF/Driver.cpp

if (Config->Shared)
       error("-r and -shared may not be used together");
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Config->ICF)
       error("-r and --icf may not be used together");
     if (Config->Pie)
       error("-r and -pie may not be used together");
   }
+
+  // -z noreloc-overflow is a specific feature used in kernels. When it is
+  // enabled, we may emit a dynamic relocation against RO segment. In that
+  // case we would need to add DT_TEXTREL flag to prepare runtime linker.
+  // Though noreloc-overflow is usually used for producing self-relocatable
+  // output which avoid use of dynamic linker.
+  if (Config->ZNorelocOverflow && !Args.hasArg(OPT_no_dynamic_linker))
+    error("-z noreloc-overflow may not be used without --no-dynamic-linker");
 }
 
 static StringRef getString(opt::InputArgList &Args, unsigned Key,
                            StringRef Default = "") {
   if (auto *Arg = Args.getLastArg(Key))
     return Arg->getValue();
   return Default;
 }
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->ThinLTOJobs = getInteger(Args, OPT_thinlto_jobs, -1u);
   if (Config->ThinLTOJobs == 0)
     error("--thinlto-jobs: number of threads must be > 0");
 
   Config->ZCombreloc = !hasZOption(Args, "nocombreloc");
   Config->ZExecstack = hasZOption(Args, "execstack");
   Config->ZNocopyreloc = hasZOption(Args, "nocopyreloc");
   Config->ZNodelete = hasZOption(Args, "nodelete");
+  Config->ZNorelocOverflow = hasZOption(Args, "noreloc-overflow");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = !hasZOption(Args, "norelro");
   Config->ZStackSize = getZOptionValue(Args, "stack-size", 0);
   Config->ZWxneeded = hasZOption(Args, "wxneeded");
 
   Config->OFormatBinary = isOutputFormatBinary(Args);
   Config->SectionStartMap = getSectionStartMap(Args);

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->ZNorelocOverflow)
       error(S.getLocation(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));
     return Expr;
   }
   if (Body.getVisibility() != STV_DEFAULT) {
     error(S.getLocation(RelOff) + ": cannot preempt symbol '" + toString(Body) +
           "' defined in " + toString(Body.File));
     return Expr;
   }
   if (Body.isObject()) {

test/ELF/znoreloc-overflow.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: ld.lld --no-dynamic-linker -z noreloc-overflow %t.o -o %t -pie
+# RUN: llvm-readobj -r  %t | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:    Section {{.*}} .rela.dyn {
+# CHECK-NEXT:      0x1000 R_X86_64_RELATIVE - 0x1000
+# CHECK-NEXT:      0x1004 R_X86_64_RELATIVE - 0x1000
+# CHECK-NEXT:    }
+# CHECK-NEXT:  ]
+
+# RUN: not ld.lld -z noreloc-overflow %t.o -o %t -pie 2>&1 \
+# RUN:  | FileCheck %s --check-prefix=ERR
+# ERR: -z noreloc-overflow may not be used without --no-dynamic-linker
+
+.text
+.global _start
+_start:
+ .long _start
+ .quad _start