contrib/llvm/tools/lld/ELF/Relocations.cpp

   1 //===- Relocations.cpp ----------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains platform-independent functions to process relocations.
  11 // I'll describe the overview of this file here.
  12 //
  13 // Simple relocations are easy to handle for the linker. For example,
  14 // for R_X86_64_PC64 relocs, the linker just has to fix up locations
  15 // with the relative offsets to the target symbols. It would just be
  16 // reading records from relocation sections and applying them to output.
  17 //
  18 // But not all relocations are that easy to handle. For example, for
  19 // R_386_GOTOFF relocs, the linker has to create new GOT entries for
  20 // symbols if they don't exist, and fix up locations with GOT entry
  21 // offsets from the beginning of GOT section. So there is more than
  22 // fixing addresses in relocation processing.
  23 //
  24 // ELF defines a large number of complex relocations.
  25 //
  26 // The functions in this file analyze relocations and do whatever needs
  27 // to be done. It includes, but not limited to, the following.
  28 //
  29 //  - create GOT/PLT entries
  30 //  - create new relocations in .dynsym to let the dynamic linker resolve
  31 //    them at runtime (since ELF supports dynamic linking, not all
  32 //    relocations can be resolved at link-time)
  33 //  - create COPY relocs and reserve space in .bss
  34 //  - replace expensive relocs (in terms of runtime cost) with cheap ones
  35 //  - error out infeasible combinations such as PIC and non-relative relocs
  36 //
  37 // Note that the functions in this file don't actually apply relocations
  38 // because it doesn't know about the output file nor the output file buffer.
  39 // It instead stores Relocation objects to InputSection's Relocations
  40 // vector to let it apply later in InputSection::writeTo.
  41 //
  42 //===----------------------------------------------------------------------===//
  43
  44 #include "Relocations.h"
  45 #include "Config.h"
  46 #include "OutputSections.h"
  47 #include "Strings.h"
  48 #include "SymbolTable.h"
  49 #include "SyntheticSections.h"
  50 #include "Target.h"
  51 #include "Thunks.h"
  52
  53 #include "llvm/Support/Endian.h"
  54 #include "llvm/Support/raw_ostream.h"
  55
  56 using namespace llvm;
  57 using namespace llvm::ELF;
  58 using namespace llvm::object;
  59 using namespace llvm::support::endian;
  60
  61 namespace lld {
  62 namespace elf {
  63
  64 static bool refersToGotEntry(RelExpr Expr) {
  65   return isRelExprOneOf<R_GOT, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOT_OFF,
  66                         R_MIPS_GOT_OFF32, R_MIPS_TLSGD, R_MIPS_TLSLD,
  67                         R_GOT_PAGE_PC, R_GOT_PC, R_GOT_FROM_END, R_TLSGD,
  68                         R_TLSGD_PC, R_TLSDESC, R_TLSDESC_PAGE>(Expr);
  69 }
  70
  71 static bool isPreemptible(const SymbolBody &Body, uint32_t Type) {
  72   // In case of MIPS GP-relative relocations always resolve to a definition
  73   // in a regular input file, ignoring the one-definition rule. So we,
  74   // for example, should not attempt to create a dynamic relocation even
  75   // if the target symbol is preemptible. There are two two MIPS GP-relative
  76   // relocations R_MIPS_GPREL16 and R_MIPS_GPREL32. But only R_MIPS_GPREL16
  77   // can be against a preemptible symbol.
  78   // To get MIPS relocation type we apply 0xff mask. In case of O32 ABI all
  79   // relocation types occupy eight bit. In case of N64 ABI we extract first
  80   // relocation from 3-in-1 packet because only the first relocation can
  81   // be against a real symbol.
  82   if (Config->EMachine == EM_MIPS && (Type & 0xff) == R_MIPS_GPREL16)
  83     return false;
  84   return Body.isPreemptible();
  85 }
  86
  87 // This function is similar to the `handleTlsRelocation`. ARM and MIPS do not
  88 // support any relaxations for TLS relocations so by factoring out ARM and MIPS
  89 // handling in to the separate function we can simplify the code and do not
  90 // pollute `handleTlsRelocation` by ARM and MIPS `ifs` statements.
  91 template <class ELFT, class GOT>
  92 static unsigned handleNoRelaxTlsRelocation(
  93     GOT *Got, uint32_t Type, SymbolBody &Body, InputSectionBase<ELFT> &C,
  94     typename ELFT::uint Offset, typename ELFT::uint Addend, RelExpr Expr) {
  95   typedef typename ELFT::uint uintX_t;
  96   auto addModuleReloc = [](SymbolBody &Body, GOT *Got, uintX_t Off, bool LD) {
  97     // The Dynamic TLS Module Index Relocation can be statically resolved to 1
  98     // if we know that we are linking an executable. For ARM we resolve the
  99     // relocation when writing the Got. MIPS has a custom Got implementation
 100     // that writes the Module index in directly.
 101     if (!Body.isPreemptible() && !Config->Pic && Config->EMachine == EM_ARM)
 102       Got->Relocations.push_back(
 103           {R_ABS, Target->TlsModuleIndexRel, Off, 0, &Body});
 104     else {
 105       SymbolBody *Dest = LD ? nullptr : &Body;
 106       In<ELFT>::RelaDyn->addReloc(
 107           {Target->TlsModuleIndexRel, Got, Off, false, Dest, 0});
 108     }
 109   };
 110   if (Expr == R_MIPS_TLSLD || Expr == R_TLSLD_PC) {
 111     if (Got->addTlsIndex() && (Config->Pic || Config->EMachine == EM_ARM))
 112       addModuleReloc(Body, Got, Got->getTlsIndexOff(), true);
 113     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
 114     return 1;
 115   }
 116   if (Target->isTlsGlobalDynamicRel(Type)) {
 117     if (Got->addDynTlsEntry(Body) &&
 118         (Body.isPreemptible() || Config->EMachine == EM_ARM)) {
 119       uintX_t Off = Got->getGlobalDynOffset(Body);
 120       addModuleReloc(Body, Got, Off, false);
 121       if (Body.isPreemptible())
 122         In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Got,
 123                                      Off + (uintX_t)sizeof(uintX_t), false,
 124                                      &Body, 0});
 125     }
 126     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
 127     return 1;
 128   }
 129   return 0;
 130 }
 131
 132 // Returns the number of relocations processed.
 133 template <class ELFT>
 134 static unsigned handleTlsRelocation(uint32_t Type, SymbolBody &Body,
 135                                     InputSectionBase<ELFT> &C,
 136                                     typename ELFT::uint Offset,
 137                                     typename ELFT::uint Addend, RelExpr Expr) {
 138   if (!(C.Flags & SHF_ALLOC))
 139     return 0;
 140
 141   if (!Body.isTls())
 142     return 0;
 143
 144   typedef typename ELFT::uint uintX_t;
 145
 146   if (Config->EMachine == EM_ARM)
 147     return handleNoRelaxTlsRelocation<ELFT>(In<ELFT>::Got, Type, Body, C,
 148                                             Offset, Addend, Expr);
 149   if (Config->EMachine == EM_MIPS)
 150     return handleNoRelaxTlsRelocation<ELFT>(In<ELFT>::MipsGot, Type, Body, C,
 151                                             Offset, Addend, Expr);
 152
 153   bool IsPreemptible = isPreemptible(Body, Type);
 154   if ((Expr == R_TLSDESC || Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC_CALL) &&
 155       Config->Shared) {
 156     if (In<ELFT>::Got->addDynTlsEntry(Body)) {
 157       uintX_t Off = In<ELFT>::Got->getGlobalDynOffset(Body);
 158       In<ELFT>::RelaDyn->addReloc({Target->TlsDescRel, In<ELFT>::Got, Off,
 159                                    !IsPreemptible, &Body, 0});
 160     }
 161     if (Expr != R_TLSDESC_CALL)
 162       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
 163     return 1;
 164   }
 165
 166   if (Expr == R_TLSLD_PC || Expr == R_TLSLD) {
 167     // Local-Dynamic relocs can be relaxed to Local-Exec.
 168     if (!Config->Shared) {
 169       C.Relocations.push_back(
 170           {R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
 171       return 2;
 172     }
 173     if (In<ELFT>::Got->addTlsIndex())
 174       In<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel, In<ELFT>::Got,
 175                                    In<ELFT>::Got->getTlsIndexOff(), false,
 176                                    nullptr, 0});
 177     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
 178     return 1;
 179   }
 180
 181   // Local-Dynamic relocs can be relaxed to Local-Exec.
 182   if (Target->isTlsLocalDynamicRel(Type) && !Config->Shared) {
 183     C.Relocations.push_back(
 184         {R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
 185     return 1;
 186   }
 187
 188   if (Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC || Expr == R_TLSDESC_CALL ||
 189       Target->isTlsGlobalDynamicRel(Type)) {
 190     if (Config->Shared) {
 191       if (In<ELFT>::Got->addDynTlsEntry(Body)) {
 192         uintX_t Off = In<ELFT>::Got->getGlobalDynOffset(Body);
 193         In<ELFT>::RelaDyn->addReloc(
 194             {Target->TlsModuleIndexRel, In<ELFT>::Got, Off, false, &Body, 0});
 195
 196         // If the symbol is preemptible we need the dynamic linker to write
 197         // the offset too.
 198         uintX_t OffsetOff = Off + (uintX_t)sizeof(uintX_t);
 199         if (IsPreemptible)
 200           In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, In<ELFT>::Got,
 201                                        OffsetOff, false, &Body, 0});
 202         else
 203           In<ELFT>::Got->Relocations.push_back(
 204               {R_ABS, Target->TlsOffsetRel, OffsetOff, 0, &Body});
 205       }
 206       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
 207       return 1;
 208     }
 209
 210     // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
 211     // depending on the symbol being locally defined or not.
 212     if (IsPreemptible) {
 213       C.Relocations.push_back(
 214           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_IE), Type,
 215            Offset, Addend, &Body});
 216       if (!Body.isInGot()) {
 217         In<ELFT>::Got->addEntry(Body);
 218         In<ELFT>::RelaDyn->addReloc({Target->TlsGotRel, In<ELFT>::Got,
 219                                      Body.getGotOffset<ELFT>(), false, &Body,
 220                                      0});
 221       }
 222       return Target->TlsGdRelaxSkip;
 223     }
 224     C.Relocations.push_back(
 225         {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_LE), Type,
 226          Offset, Addend, &Body});
 227     return Target->TlsGdRelaxSkip;
 228   }
 229
 230   // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
 231   // defined.
 232   if (Target->isTlsInitialExecRel(Type) && !Config->Shared && !IsPreemptible) {
 233     C.Relocations.push_back(
 234         {R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Body});
 235     return 1;
 236   }
 237   return 0;
 238 }
 239
 240 template <endianness E> static int16_t readSignedLo16(const uint8_t *Loc) {
 241   return read32<E>(Loc) & 0xffff;
 242 }
 243
 244 template <class RelTy>
 245 static uint32_t getMipsPairType(const RelTy *Rel, const SymbolBody &Sym) {
 246   switch (Rel->getType(Config->Mips64EL)) {
 247   case R_MIPS_HI16:
 248     return R_MIPS_LO16;
 249   case R_MIPS_GOT16:
 250     return Sym.isLocal() ? R_MIPS_LO16 : R_MIPS_NONE;
 251   case R_MIPS_PCHI16:
 252     return R_MIPS_PCLO16;
 253   case R_MICROMIPS_HI16:
 254     return R_MICROMIPS_LO16;
 255   default:
 256     return R_MIPS_NONE;
 257   }
 258 }
 259
 260 template <class ELFT, class RelTy>
 261 static int32_t findMipsPairedAddend(const uint8_t *Buf, const uint8_t *BufLoc,
 262                                     SymbolBody &Sym, const RelTy *Rel,
 263                                     const RelTy *End) {
 264   uint32_t SymIndex = Rel->getSymbol(Config->Mips64EL);
 265   uint32_t Type = getMipsPairType(Rel, Sym);
 266
 267   // Some MIPS relocations use addend calculated from addend of the relocation
 268   // itself and addend of paired relocation. ABI requires to compute such
 269   // combined addend in case of REL relocation record format only.
 270   // See p. 4-17 at ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 271   if (RelTy::IsRela || Type == R_MIPS_NONE)
 272     return 0;
 273
 274   for (const RelTy *RI = Rel; RI != End; ++RI) {
 275     if (RI->getType(Config->Mips64EL) != Type)
 276       continue;
 277     if (RI->getSymbol(Config->Mips64EL) != SymIndex)
 278       continue;
 279     const endianness E = ELFT::TargetEndianness;
 280     return ((read32<E>(BufLoc) & 0xffff) << 16) +
 281            readSignedLo16<E>(Buf + RI->r_offset);
 282   }
 283   warn("can't find matching " + toString(Type) + " relocation for " +
 284        toString(Rel->getType(Config->Mips64EL)));
 285   return 0;
 286 }
 287
 288 // True if non-preemptable symbol always has the same value regardless of where
 289 // the DSO is loaded.
 290 template <class ELFT> static bool isAbsolute(const SymbolBody &Body) {
 291   if (Body.isUndefined())
 292     return !Body.isLocal() && Body.symbol()->isWeak();
 293   if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(&Body))
 294     return DR->Section == nullptr; // Absolute symbol.
 295   return false;
 296 }
 297
 298 template <class ELFT> static bool isAbsoluteValue(const SymbolBody &Body) {
 299   return isAbsolute<ELFT>(Body) || Body.isTls();
 300 }
 301
 302 static bool needsPlt(RelExpr Expr) {
 303   return isRelExprOneOf<R_PLT_PC, R_PPC_PLT_OPD, R_PLT, R_PLT_PAGE_PC,
 304                         R_THUNK_PLT_PC>(Expr);
 305 }
 306
 307 // True if this expression is of the form Sym - X, where X is a position in the
 308 // file (PC, or GOT for example).
 309 static bool isRelExpr(RelExpr Expr) {
 310   return isRelExprOneOf<R_PC, R_GOTREL, R_GOTREL_FROM_END, R_MIPS_GOTREL,
 311                         R_PAGE_PC, R_RELAX_GOT_PC, R_THUNK_PC, R_THUNK_PLT_PC>(
 312       Expr);
 313 }
 314
 315 template <class ELFT>
 316 static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
 317                                      const SymbolBody &Body,
 318                                      InputSectionBase<ELFT> &S,
 319                                      typename ELFT::uint RelOff) {
 320   // These expressions always compute a constant
 321   if (isRelExprOneOf<R_SIZE, R_GOT_FROM_END, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE,
 322                      R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_TLSGD,
 323                      R_GOT_PAGE_PC, R_GOT_PC, R_PLT_PC, R_TLSGD_PC, R_TLSGD,
 324                      R_PPC_PLT_OPD, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT,
 325                      R_THUNK_PC, R_THUNK_PLT_PC>(E))
 326     return true;
 327
 328   // These never do, except if the entire file is position dependent or if
 329   // only the low bits are used.
 330   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
 331     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
 332
 333   if (isPreemptible(Body, Type))
 334     return false;
 335
 336   if (!Config->Pic)
 337     return true;
 338
 339   bool AbsVal = isAbsoluteValue<ELFT>(Body);
 340   bool RelE = isRelExpr(E);
 341   if (AbsVal && !RelE)
 342     return true;
 343   if (!AbsVal && RelE)
 344     return true;
 345
 346   // Relative relocation to an absolute value. This is normally unrepresentable,
 347   // but if the relocation refers to a weak undefined symbol, we allow it to
 348   // resolve to the image base. This is a little strange, but it allows us to
 349   // link function calls to such symbols. Normally such a call will be guarded
 350   // with a comparison, which will load a zero from the GOT.
 351   // Another special case is MIPS _gp_disp symbol which represents offset
 352   // between start of a function and '_gp' value and defined as absolute just
 353   // to simplify the code.
 354   if (AbsVal && RelE) {
 355     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
 356       return true;
 357     if (&Body == ElfSym<ELFT>::MipsGpDisp)
 358       return true;
 359     error(S.getLocation(RelOff) + ": relocation " + toString(Type) +
 360           " cannot refer to absolute symbol '" + toString(Body) +
 361           "' defined in " + toString(Body.File));
 362     return true;
 363   }
 364
 365   return Target->usesOnlyLowPageBits(Type);
 366 }
 367
 368 static RelExpr toPlt(RelExpr Expr) {
 369   if (Expr == R_PPC_OPD)
 370     return R_PPC_PLT_OPD;
 371   if (Expr == R_PC)
 372     return R_PLT_PC;
 373   if (Expr == R_PAGE_PC)
 374     return R_PLT_PAGE_PC;
 375   if (Expr == R_ABS)
 376     return R_PLT;
 377   return Expr;
 378 }
 379
 380 static RelExpr fromPlt(RelExpr Expr) {
 381   // We decided not to use a plt. Optimize a reference to the plt to a
 382   // reference to the symbol itself.
 383   if (Expr == R_PLT_PC)
 384     return R_PC;
 385   if (Expr == R_PPC_PLT_OPD)
 386     return R_PPC_OPD;
 387   if (Expr == R_PLT)
 388     return R_ABS;
 389   return Expr;
 390 }
 391
 392 template <class ELFT> static uint32_t getAlignment(SharedSymbol<ELFT> *SS) {
 393   typedef typename ELFT::uint uintX_t;
 394
 395   uintX_t SecAlign = SS->file()->getSection(SS->Sym)->sh_addralign;
 396   uintX_t SymValue = SS->Sym.st_value;
 397   int TrailingZeros =
 398       std::min(countTrailingZeros(SecAlign), countTrailingZeros(SymValue));
 399   return 1 << TrailingZeros;
 400 }
 401
 402 // Reserve space in .bss for copy relocation.
 403 template <class ELFT> static void addCopyRelSymbol(SharedSymbol<ELFT> *SS) {
 404   typedef typename ELFT::uint uintX_t;
 405   typedef typename ELFT::Sym Elf_Sym;
 406
 407   // Copy relocation against zero-sized symbol doesn't make sense.
 408   uintX_t SymSize = SS->template getSize<ELFT>();
 409   if (SymSize == 0)
 410     fatal("cannot create a copy relocation for symbol " + toString(*SS));
 411
 412   uintX_t Alignment = getAlignment(SS);
 413   uintX_t Off = alignTo(Out<ELFT>::Bss->Size, Alignment);
 414   Out<ELFT>::Bss->Size = Off + SymSize;
 415   Out<ELFT>::Bss->updateAlignment(Alignment);
 416   uintX_t Shndx = SS->Sym.st_shndx;
 417   uintX_t Value = SS->Sym.st_value;
 418   // Look through the DSO's dynamic symbol table for aliases and create a
 419   // dynamic symbol for each one. This causes the copy relocation to correctly
 420   // interpose any aliases.
 421   for (const Elf_Sym &S : SS->file()->getGlobalSymbols()) {
 422     if (S.st_shndx != Shndx || S.st_value != Value)
 423       continue;
 424     auto *Alias = dyn_cast_or_null<SharedSymbol<ELFT>>(
 425         Symtab<ELFT>::X->find(check(S.getName(SS->file()->getStringTable()))));
 426     if (!Alias)
 427       continue;
 428     Alias->OffsetInBss = Off;
 429     Alias->NeedsCopyOrPltAddr = true;
 430     Alias->symbol()->IsUsedInRegularObj = true;
 431   }
 432   In<ELFT>::RelaDyn->addReloc(
 433       {Target->CopyRel, Out<ELFT>::Bss, SS->OffsetInBss, false, SS, 0});
 434 }
 435
 436 template <class ELFT>
 437 static RelExpr adjustExpr(const elf::ObjectFile<ELFT> &File, SymbolBody &Body,
 438                           bool IsWrite, RelExpr Expr, uint32_t Type,
 439                           const uint8_t *Data, InputSectionBase<ELFT> &S,
 440                           typename ELFT::uint RelOff) {
 441   bool Preemptible = isPreemptible(Body, Type);
 442   if (Body.isGnuIFunc()) {
 443     Expr = toPlt(Expr);
 444   } else if (!Preemptible) {
 445     if (needsPlt(Expr))
 446       Expr = fromPlt(Expr);
 447     if (Expr == R_GOT_PC && !isAbsoluteValue<ELFT>(Body))
 448       Expr = Target->adjustRelaxExpr(Type, Data, Expr);
 449   }
 450   Expr = Target->getThunkExpr(Expr, Type, File, Body);
 451
 452   if (IsWrite || isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, S, RelOff))
 453     return Expr;
 454
 455   // This relocation would require the dynamic linker to write a value to read
 456   // only memory. We can hack around it if we are producing an executable and
 457   // the refered symbol can be preemepted to refer to the executable.
 458   if (Config->Shared || (Config->Pic && !isRelExpr(Expr))) {
 459     error(S.getLocation(RelOff) + ": can't create dynamic relocation " +
 460           toString(Type) + " against " +
 461           (Body.getName().empty() ? "local symbol in readonly segment"
 462                                   : "symbol '" + toString(Body) + "'") +
 463           " defined in " + toString(Body.File));
 464     return Expr;
 465   }
 466   if (Body.getVisibility() != STV_DEFAULT) {
 467     error(S.getLocation(RelOff) + ": cannot preempt symbol '" + toString(Body) +
 468           "' defined in " + toString(Body.File));
 469     return Expr;
 470   }
 471   if (Body.isObject()) {
 472     // Produce a copy relocation.
 473     auto *B = cast<SharedSymbol<ELFT>>(&Body);
 474     if (!B->needsCopy())
 475       addCopyRelSymbol(B);
 476     return Expr;
 477   }
 478   if (Body.isFunc()) {
 479     // This handles a non PIC program call to function in a shared library. In
 480     // an ideal world, we could just report an error saying the relocation can
 481     // overflow at runtime. In the real world with glibc, crt1.o has a
 482     // R_X86_64_PC32 pointing to libc.so.
 483     //
 484     // The general idea on how to handle such cases is to create a PLT entry and
 485     // use that as the function value.
 486     //
 487     // For the static linking part, we just return a plt expr and everything
 488     // else will use the the PLT entry as the address.
 489     //
 490     // The remaining problem is making sure pointer equality still works. We
 491     // need the help of the dynamic linker for that. We let it know that we have
 492     // a direct reference to a so symbol by creating an undefined symbol with a
 493     // non zero st_value. Seeing that, the dynamic linker resolves the symbol to
 494     // the value of the symbol we created. This is true even for got entries, so
 495     // pointer equality is maintained. To avoid an infinite loop, the only entry
 496     // that points to the real function is a dedicated got entry used by the
 497     // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
 498     // R_386_JMP_SLOT, etc).
 499     Body.NeedsCopyOrPltAddr = true;
 500     return toPlt(Expr);
 501   }
 502   error("symbol '" + toString(Body) + "' defined in " + toString(Body.File) +
 503         " is missing type");
 504
 505   return Expr;
 506 }
 507
 508 template <class ELFT, class RelTy>
 509 static typename ELFT::uint computeAddend(const elf::ObjectFile<ELFT> &File,
 510                                          const uint8_t *SectionData,
 511                                          const RelTy *End, const RelTy &RI,
 512                                          RelExpr Expr, SymbolBody &Body) {
 513   typedef typename ELFT::uint uintX_t;
 514
 515   uint32_t Type = RI.getType(Config->Mips64EL);
 516   uintX_t Addend = getAddend<ELFT>(RI);
 517   const uint8_t *BufLoc = SectionData + RI.r_offset;
 518   if (!RelTy::IsRela)
 519     Addend += Target->getImplicitAddend(BufLoc, Type);
 520   if (Config->EMachine == EM_MIPS) {
 521     Addend += findMipsPairedAddend<ELFT>(SectionData, BufLoc, Body, &RI, End);
 522     if (Type == R_MIPS_LO16 && Expr == R_PC)
 523       // R_MIPS_LO16 expression has R_PC type iif the target is _gp_disp
 524       // symbol. In that case we should use the following formula for
 525       // calculation "AHL + GP - P + 4". Let's add 4 right here.
 526       // For details see p. 4-19 at
 527       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 528       Addend += 4;
 529     if (Expr == R_MIPS_GOTREL && Body.isLocal())
 530       Addend += File.MipsGp0;
 531   }
 532   if (Config->Pic && Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
 533     Addend += getPPC64TocBase();
 534   return Addend;
 535 }
 536
 537 template <class ELFT>
 538 static void reportUndefined(SymbolBody &Sym, InputSectionBase<ELFT> &S,
 539                             typename ELFT::uint Offset) {
 540   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
 541     return;
 542
 543   if (Config->Shared && Sym.symbol()->Visibility == STV_DEFAULT &&
 544       Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
 545     return;
 546
 547   std::string Msg =
 548       S.getLocation(Offset) + ": undefined symbol '" + toString(Sym) + "'";
 549
 550   if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
 551     warn(Msg);
 552   else
 553     error(Msg);
 554 }
 555
 556 template <class RelTy>
 557 static std::pair<uint32_t, uint32_t>
 558 mergeMipsN32RelTypes(uint32_t Type, uint32_t Offset, RelTy *I, RelTy *E) {
 559   // MIPS N32 ABI treats series of successive relocations with the same offset
 560   // as a single relocation. The similar approach used by N64 ABI, but this ABI
 561   // packs all relocations into the single relocation record. Here we emulate
 562   // this for the N32 ABI. Iterate over relocation with the same offset and put
 563   // theirs types into the single bit-set.
 564   uint32_t Processed = 0;
 565   for (; I != E && Offset == I->r_offset; ++I) {
 566     ++Processed;
 567     Type |= I->getType(Config->Mips64EL) << (8 * Processed);
 568   }
 569   return std::make_pair(Type, Processed);
 570 }
 571
 572 // The reason we have to do this early scan is as follows
 573 // * To mmap the output file, we need to know the size
 574 // * For that, we need to know how many dynamic relocs we will have.
 575 // It might be possible to avoid this by outputting the file with write:
 576 // * Write the allocated output sections, computing addresses.
 577 // * Apply relocations, recording which ones require a dynamic reloc.
 578 // * Write the dynamic relocations.
 579 // * Write the rest of the file.
 580 // This would have some drawbacks. For example, we would only know if .rela.dyn
 581 // is needed after applying relocations. If it is, it will go after rw and rx
 582 // sections. Given that it is ro, we will need an extra PT_LOAD. This
 583 // complicates things for the dynamic linker and means we would have to reserve
 584 // space for the extra PT_LOAD even if we end up not using it.
 585 template <class ELFT, class RelTy>
 586 static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
 587   typedef typename ELFT::uint uintX_t;
 588
 589   bool IsWrite = C.Flags & SHF_WRITE;
 590
 591   auto AddDyn = [=](const DynamicReloc<ELFT> &Reloc) {
 592     In<ELFT>::RelaDyn->addReloc(Reloc);
 593   };
 594
 595   const elf::ObjectFile<ELFT> *File = C.getFile();
 596   ArrayRef<uint8_t> SectionData = C.Data;
 597   const uint8_t *Buf = SectionData.begin();
 598
 599   ArrayRef<EhSectionPiece> Pieces;
 600   if (auto *Eh = dyn_cast<EhInputSection<ELFT>>(&C))
 601     Pieces = Eh->Pieces;
 602
 603   ArrayRef<EhSectionPiece>::iterator PieceI = Pieces.begin();
 604   ArrayRef<EhSectionPiece>::iterator PieceE = Pieces.end();
 605
 606   for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
 607     const RelTy &RI = *I;
 608     SymbolBody &Body = File->getRelocTargetSym(RI);
 609     uint32_t Type = RI.getType(Config->Mips64EL);
 610
 611     if (Config->MipsN32Abi) {
 612       uint32_t Processed;
 613       std::tie(Type, Processed) =
 614           mergeMipsN32RelTypes(Type, RI.r_offset, I + 1, E);
 615       I += Processed;
 616     }
 617
 618     // We only report undefined symbols if they are referenced somewhere in the
 619     // code.
 620     if (!Body.isLocal() && Body.isUndefined() && !Body.symbol()->isWeak())
 621       reportUndefined(Body, C, RI.r_offset);
 622
 623     RelExpr Expr = Target->getRelExpr(Type, Body);
 624     bool Preemptible = isPreemptible(Body, Type);
 625     Expr = adjustExpr(*File, Body, IsWrite, Expr, Type, Buf + RI.r_offset, C,
 626                       RI.r_offset);
 627     if (ErrorCount)
 628       continue;
 629
 630     // Skip a relocation that points to a dead piece
 631     // in a eh_frame section.
 632     while (PieceI != PieceE &&
 633            (PieceI->InputOff + PieceI->size() <= RI.r_offset))
 634       ++PieceI;
 635
 636     // Compute the offset of this section in the output section. We do it here
 637     // to try to compute it only once.
 638     uintX_t Offset;
 639     if (PieceI != PieceE) {
 640       assert(PieceI->InputOff <= RI.r_offset && "Relocation not in any piece");
 641       if (PieceI->OutputOff == -1)
 642         continue;
 643       Offset = PieceI->OutputOff + RI.r_offset - PieceI->InputOff;
 644     } else {
 645       Offset = RI.r_offset;
 646     }
 647
 648     // This relocation does not require got entry, but it is relative to got and
 649     // needs it to be created. Here we request for that.
 650     if (Expr == R_GOTONLY_PC || Expr == R_GOTONLY_PC_FROM_END ||
 651         Expr == R_GOTREL || Expr == R_GOTREL_FROM_END || Expr == R_PPC_TOC)
 652       In<ELFT>::Got->HasGotOffRel = true;
 653
 654     uintX_t Addend = computeAddend(*File, Buf, E, RI, Expr, Body);
 655
 656     if (unsigned Processed =
 657             handleTlsRelocation<ELFT>(Type, Body, C, Offset, Addend, Expr)) {
 658       I += (Processed - 1);
 659       continue;
 660     }
 661
 662     // Ignore "hint" and TLS Descriptor call relocation because they are
 663     // only markers for relaxation.
 664     if (isRelExprOneOf<R_HINT, R_TLSDESC_CALL>(Expr))
 665       continue;
 666
 667     if (needsPlt(Expr) ||
 668         isRelExprOneOf<R_THUNK_ABS, R_THUNK_PC, R_THUNK_PLT_PC>(Expr) ||
 669         refersToGotEntry(Expr) || !isPreemptible(Body, Type)) {
 670       // If the relocation points to something in the file, we can process it.
 671       bool Constant =
 672           isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, C, RI.r_offset);
 673
 674       // If the output being produced is position independent, the final value
 675       // is still not known. In that case we still need some help from the
 676       // dynamic linker. We can however do better than just copying the incoming
 677       // relocation. We can process some of it and and just ask the dynamic
 678       // linker to add the load address.
 679       if (!Constant)
 680         AddDyn({Target->RelativeRel, &C, Offset, true, &Body, Addend});
 681
 682       // If the produced value is a constant, we just remember to write it
 683       // when outputting this section. We also have to do it if the format
 684       // uses Elf_Rel, since in that case the written value is the addend.
 685       if (Constant || !RelTy::IsRela)
 686         C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
 687     } else {
 688       // We don't know anything about the finaly symbol. Just ask the dynamic
 689       // linker to handle the relocation for us.
 690       if (!Target->isPicRel(Type))
 691         error(C.getLocation(Offset) + ": relocation " + toString(Type) +
 692               " cannot be used against shared object; recompile with -fPIC.");
 693       AddDyn({Target->getDynRel(Type), &C, Offset, false, &Body, Addend});
 694
 695       // MIPS ABI turns using of GOT and dynamic relocations inside out.
 696       // While regular ABI uses dynamic relocations to fill up GOT entries
 697       // MIPS ABI requires dynamic linker to fills up GOT entries using
 698       // specially sorted dynamic symbol table. This affects even dynamic
 699       // relocations against symbols which do not require GOT entries
 700       // creation explicitly, i.e. do not have any GOT-relocations. So if
 701       // a preemptible symbol has a dynamic relocation we anyway have
 702       // to create a GOT entry for it.
 703       // If a non-preemptible symbol has a dynamic relocation against it,
 704       // dynamic linker takes it st_value, adds offset and writes down
 705       // result of the dynamic relocation. In case of preemptible symbol
 706       // dynamic linker performs symbol resolution, writes the symbol value
 707       // to the GOT entry and reads the GOT entry when it needs to perform
 708       // a dynamic relocation.
 709       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf p.4-19
 710       if (Config->EMachine == EM_MIPS)
 711         In<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
 712       continue;
 713     }
 714
 715     // At this point we are done with the relocated position. Some relocations
 716     // also require us to create a got or plt entry.
 717
 718     // If a relocation needs PLT, we create a PLT and a GOT slot for the symbol.
 719     if (needsPlt(Expr)) {
 720       if (Body.isInPlt())
 721         continue;
 722
 723       if (Body.isGnuIFunc() && !Preemptible) {
 724         In<ELFT>::Iplt->addEntry(Body);
 725         In<ELFT>::IgotPlt->addEntry(Body);
 726         In<ELFT>::RelaIplt->addReloc({Target->IRelativeRel, In<ELFT>::IgotPlt,
 727                                       Body.getGotPltOffset<ELFT>(),
 728                                       !Preemptible, &Body, 0});
 729       } else {
 730         In<ELFT>::Plt->addEntry(Body);
 731         In<ELFT>::GotPlt->addEntry(Body);
 732         In<ELFT>::RelaPlt->addReloc({Target->PltRel, In<ELFT>::GotPlt,
 733                                      Body.getGotPltOffset<ELFT>(), !Preemptible,
 734                                      &Body, 0});
 735       }
 736       continue;
 737     }
 738
 739     if (refersToGotEntry(Expr)) {
 740       if (Config->EMachine == EM_MIPS) {
 741         // MIPS ABI has special rules to process GOT entries and doesn't
 742         // require relocation entries for them. A special case is TLS
 743         // relocations. In that case dynamic loader applies dynamic
 744         // relocations to initialize TLS GOT entries.
 745         // See "Global Offset Table" in Chapter 5 in the following document
 746         // for detailed description:
 747         // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 748         In<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
 749         if (Body.isTls() && Body.isPreemptible())
 750           AddDyn({Target->TlsGotRel, In<ELFT>::MipsGot,
 751                   Body.getGotOffset<ELFT>(), false, &Body, 0});
 752         continue;
 753       }
 754
 755       if (Body.isInGot())
 756         continue;
 757
 758       In<ELFT>::Got->addEntry(Body);
 759       uintX_t Off = Body.getGotOffset<ELFT>();
 760       uint32_t DynType;
 761       RelExpr GotRE = R_ABS;
 762       if (Body.isTls()) {
 763         DynType = Target->TlsGotRel;
 764         GotRE = R_TLS;
 765       } else if (!Preemptible && Config->Pic && !isAbsolute<ELFT>(Body))
 766         DynType = Target->RelativeRel;
 767       else
 768         DynType = Target->GotRel;
 769
 770       // FIXME: this logic is almost duplicated above.
 771       bool Constant = !Preemptible && !(Config->Pic && !isAbsolute<ELFT>(Body));
 772       if (!Constant)
 773         AddDyn({DynType, In<ELFT>::Got, Off, !Preemptible, &Body, 0});
 774       if (Constant || (!RelTy::IsRela && !Preemptible))
 775         In<ELFT>::Got->Relocations.push_back({GotRE, DynType, Off, 0, &Body});
 776       continue;
 777     }
 778   }
 779 }
 780
 781 template <class ELFT> void scanRelocations(InputSectionBase<ELFT> &S) {
 782   if (S.AreRelocsRela)
 783     scanRelocs(S, S.relas());
 784   else
 785     scanRelocs(S, S.rels());
 786 }
 787
 788 template <class ELFT, class RelTy>
 789 static void createThunks(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
 790   const elf::ObjectFile<ELFT> *File = C.getFile();
 791   for (const RelTy &Rel : Rels) {
 792     SymbolBody &Body = File->getRelocTargetSym(Rel);
 793     uint32_t Type = Rel.getType(Config->Mips64EL);
 794     RelExpr Expr = Target->getRelExpr(Type, Body);
 795     if (!isPreemptible(Body, Type) && needsPlt(Expr))
 796       Expr = fromPlt(Expr);
 797     Expr = Target->getThunkExpr(Expr, Type, *File, Body);
 798     // Some targets might require creation of thunks for relocations.
 799     // Now we support only MIPS which requires LA25 thunk to call PIC
 800     // code from non-PIC one, and ARM which requires interworking.
 801     if (Expr == R_THUNK_ABS || Expr == R_THUNK_PC || Expr == R_THUNK_PLT_PC) {
 802       auto *Sec = cast<InputSection<ELFT>>(&C);
 803       addThunk<ELFT>(Type, Body, *Sec);
 804     }
 805   }
 806 }
 807
 808 template <class ELFT> void createThunks(InputSectionBase<ELFT> &S) {
 809   if (S.AreRelocsRela)
 810     createThunks(S, S.relas());
 811   else
 812     createThunks(S, S.rels());
 813 }
 814
 815 template void scanRelocations<ELF32LE>(InputSectionBase<ELF32LE> &);
 816 template void scanRelocations<ELF32BE>(InputSectionBase<ELF32BE> &);
 817 template void scanRelocations<ELF64LE>(InputSectionBase<ELF64LE> &);
 818 template void scanRelocations<ELF64BE>(InputSectionBase<ELF64BE> &);
 819
 820 template void createThunks<ELF32LE>(InputSectionBase<ELF32LE> &);
 821 template void createThunks<ELF32BE>(InputSectionBase<ELF32BE> &);
 822 template void createThunks<ELF64LE>(InputSectionBase<ELF64LE> &);
 823 template void createThunks<ELF64BE>(InputSectionBase<ELF64BE> &);
 824 }
 825 }