[ELF] Rename canRelax to toExecRelax. NFC

[MaskRay]

Summary

In the absence of TLS relaxation (rewrite of code sequences),
there is still an applicable optimization:

[gd]: General Dynamic: resolve DTPMOD to 1 and/or resolve DTPOFF statically

All the other relaxations are only performed when transiting to
executable (!config->shared).
Since [gd] is handled differently, we can fold !config->shared into canRelax
and simplify its use sites. Rename the variable to reflect to new semantics.

[psmith]

LGTM it looks like a good simplification. Worth waiting a little bit to see if there are any objections.

[grimar]

LGTM too. A question/suggestion for a follow-up is inlined.

lld/ELF/Relocations.cpp

211

It looks like we can get rid of this variable now? I.e. looks like isLocalInExecutable can be replaced with !sym.isPreemptible everywhere.

[MaskRay]

lld/ELF/Relocations.cpp

211

We can't delete it.

if (!sharedToExecRelax) {
  // if (isLocalInExecutable)
  // cannot be changed to
  // if (!sym.isPreemptible
}

[MaskRay]

lld/ELF/Relocations.cpp

311

Initial-Exec -> Local-Exec is a relaxation from executable to executable. sharedToExecRelax is not an appropriate name. Shall we rename the variable?

Technically, a shared object can use Initial-Exec as well if it is part of initial modules (via transitive DT_NEEDED; DF_STATIC_TLS).

[psmith]

lld/ELF/Relocations.cpp

311

Perhaps just toExecRelax or canExecRelax?

[MaskRay]

lld/ELF/Relocations.cpp

311

Thanks. toExecRelax sounds good.

[MaskRay]

sharedToExecRelax -> toExecRelax

lld/ELF/Relocations.cpp

if (in.got->addDynTlsEntry(sym)) {
       mainPart->relaDyn->addReloc(
           {target->tlsDescRel, in.got, off, !sym.isPreemptible, &sym, 0});
     }
     if (expr != R_TLSDESC_CALL)
       c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
 
-  bool canRelax = config->emachine != EM_ARM &&
+  bool toExecRelax = !config->shared && config->emachine != EM_ARM &&
                      config->emachine != EM_HEXAGON &&
                      config->emachine != EM_RISCV;
 
   // If we are producing an executable and the symbol is non-preemptable, it
   // must be defined and the code sequence can be relaxed to use Local-Exec.
   //
   // ARM and RISC-V do not support any relaxations for TLS relocations, however,
   // we can omit the DTPMOD dynamic relocations and resolve them at link time
   // because them are always 1. This may be necessary for static linking as
   // DTPMOD may not be expected at load time.
   bool isLocalInExecutable = !sym.isPreemptible && !config->shared;
 
   // Local Dynamic is for access to module local TLS variables, while still
   // being suitable for being dynamically loaded via dlopen. GOT[e0] is the
   // module index, with a special value of 0 for the current module. GOT[e1] is
   // unused. There only needs to be one module index entry.
   if (oneof<R_TLSLD_GOT, R_TLSLD_GOTPLT, R_TLSLD_PC, R_TLSLD_HINT>(
           expr)) {
     // Local-Dynamic relocs can be relaxed to Local-Exec.
-    if (canRelax && !config->shared) {
+    if (toExecRelax) {
       c.relocations.push_back(
           {target->adjustRelaxExpr(type, nullptr, R_RELAX_TLS_LD_TO_LE), type,
            offset, addend, &sym});
       return target->getTlsGdRelaxSkip(type);
     }
     if (expr == R_TLSLD_HINT)
       return 1;
     if (in.got->addTlsIndex()) {
       if (isLocalInExecutable)
         in.got->relocations.push_back(
             {R_ADDEND, target->symbolicRel, in.got->getTlsIndexOff(), 1, &sym});
       else
         mainPart->relaDyn->addReloc(target->tlsModuleIndexRel, in.got,
                                 in.got->getTlsIndexOff(), nullptr);
     }
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
 
   // Local-Dynamic relocs can be relaxed to Local-Exec.
-  if (expr == R_DTPREL && canRelax && !config->shared) {
+  if (expr == R_DTPREL && toExecRelax) {
     c.relocations.push_back(
         {target->adjustRelaxExpr(type, nullptr, R_RELAX_TLS_LD_TO_LE), type,
          offset, addend, &sym});
     return 1;
   }
 
   // Local-Dynamic sequence where offset of tls variable relative to dynamic
   // thread pointer is stored in the got. This cannot be relaxed to Local-Exec.
   if (expr == R_TLSLD_GOT_OFF) {
     if (!sym.isInGot()) {
       in.got->addEntry(sym);
       uint64_t off = sym.getGotOffset();
       in.got->relocations.push_back(
           {R_ABS, target->tlsOffsetRel, off, 0, &sym});
     }
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
 
   if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
             R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC>(expr)) {
-    if (!canRelax || config->shared) {
+    if (!toExecRelax) {
       if (in.got->addDynTlsEntry(sym)) {
         uint64_t off = in.got->getGlobalDynOffset(sym);
 
         if (isLocalInExecutable)
           // Write one to the GOT slot.
           in.got->relocations.push_back(
               {R_ADDEND, target->symbolicRel, off, 1, &sym});
         else
if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
     }
     return target->getTlsGdRelaxSkip(type);
   }
 
   // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
   // defined.
   if (oneof<R_GOT, R_GOTPLT, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF,
             R_TLSIE_HINT>(expr) &&
-      canRelax && isLocalInExecutable) {
+      toExecRelax && isLocalInExecutable) {
     c.relocations.push_back({R_RELAX_TLS_IE_TO_LE, type, offset, addend, &sym});
     return 1;
   }
 
   if (expr == R_TLSIE_HINT)
     return 1;
   return 0;
 }