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