contrib/llvm/lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

   1 //===-- MipsELFObjectWriter.cpp - Mips ELF Writer -------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include <algorithm>
  11 #include <list>
  12 #include "MCTargetDesc/MipsBaseInfo.h"
  13 #include "MCTargetDesc/MipsFixupKinds.h"
  14 #include "MCTargetDesc/MipsMCExpr.h"
  15 #include "MCTargetDesc/MipsMCTargetDesc.h"
  16 #include "llvm/ADT/STLExtras.h"
  17 #include "llvm/MC/MCAssembler.h"
  18 #include "llvm/MC/MCELFObjectWriter.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCSection.h"
  21 #include "llvm/MC/MCSymbolELF.h"
  22 #include "llvm/MC/MCValue.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25
  26 #define DEBUG_TYPE "mips-elf-object-writer"
  27
  28 using namespace llvm;
  29
  30 namespace {
  31 /// Holds additional information needed by the relocation ordering algorithm.
  32 struct MipsRelocationEntry {
  33   const ELFRelocationEntry R; ///< The relocation.
  34   bool Matched;               ///< Is this relocation part of a match.
  35
  36   MipsRelocationEntry(const ELFRelocationEntry &R) : R(R), Matched(false) {}
  37
  38   void print(raw_ostream &Out) const {
  39     R.print(Out);
  40     Out << ", Matched=" << Matched;
  41   }
  42 };
  43
  44 #ifndef NDEBUG
  45 raw_ostream &operator<<(raw_ostream &OS, const MipsRelocationEntry &RHS) {
  46   RHS.print(OS);
  47   return OS;
  48 }
  49 #endif
  50
  51 class MipsELFObjectWriter : public MCELFObjectTargetWriter {
  52 public:
  53   MipsELFObjectWriter(bool _is64Bit, uint8_t OSABI, bool _isN64,
  54                       bool IsLittleEndian);
  55
  56   ~MipsELFObjectWriter() override;
  57
  58   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
  59                         const MCFixup &Fixup, bool IsPCRel) const override;
  60   bool needsRelocateWithSymbol(const MCSymbol &Sym,
  61                                unsigned Type) const override;
  62   virtual void sortRelocs(const MCAssembler &Asm,
  63                           std::vector<ELFRelocationEntry> &Relocs) override;
  64 };
  65
  66 /// Copy elements in the range [First, Last) to d1 when the predicate is true or
  67 /// d2 when the predicate is false. This is essentially both std::copy_if and
  68 /// std::remove_copy_if combined into a single pass.
  69 template <class InputIt, class OutputIt1, class OutputIt2, class UnaryPredicate>
  70 std::pair<OutputIt1, OutputIt2> copy_if_else(InputIt First, InputIt Last,
  71                                              OutputIt1 d1, OutputIt2 d2,
  72                                              UnaryPredicate Predicate) {
  73   for (InputIt I = First; I != Last; ++I) {
  74     if (Predicate(*I)) {
  75       *d1 = *I;
  76       d1++;
  77     } else {
  78       *d2 = *I;
  79       d2++;
  80     }
  81   }
  82
  83   return std::make_pair(d1, d2);
  84 }
  85
  86 /// The possible results of the Predicate function used by find_best.
  87 enum FindBestPredicateResult {
  88   FindBest_NoMatch = 0,  ///< The current element is not a match.
  89   FindBest_Match,        ///< The current element is a match but better ones are
  90                          ///  possible.
  91   FindBest_PerfectMatch, ///< The current element is an unbeatable match.
  92 };
  93
  94 /// Find the best match in the range [First, Last).
  95 ///
  96 /// An element matches when Predicate(X) returns FindBest_Match or
  97 /// FindBest_PerfectMatch. A value of FindBest_PerfectMatch also terminates
  98 /// the search. BetterThan(A, B) is a comparator that returns true when A is a
  99 /// better match than B. The return value is the position of the best match.
 100 ///
 101 /// This is similar to std::find_if but finds the best of multiple possible
 102 /// matches.
 103 template <class InputIt, class UnaryPredicate, class Comparator>
 104 InputIt find_best(InputIt First, InputIt Last, UnaryPredicate Predicate,
 105                   Comparator BetterThan) {
 106   InputIt Best = Last;
 107
 108   for (InputIt I = First; I != Last; ++I) {
 109     unsigned Matched = Predicate(*I);
 110     if (Matched != FindBest_NoMatch) {
 111       DEBUG(dbgs() << std::distance(First, I) << " is a match (";
 112             I->print(dbgs()); dbgs() << ")\n");
 113       if (Best == Last || BetterThan(*I, *Best)) {
 114         DEBUG(dbgs() << ".. and it beats the last one\n");
 115         Best = I;
 116       }
 117     }
 118     if (Matched == FindBest_PerfectMatch) {
 119       DEBUG(dbgs() << ".. and it is unbeatable\n");
 120       break;
 121     }
 122   }
 123
 124   return Best;
 125 }
 126
 127 /// Determine the low relocation that matches the given relocation.
 128 /// If the relocation does not need a low relocation then the return value
 129 /// is ELF::R_MIPS_NONE.
 130 ///
 131 /// The relocations that need a matching low part are
 132 /// R_(MIPS|MICROMIPS|MIPS16)_HI16 for all symbols and
 133 /// R_(MIPS|MICROMIPS|MIPS16)_GOT16 for local symbols only.
 134 static unsigned getMatchingLoType(const ELFRelocationEntry &Reloc) {
 135   unsigned Type = Reloc.Type;
 136   if (Type == ELF::R_MIPS_HI16)
 137     return ELF::R_MIPS_LO16;
 138   if (Type == ELF::R_MICROMIPS_HI16)
 139     return ELF::R_MICROMIPS_LO16;
 140   if (Type == ELF::R_MIPS16_HI16)
 141     return ELF::R_MIPS16_LO16;
 142
 143   if (Reloc.OriginalSymbol->getBinding() != ELF::STB_LOCAL)
 144     return ELF::R_MIPS_NONE;
 145
 146   if (Type == ELF::R_MIPS_GOT16)
 147     return ELF::R_MIPS_LO16;
 148   if (Type == ELF::R_MICROMIPS_GOT16)
 149     return ELF::R_MICROMIPS_LO16;
 150   if (Type == ELF::R_MIPS16_GOT16)
 151     return ELF::R_MIPS16_LO16;
 152
 153   return ELF::R_MIPS_NONE;
 154 }
 155
 156 /// Determine whether a relocation (X) matches the one given in R.
 157 ///
 158 /// A relocation matches if:
 159 /// - It's type matches that of a corresponding low part. This is provided in
 160 ///   MatchingType for efficiency.
 161 /// - It's based on the same symbol.
 162 /// - It's offset of greater or equal to that of the one given in R.
 163 ///   It should be noted that this rule assumes the programmer does not use
 164 ///   offsets that exceed the alignment of the symbol. The carry-bit will be
 165 ///   incorrect if this is not true.
 166 ///
 167 /// A matching relocation is unbeatable if:
 168 /// - It is not already involved in a match.
 169 /// - It's offset is exactly that of the one given in R.
 170 static FindBestPredicateResult isMatchingReloc(const MipsRelocationEntry &X,
 171                                                const ELFRelocationEntry &R,
 172                                                unsigned MatchingType) {
 173   if (X.R.Type == MatchingType && X.R.OriginalSymbol == R.OriginalSymbol) {
 174     if (!X.Matched &&
 175         X.R.OriginalAddend == R.OriginalAddend)
 176       return FindBest_PerfectMatch;
 177     else if (X.R.OriginalAddend >= R.OriginalAddend)
 178       return FindBest_Match;
 179   }
 180   return FindBest_NoMatch;
 181 }
 182
 183 /// Determine whether Candidate or PreviousBest is the better match.
 184 /// The return value is true if Candidate is the better match.
 185 ///
 186 /// A matching relocation is a better match if:
 187 /// - It has a smaller addend.
 188 /// - It is not already involved in a match.
 189 static bool compareMatchingRelocs(const MipsRelocationEntry &Candidate,
 190                                   const MipsRelocationEntry &PreviousBest) {
 191   if (Candidate.R.OriginalAddend != PreviousBest.R.OriginalAddend)
 192     return Candidate.R.OriginalAddend < PreviousBest.R.OriginalAddend;
 193   return PreviousBest.Matched && !Candidate.Matched;
 194 }
 195
 196 #ifndef NDEBUG
 197 /// Print all the relocations.
 198 template <class Container>
 199 static void dumpRelocs(const char *Prefix, const Container &Relocs) {
 200   for (const auto &R : Relocs)
 201     dbgs() << Prefix << R << "\n";
 202 }
 203 #endif
 204
 205 } // end anonymous namespace
 206
 207 MipsELFObjectWriter::MipsELFObjectWriter(bool _is64Bit, uint8_t OSABI,
 208                                          bool _isN64, bool IsLittleEndian)
 209     : MCELFObjectTargetWriter(_is64Bit, OSABI, ELF::EM_MIPS,
 210                               /*HasRelocationAddend*/ _isN64,
 211                               /*IsN64*/ _isN64) {}
 212
 213 MipsELFObjectWriter::~MipsELFObjectWriter() {}
 214
 215 unsigned MipsELFObjectWriter::getRelocType(MCContext &Ctx,
 216                                            const MCValue &Target,
 217                                            const MCFixup &Fixup,
 218                                            bool IsPCRel) const {
 219   // Determine the type of the relocation.
 220   unsigned Kind = (unsigned)Fixup.getKind();
 221
 222   switch (Kind) {
 223   case Mips::fixup_Mips_NONE:
 224     return ELF::R_MIPS_NONE;
 225   case Mips::fixup_Mips_16:
 226   case FK_Data_2:
 227     return IsPCRel ? ELF::R_MIPS_PC16 : ELF::R_MIPS_16;
 228   case Mips::fixup_Mips_32:
 229   case FK_Data_4:
 230     return IsPCRel ? ELF::R_MIPS_PC32 : ELF::R_MIPS_32;
 231   }
 232
 233   if (IsPCRel) {
 234     switch (Kind) {
 235     case Mips::fixup_Mips_Branch_PCRel:
 236     case Mips::fixup_Mips_PC16:
 237       return ELF::R_MIPS_PC16;
 238     case Mips::fixup_MICROMIPS_PC7_S1:
 239       return ELF::R_MICROMIPS_PC7_S1;
 240     case Mips::fixup_MICROMIPS_PC10_S1:
 241       return ELF::R_MICROMIPS_PC10_S1;
 242     case Mips::fixup_MICROMIPS_PC16_S1:
 243       return ELF::R_MICROMIPS_PC16_S1;
 244     case Mips::fixup_MICROMIPS_PC26_S1:
 245       return ELF::R_MICROMIPS_PC26_S1;
 246     case Mips::fixup_MICROMIPS_PC19_S2:
 247       return ELF::R_MICROMIPS_PC19_S2;
 248     case Mips::fixup_MICROMIPS_PC18_S3:
 249       return ELF::R_MICROMIPS_PC18_S3;
 250     case Mips::fixup_MICROMIPS_PC21_S1:
 251       return ELF::R_MICROMIPS_PC21_S1;
 252     case Mips::fixup_MIPS_PC19_S2:
 253       return ELF::R_MIPS_PC19_S2;
 254     case Mips::fixup_MIPS_PC18_S3:
 255       return ELF::R_MIPS_PC18_S3;
 256     case Mips::fixup_MIPS_PC21_S2:
 257       return ELF::R_MIPS_PC21_S2;
 258     case Mips::fixup_MIPS_PC26_S2:
 259       return ELF::R_MIPS_PC26_S2;
 260     case Mips::fixup_MIPS_PCHI16:
 261       return ELF::R_MIPS_PCHI16;
 262     case Mips::fixup_MIPS_PCLO16:
 263       return ELF::R_MIPS_PCLO16;
 264     }
 265
 266     llvm_unreachable("invalid PC-relative fixup kind!");
 267   }
 268
 269   switch (Kind) {
 270   case Mips::fixup_Mips_64:
 271   case FK_Data_8:
 272     return ELF::R_MIPS_64;
 273   case FK_DTPRel_4:
 274     return ELF::R_MIPS_TLS_DTPREL32;
 275   case FK_DTPRel_8:
 276     return ELF::R_MIPS_TLS_DTPREL64;
 277   case FK_TPRel_4:
 278     return ELF::R_MIPS_TLS_TPREL32;
 279   case FK_TPRel_8:
 280     return ELF::R_MIPS_TLS_TPREL64;
 281   case FK_GPRel_4:
 282     if (isN64()) {
 283       unsigned Type = (unsigned)ELF::R_MIPS_NONE;
 284       Type = setRType((unsigned)ELF::R_MIPS_GPREL32, Type);
 285       Type = setRType2((unsigned)ELF::R_MIPS_64, Type);
 286       Type = setRType3((unsigned)ELF::R_MIPS_NONE, Type);
 287       return Type;
 288     }
 289     return ELF::R_MIPS_GPREL32;
 290   case Mips::fixup_Mips_GPREL16:
 291     return ELF::R_MIPS_GPREL16;
 292   case Mips::fixup_Mips_26:
 293     return ELF::R_MIPS_26;
 294   case Mips::fixup_Mips_CALL16:
 295     return ELF::R_MIPS_CALL16;
 296   case Mips::fixup_Mips_GOT:
 297     return ELF::R_MIPS_GOT16;
 298   case Mips::fixup_Mips_HI16:
 299     return ELF::R_MIPS_HI16;
 300   case Mips::fixup_Mips_LO16:
 301     return ELF::R_MIPS_LO16;
 302   case Mips::fixup_Mips_TLSGD:
 303     return ELF::R_MIPS_TLS_GD;
 304   case Mips::fixup_Mips_GOTTPREL:
 305     return ELF::R_MIPS_TLS_GOTTPREL;
 306   case Mips::fixup_Mips_TPREL_HI:
 307     return ELF::R_MIPS_TLS_TPREL_HI16;
 308   case Mips::fixup_Mips_TPREL_LO:
 309     return ELF::R_MIPS_TLS_TPREL_LO16;
 310   case Mips::fixup_Mips_TLSLDM:
 311     return ELF::R_MIPS_TLS_LDM;
 312   case Mips::fixup_Mips_DTPREL_HI:
 313     return ELF::R_MIPS_TLS_DTPREL_HI16;
 314   case Mips::fixup_Mips_DTPREL_LO:
 315     return ELF::R_MIPS_TLS_DTPREL_LO16;
 316   case Mips::fixup_Mips_GOT_PAGE:
 317     return ELF::R_MIPS_GOT_PAGE;
 318   case Mips::fixup_Mips_GOT_OFST:
 319     return ELF::R_MIPS_GOT_OFST;
 320   case Mips::fixup_Mips_GOT_DISP:
 321     return ELF::R_MIPS_GOT_DISP;
 322   case Mips::fixup_Mips_GPOFF_HI: {
 323     unsigned Type = (unsigned)ELF::R_MIPS_NONE;
 324     Type = setRType((unsigned)ELF::R_MIPS_GPREL16, Type);
 325     Type = setRType2((unsigned)ELF::R_MIPS_SUB, Type);
 326     Type = setRType3((unsigned)ELF::R_MIPS_HI16, Type);
 327     return Type;
 328   }
 329   case Mips::fixup_Mips_GPOFF_LO: {
 330     unsigned Type = (unsigned)ELF::R_MIPS_NONE;
 331     Type = setRType((unsigned)ELF::R_MIPS_GPREL16, Type);
 332     Type = setRType2((unsigned)ELF::R_MIPS_SUB, Type);
 333     Type = setRType3((unsigned)ELF::R_MIPS_LO16, Type);
 334     return Type;
 335   }
 336   case Mips::fixup_Mips_HIGHER:
 337     return ELF::R_MIPS_HIGHER;
 338   case Mips::fixup_Mips_HIGHEST:
 339     return ELF::R_MIPS_HIGHEST;
 340   case Mips::fixup_Mips_SUB:
 341     return ELF::R_MIPS_SUB;
 342   case Mips::fixup_Mips_GOT_HI16:
 343     return ELF::R_MIPS_GOT_HI16;
 344   case Mips::fixup_Mips_GOT_LO16:
 345     return ELF::R_MIPS_GOT_LO16;
 346   case Mips::fixup_Mips_CALL_HI16:
 347     return ELF::R_MIPS_CALL_HI16;
 348   case Mips::fixup_Mips_CALL_LO16:
 349     return ELF::R_MIPS_CALL_LO16;
 350   case Mips::fixup_MICROMIPS_26_S1:
 351     return ELF::R_MICROMIPS_26_S1;
 352   case Mips::fixup_MICROMIPS_HI16:
 353     return ELF::R_MICROMIPS_HI16;
 354   case Mips::fixup_MICROMIPS_LO16:
 355     return ELF::R_MICROMIPS_LO16;
 356   case Mips::fixup_MICROMIPS_GOT16:
 357     return ELF::R_MICROMIPS_GOT16;
 358   case Mips::fixup_MICROMIPS_CALL16:
 359     return ELF::R_MICROMIPS_CALL16;
 360   case Mips::fixup_MICROMIPS_GOT_DISP:
 361     return ELF::R_MICROMIPS_GOT_DISP;
 362   case Mips::fixup_MICROMIPS_GOT_PAGE:
 363     return ELF::R_MICROMIPS_GOT_PAGE;
 364   case Mips::fixup_MICROMIPS_GOT_OFST:
 365     return ELF::R_MICROMIPS_GOT_OFST;
 366   case Mips::fixup_MICROMIPS_TLS_GD:
 367     return ELF::R_MICROMIPS_TLS_GD;
 368   case Mips::fixup_MICROMIPS_TLS_LDM:
 369     return ELF::R_MICROMIPS_TLS_LDM;
 370   case Mips::fixup_MICROMIPS_TLS_DTPREL_HI16:
 371     return ELF::R_MICROMIPS_TLS_DTPREL_HI16;
 372   case Mips::fixup_MICROMIPS_TLS_DTPREL_LO16:
 373     return ELF::R_MICROMIPS_TLS_DTPREL_LO16;
 374   case Mips::fixup_MICROMIPS_TLS_TPREL_HI16:
 375     return ELF::R_MICROMIPS_TLS_TPREL_HI16;
 376   case Mips::fixup_MICROMIPS_TLS_TPREL_LO16:
 377     return ELF::R_MICROMIPS_TLS_TPREL_LO16;
 378   case Mips::fixup_MICROMIPS_SUB:
 379     return ELF::R_MICROMIPS_SUB;
 380   }
 381
 382   llvm_unreachable("invalid fixup kind!");
 383 }
 384
 385 /// Sort relocation table entries by offset except where another order is
 386 /// required by the MIPS ABI.
 387 ///
 388 /// MIPS has a few relocations that have an AHL component in the expression used
 389 /// to evaluate them. This AHL component is an addend with the same number of
 390 /// bits as a symbol value but not all of our ABI's are able to supply a
 391 /// sufficiently sized addend in a single relocation.
 392 ///
 393 /// The O32 ABI for example, uses REL relocations which store the addend in the
 394 /// section data. All the relocations with AHL components affect 16-bit fields
 395 /// so the addend for a single relocation is limited to 16-bit. This ABI
 396 /// resolves the limitation by linking relocations (e.g. R_MIPS_HI16 and
 397 /// R_MIPS_LO16) and distributing the addend between the linked relocations. The
 398 /// ABI mandates that such relocations must be next to each other in a
 399 /// particular order (e.g. R_MIPS_HI16 must be immediately followed by a
 400 /// matching R_MIPS_LO16) but the rule is less strict in practice.
 401 ///
 402 /// The de facto standard is lenient in the following ways:
 403 /// - 'Immediately following' does not refer to the next relocation entry but
 404 ///   the next matching relocation.
 405 /// - There may be multiple high parts relocations for one low part relocation.
 406 /// - There may be multiple low part relocations for one high part relocation.
 407 /// - The AHL addend in each part does not have to be exactly equal as long as
 408 ///   the difference does not affect the carry bit from bit 15 into 16. This is
 409 ///   to allow, for example, the use of %lo(foo) and %lo(foo+4) when loading
 410 ///   both halves of a long long.
 411 ///
 412 /// See getMatchingLoType() for a description of which high part relocations
 413 /// match which low part relocations. One particular thing to note is that
 414 /// R_MIPS_GOT16 and similar only have AHL addends if they refer to local
 415 /// symbols.
 416 ///
 417 /// It should also be noted that this function is not affected by whether
 418 /// the symbol was kept or rewritten into a section-relative equivalent. We
 419 /// always match using the expressions from the source.
 420 void MipsELFObjectWriter::sortRelocs(const MCAssembler &Asm,
 421                                      std::vector<ELFRelocationEntry> &Relocs) {
 422
 423   // We do not need to sort the relocation table for RELA relocations which
 424   // N32/N64 uses as the relocation addend contains the value we require,
 425   // rather than it being split across a pair of relocations.
 426   if (hasRelocationAddend())
 427     return;
 428
 429   if (Relocs.size() < 2)
 430     return;
 431
 432   // Sort relocations by the address they are applied to.
 433   std::sort(Relocs.begin(), Relocs.end(),
 434             [](const ELFRelocationEntry &A, const ELFRelocationEntry &B) {
 435               return A.Offset < B.Offset;
 436             });
 437
 438   std::list<MipsRelocationEntry> Sorted;
 439   std::list<ELFRelocationEntry> Remainder;
 440
 441   DEBUG(dumpRelocs("R: ", Relocs));
 442
 443   // Separate the movable relocations (AHL relocations using the high bits) from
 444   // the immobile relocations (everything else). This does not preserve high/low
 445   // matches that already existed in the input.
 446   copy_if_else(Relocs.begin(), Relocs.end(), std::back_inserter(Remainder),
 447                std::back_inserter(Sorted), [](const ELFRelocationEntry &Reloc) {
 448                  return getMatchingLoType(Reloc) != ELF::R_MIPS_NONE;
 449                });
 450
 451   for (auto &R : Remainder) {
 452     DEBUG(dbgs() << "Matching: " << R << "\n");
 453
 454     unsigned MatchingType = getMatchingLoType(R);
 455     assert(MatchingType != ELF::R_MIPS_NONE &&
 456            "Wrong list for reloc that doesn't need a match");
 457
 458     // Find the best matching relocation for the current high part.
 459     // See isMatchingReloc for a description of a matching relocation and
 460     // compareMatchingRelocs for a description of what 'best' means.
 461     auto InsertionPoint =
 462         find_best(Sorted.begin(), Sorted.end(),
 463                   [&R, &MatchingType](const MipsRelocationEntry &X) {
 464                     return isMatchingReloc(X, R, MatchingType);
 465                   },
 466                   compareMatchingRelocs);
 467
 468     // If we matched then insert the high part in front of the match and mark
 469     // both relocations as being involved in a match. We only mark the high
 470     // part for cosmetic reasons in the debug output.
 471     //
 472     // If we failed to find a match then the high part is orphaned. This is not
 473     // permitted since the relocation cannot be evaluated without knowing the
 474     // carry-in. We can sometimes handle this using a matching low part that is
 475     // already used in a match but we already cover that case in
 476     // isMatchingReloc and compareMatchingRelocs. For the remaining cases we
 477     // should insert the high part at the end of the list. This will cause the
 478     // linker to fail but the alternative is to cause the linker to bind the
 479     // high part to a semi-matching low part and silently calculate the wrong
 480     // value. Unfortunately we have no means to warn the user that we did this
 481     // so leave it up to the linker to complain about it.
 482     if (InsertionPoint != Sorted.end())
 483       InsertionPoint->Matched = true;
 484     Sorted.insert(InsertionPoint, R)->Matched = true;
 485   }
 486
 487   DEBUG(dumpRelocs("S: ", Sorted));
 488
 489   assert(Relocs.size() == Sorted.size() && "Some relocs were not consumed");
 490
 491   // Overwrite the original vector with the sorted elements. The caller expects
 492   // them in reverse order.
 493   unsigned CopyTo = 0;
 494   for (const auto &R : reverse(Sorted))
 495     Relocs[CopyTo++] = R.R;
 496 }
 497
 498 bool MipsELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
 499                                                   unsigned Type) const {
 500   // If it's a compound relocation for N64 then we need the relocation if any
 501   // sub-relocation needs it.
 502   if (!isUInt<8>(Type))
 503     return needsRelocateWithSymbol(Sym, Type & 0xff) ||
 504            needsRelocateWithSymbol(Sym, (Type >> 8) & 0xff) ||
 505            needsRelocateWithSymbol(Sym, (Type >> 16) & 0xff);
 506
 507   switch (Type) {
 508   default:
 509     errs() << Type << "\n";
 510     llvm_unreachable("Unexpected relocation");
 511     return true;
 512
 513   // This relocation doesn't affect the section data.
 514   case ELF::R_MIPS_NONE:
 515     return false;
 516
 517   // On REL ABI's (e.g. O32), these relocations form pairs. The pairing is done
 518   // by the static linker by matching the symbol and offset.
 519   // We only see one relocation at a time but it's still safe to relocate with
 520   // the section so long as both relocations make the same decision.
 521   //
 522   // Some older linkers may require the symbol for particular cases. Such cases
 523   // are not supported yet but can be added as required.
 524   case ELF::R_MIPS_GOT16:
 525   case ELF::R_MIPS16_GOT16:
 526   case ELF::R_MICROMIPS_GOT16:
 527   case ELF::R_MIPS_HI16:
 528   case ELF::R_MIPS16_HI16:
 529   case ELF::R_MICROMIPS_HI16:
 530   case ELF::R_MIPS_LO16:
 531   case ELF::R_MIPS16_LO16:
 532   case ELF::R_MICROMIPS_LO16:
 533     // FIXME: It should be safe to return false for the STO_MIPS_MICROMIPS but
 534     //        we neglect to handle the adjustment to the LSB of the addend that
 535     //        it causes in applyFixup() and similar.
 536     if (cast<MCSymbolELF>(Sym).getOther() & ELF::STO_MIPS_MICROMIPS)
 537       return true;
 538     return false;
 539
 540   case ELF::R_MIPS_GOT_PAGE:
 541   case ELF::R_MICROMIPS_GOT_PAGE:
 542   case ELF::R_MIPS_GOT_OFST:
 543   case ELF::R_MICROMIPS_GOT_OFST:
 544   case ELF::R_MIPS_16:
 545   case ELF::R_MIPS_32:
 546   case ELF::R_MIPS_GPREL32:
 547     if (cast<MCSymbolELF>(Sym).getOther() & ELF::STO_MIPS_MICROMIPS)
 548       return true;
 549     LLVM_FALLTHROUGH;
 550   case ELF::R_MIPS_26:
 551   case ELF::R_MIPS_64:
 552   case ELF::R_MIPS_GPREL16:
 553   case ELF::R_MIPS_PC16:
 554   case ELF::R_MIPS_SUB:
 555     return false;
 556
 557   // FIXME: Many of these relocations should probably return false but this
 558   //        hasn't been confirmed to be safe yet.
 559   case ELF::R_MIPS_REL32:
 560   case ELF::R_MIPS_LITERAL:
 561   case ELF::R_MIPS_CALL16:
 562   case ELF::R_MIPS_SHIFT5:
 563   case ELF::R_MIPS_SHIFT6:
 564   case ELF::R_MIPS_GOT_DISP:
 565   case ELF::R_MIPS_GOT_HI16:
 566   case ELF::R_MIPS_GOT_LO16:
 567   case ELF::R_MIPS_INSERT_A:
 568   case ELF::R_MIPS_INSERT_B:
 569   case ELF::R_MIPS_DELETE:
 570   case ELF::R_MIPS_HIGHER:
 571   case ELF::R_MIPS_HIGHEST:
 572   case ELF::R_MIPS_CALL_HI16:
 573   case ELF::R_MIPS_CALL_LO16:
 574   case ELF::R_MIPS_SCN_DISP:
 575   case ELF::R_MIPS_REL16:
 576   case ELF::R_MIPS_ADD_IMMEDIATE:
 577   case ELF::R_MIPS_PJUMP:
 578   case ELF::R_MIPS_RELGOT:
 579   case ELF::R_MIPS_JALR:
 580   case ELF::R_MIPS_TLS_DTPMOD32:
 581   case ELF::R_MIPS_TLS_DTPREL32:
 582   case ELF::R_MIPS_TLS_DTPMOD64:
 583   case ELF::R_MIPS_TLS_DTPREL64:
 584   case ELF::R_MIPS_TLS_GD:
 585   case ELF::R_MIPS_TLS_LDM:
 586   case ELF::R_MIPS_TLS_DTPREL_HI16:
 587   case ELF::R_MIPS_TLS_DTPREL_LO16:
 588   case ELF::R_MIPS_TLS_GOTTPREL:
 589   case ELF::R_MIPS_TLS_TPREL32:
 590   case ELF::R_MIPS_TLS_TPREL64:
 591   case ELF::R_MIPS_TLS_TPREL_HI16:
 592   case ELF::R_MIPS_TLS_TPREL_LO16:
 593   case ELF::R_MIPS_GLOB_DAT:
 594   case ELF::R_MIPS_PC21_S2:
 595   case ELF::R_MIPS_PC26_S2:
 596   case ELF::R_MIPS_PC18_S3:
 597   case ELF::R_MIPS_PC19_S2:
 598   case ELF::R_MIPS_PCHI16:
 599   case ELF::R_MIPS_PCLO16:
 600   case ELF::R_MIPS_COPY:
 601   case ELF::R_MIPS_JUMP_SLOT:
 602   case ELF::R_MIPS_NUM:
 603   case ELF::R_MIPS_PC32:
 604   case ELF::R_MIPS_EH:
 605   case ELF::R_MICROMIPS_26_S1:
 606   case ELF::R_MICROMIPS_GPREL16:
 607   case ELF::R_MICROMIPS_LITERAL:
 608   case ELF::R_MICROMIPS_PC7_S1:
 609   case ELF::R_MICROMIPS_PC10_S1:
 610   case ELF::R_MICROMIPS_PC16_S1:
 611   case ELF::R_MICROMIPS_CALL16:
 612   case ELF::R_MICROMIPS_GOT_DISP:
 613   case ELF::R_MICROMIPS_GOT_HI16:
 614   case ELF::R_MICROMIPS_GOT_LO16:
 615   case ELF::R_MICROMIPS_SUB:
 616   case ELF::R_MICROMIPS_HIGHER:
 617   case ELF::R_MICROMIPS_HIGHEST:
 618   case ELF::R_MICROMIPS_CALL_HI16:
 619   case ELF::R_MICROMIPS_CALL_LO16:
 620   case ELF::R_MICROMIPS_SCN_DISP:
 621   case ELF::R_MICROMIPS_JALR:
 622   case ELF::R_MICROMIPS_HI0_LO16:
 623   case ELF::R_MICROMIPS_TLS_GD:
 624   case ELF::R_MICROMIPS_TLS_LDM:
 625   case ELF::R_MICROMIPS_TLS_DTPREL_HI16:
 626   case ELF::R_MICROMIPS_TLS_DTPREL_LO16:
 627   case ELF::R_MICROMIPS_TLS_GOTTPREL:
 628   case ELF::R_MICROMIPS_TLS_TPREL_HI16:
 629   case ELF::R_MICROMIPS_TLS_TPREL_LO16:
 630   case ELF::R_MICROMIPS_GPREL7_S2:
 631   case ELF::R_MICROMIPS_PC23_S2:
 632   case ELF::R_MICROMIPS_PC21_S1:
 633   case ELF::R_MICROMIPS_PC26_S1:
 634   case ELF::R_MICROMIPS_PC18_S3:
 635   case ELF::R_MICROMIPS_PC19_S2:
 636     return true;
 637
 638   // FIXME: Many of these should probably return false but MIPS16 isn't
 639   //        supported by the integrated assembler.
 640   case ELF::R_MIPS16_26:
 641   case ELF::R_MIPS16_GPREL:
 642   case ELF::R_MIPS16_CALL16:
 643   case ELF::R_MIPS16_TLS_GD:
 644   case ELF::R_MIPS16_TLS_LDM:
 645   case ELF::R_MIPS16_TLS_DTPREL_HI16:
 646   case ELF::R_MIPS16_TLS_DTPREL_LO16:
 647   case ELF::R_MIPS16_TLS_GOTTPREL:
 648   case ELF::R_MIPS16_TLS_TPREL_HI16:
 649   case ELF::R_MIPS16_TLS_TPREL_LO16:
 650     llvm_unreachable("Unsupported MIPS16 relocation");
 651     return true;
 652   }
 653 }
 654
 655 MCObjectWriter *llvm::createMipsELFObjectWriter(raw_pwrite_stream &OS,
 656                                                 uint8_t OSABI,
 657                                                 bool IsLittleEndian,
 658                                                 bool Is64Bit) {
 659   MCELFObjectTargetWriter *MOTW =
 660       new MipsELFObjectWriter(Is64Bit, OSABI, Is64Bit, IsLittleEndian);
 661   return createELFObjectWriter(MOTW, OS, IsLittleEndian);
 662 }