[ELF] - Allow using PLT relocations when "-z notext" is given.

[grimar]

Summary

This is PR35720.

Currently LLD allows dynamic relocations against text when -z notext is given.
Though for non-PIC relocations like R_X86_64_PC32 that does not work,
we produce "relocation R_X86_64_PC32 cannot be used against shared object;"
error because they may overflow in runtime.

Solution implemented is to use PLT for them.

[emaste]

ELF/Relocations.cpp

558 ↗

(On Diff #128009)

Convention would have the comment before the function, no?

[grimar]

Addressed review comment:

• Moved function comment outsize and converted to function header comment.

[emaste]

I can confirm this fixes the reduced test case, but the 'hello world' test on FreeBSD still fails, now with:

/home/emaste/src/llvm/build/bin/ld.lld: error: relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC
>>> defined in usr/lib/crtbegin.o
>>> referenced by /usr/home/emaste/src/freebsd/contrib/gcc/crtstuff.c
>>>               usr/lib/crtbegin.o:(frame_dummy)

[grimar]

In D41541#963178, @emaste wrote:

I can confirm this fixes the reduced test case, but the 'hello world' test on FreeBSD still fails, now with:

/home/emaste/src/llvm/build/bin/ld.lld: error: relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC
>>> defined in usr/lib/crtbegin.o
>>> referenced by /usr/home/emaste/src/freebsd/contrib/gcc/crtstuff.c
>>>               usr/lib/crtbegin.o:(frame_dummy)

I guess 'frame_dummy' is not of STT_FUNC type probably. I'll check the initial testcase (sorry that did not do that before posting the patch).

[grimar]

In D41541#963178, @emaste wrote:

I can confirm this fixes the reduced test case, but the 'hello world' test on FreeBSD still fails, now with:

/home/emaste/src/llvm/build/bin/ld.lld: error: relocation R_X86_64_32 cannot be used against shared object; recompile with -fPIC
>>> defined in usr/lib/crtbegin.o
>>> referenced by /usr/home/emaste/src/freebsd/contrib/gcc/crtstuff.c
>>>               usr/lib/crtbegin.o:(frame_dummy)

It happens because R_X86_64_32 reloc is used against _Jv_RegisterClasses, which is
NOTYPE WEAK DEFAULT UND _Jv_RegisterClasses

That looks to be different issue. It is not a function and I do not see dynamic relocation for it in bfd output,
I can try to investigate it tomorrow.

lld/trunk/ELF/Relocations.cpp

 
 static void errorOrWarn(const Twine &Msg) {
   if (!Config->NoinhibitExec)
     error(Msg);
   else
     warn(Msg);
 }
 
+// Returns PLT relocation expression.
+//
+// This handles a non PIC program call to function in a shared library. In
+// an ideal world, we could just report an error saying the relocation can
+// overflow at runtime. In the real world with glibc, crt1.o has a
+// R_X86_64_PC32 pointing to libc.so.
+//
+// The general idea on how to handle such cases is to create a PLT entry and
+// use that as the function value.
+//
+// For the static linking part, we just return a plt expr and everything
+// else will use the the PLT entry as the address.
+//
+// The remaining problem is making sure pointer equality still works. We
+// need the help of the dynamic linker for that. We let it know that we have
+// a direct reference to a so symbol by creating an undefined symbol with a
+// non zero st_value. Seeing that, the dynamic linker resolves the symbol to
+// the value of the symbol we created. This is true even for got entries, so
+// pointer equality is maintained. To avoid an infinite loop, the only entry
+// that points to the real function is a dedicated got entry used by the
+// plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
+// R_386_JMP_SLOT, etc).
+static RelExpr getPltExpr(Symbol &Sym, RelExpr Expr, bool &IsConstant) {
+  Sym.NeedsPltAddr = true;
+  Sym.IsPreemptible = false;
+  IsConstant = true;
+  return toPlt(Expr);
+}
+
 template <class ELFT>
 static RelExpr adjustExpr(Symbol &Sym, RelExpr Expr, RelType Type,
                           InputSectionBase &S, uint64_t RelOff,
                           bool &IsConstant) {
   // We can create any dynamic relocation if a section is simply writable.
   if (S.Flags & SHF_WRITE)
     return Expr;
 
   // Or, if we are allowed to create dynamic relocations against
-  // read-only sections (i.e. unless "-z notext" is given),
+  // read-only sections (i.e. when "-z notext" is given),
   // we can create a dynamic relocation as we want, too.
-  if (!Config->ZText)
+  if (!Config->ZText) {
+    // We use PLT for relocations that may overflow in runtime,
+    // see comment for getPltExpr().
+    if (Sym.isFunc() && !Target->isPicRel(Type))
+      return getPltExpr(Sym, Expr, IsConstant);
     return Expr;
+  }
 
   // If a relocation can be applied at link-time, we don't need to
   // create a dynamic relocation in the first place.
   if (IsConstant)
     return Expr;
 
   // If we got here we know that this relocation would require the dynamic
   // linker to write a value to read only memory.
if (B && !B->CopyRelSec) {
               getLocation<ELFT>(S, Sym, RelOff));
 
       addCopyRelSymbol<ELFT>(B);
     }
     IsConstant = true;
     return Expr;
   }
 
-  if (Sym.isFunc()) {
-    // This handles a non PIC program call to function in a shared library. In
-    // an ideal world, we could just report an error saying the relocation can
-    // overflow at runtime. In the real world with glibc, crt1.o has a
-    // R_X86_64_PC32 pointing to libc.so.
-    //
-    // The general idea on how to handle such cases is to create a PLT entry and
-    // use that as the function value.
-    //
-    // For the static linking part, we just return a plt expr and everything
-    // else will use the the PLT entry as the address.
-    //
-    // The remaining problem is making sure pointer equality still works. We
-    // need the help of the dynamic linker for that. We let it know that we have
-    // a direct reference to a so symbol by creating an undefined symbol with a
-    // non zero st_value. Seeing that, the dynamic linker resolves the symbol to
-    // the value of the symbol we created. This is true even for got entries, so
-    // pointer equality is maintained. To avoid an infinite loop, the only entry
-    // that points to the real function is a dedicated got entry used by the
-    // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
-    // R_386_JMP_SLOT, etc).
-    Sym.NeedsPltAddr = true;
-    Sym.IsPreemptible = false;
-    IsConstant = true;
-    return toPlt(Expr);
-  }
+  if (Sym.isFunc())
+    return getPltExpr(Sym, Expr, IsConstant);
 
   errorOrWarn("symbol '" + toString(Sym) + "' defined in " +
               toString(Sym.File) + " has no type");
   return Expr;
 }
 
 // MIPS has an odd notion of "paired" relocations to calculate addends.
 // For example, if a relocation is of R_MIPS_HI16, there must be a

lld/trunk/test/ELF/Inputs/znotext-plt-relocations.s

+.text
+.global atexit
+.type atexit,@function
+atexit:
+ nop
+
+.global foo
+.type foo,@function
+foo:
+ nop

lld/trunk/test/ELF/znotext-plt-relocations.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/znotext-plt-relocations.s -o %t2.o
+# RUN: ld.lld %t2.o -o %t2.so -shared
+# RUN: ld.lld -z notext %t.o %t2.so -o %t
+# RUN: llvm-readobj -r %t | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section {{.*}} .rela.dyn {
+# CHECK-NEXT:     R_X86_64_64 foo 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {{.*}} .rela.plt {
+# CHECK-NEXT:     R_X86_64_JUMP_SLOT atexit 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+.text
+_start:
+callq atexit
+.quad foo