LLVM  4.0.0
MipsELFObjectWriter.cpp
Go to the documentation of this file.
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>
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/MC/MCAssembler.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"
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.
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 
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) {
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) {
237  return ELF::R_MIPS_PC16;
239  return ELF::R_MICROMIPS_PC7_S1;
241  return ELF::R_MICROMIPS_PC10_S1;
243  return ELF::R_MICROMIPS_PC16_S1;
245  return ELF::R_MICROMIPS_PC26_S1;
247  return ELF::R_MICROMIPS_PC19_S2;
249  return ELF::R_MICROMIPS_PC18_S3;
251  return ELF::R_MICROMIPS_PC21_S1;
253  return ELF::R_MIPS_PC19_S2;
255  return ELF::R_MIPS_PC18_S3;
257  return ELF::R_MIPS_PC21_S2;
259  return ELF::R_MIPS_PC26_S2;
261  return ELF::R_MIPS_PCHI16;
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;
291  return ELF::R_MIPS_GPREL16;
292  case Mips::fixup_Mips_26:
293  return ELF::R_MIPS_26;
295  return ELF::R_MIPS_CALL16;
297  return ELF::R_MIPS_GOT16;
299  return ELF::R_MIPS_HI16;
301  return ELF::R_MIPS_LO16;
303  return ELF::R_MIPS_TLS_GD;
305  return ELF::R_MIPS_TLS_GOTTPREL;
307  return ELF::R_MIPS_TLS_TPREL_HI16;
309  return ELF::R_MIPS_TLS_TPREL_LO16;
311  return ELF::R_MIPS_TLS_LDM;
313  return ELF::R_MIPS_TLS_DTPREL_HI16;
315  return ELF::R_MIPS_TLS_DTPREL_LO16;
317  return ELF::R_MIPS_GOT_PAGE;
319  return ELF::R_MIPS_GOT_OFST;
321  return ELF::R_MIPS_GOT_DISP;
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  }
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  }
337  return ELF::R_MIPS_HIGHER;
339  return ELF::R_MIPS_HIGHEST;
341  return ELF::R_MIPS_SUB;
343  return ELF::R_MIPS_GOT_HI16;
345  return ELF::R_MIPS_GOT_LO16;
347  return ELF::R_MIPS_CALL_HI16;
349  return ELF::R_MIPS_CALL_LO16;
351  return ELF::R_MICROMIPS_26_S1;
353  return ELF::R_MICROMIPS_HI16;
355  return ELF::R_MICROMIPS_LO16;
357  return ELF::R_MICROMIPS_GOT16;
359  return ELF::R_MICROMIPS_CALL16;
361  return ELF::R_MICROMIPS_GOT_DISP;
363  return ELF::R_MICROMIPS_GOT_PAGE;
365  return ELF::R_MICROMIPS_GOT_OFST;
367  return ELF::R_MICROMIPS_TLS_GD;
369  return ELF::R_MICROMIPS_TLS_LDM;
371  return ELF::R_MICROMIPS_TLS_DTPREL_HI16;
373  return ELF::R_MICROMIPS_TLS_DTPREL_LO16;
375  return ELF::R_MICROMIPS_TLS_TPREL_HI16;
377  return ELF::R_MICROMIPS_TLS_TPREL_LO16;
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;
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 
656  uint8_t OSABI,
657  bool IsLittleEndian,
658  bool Is64Bit) {
660  new MipsELFObjectWriter(Is64Bit, OSABI, Is64Bit, IsLittleEndian);
661  return createELFObjectWriter(MOTW, OS, IsLittleEndian);
662 }
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
A eight-byte dtp relative fixup.
Definition: MCFixup.h:37
This represents an "assembler immediate".
Definition: MCValue.h:40
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
void print(raw_ostream &Out) const
Defines the object file and target independent interfaces used by the assembler backend to write nati...
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:66
A four-byte tp relative fixup.
Definition: MCFixup.h:38
static unsigned getRelocType(const MCValue &Target, const MCFixupKind FixupKind, const bool IsPCRel)
Translates generic PPC fixup kind to Mach-O/PPC relocation type enum.
A four-byte fixup.
Definition: MCFixup.h:26
Context object for machine code objects.
Definition: MCContext.h:51
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:241
A four-byte gp relative fixup.
Definition: MCFixup.h:34
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
A four-byte dtp relative fixup.
Definition: MCFixup.h:36
constexpr bool isUInt< 8 >(uint64_t x)
Definition: MathExtras.h:309
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
unsigned getBinding() const
Definition: MCSymbolELF.cpp:66
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
A eight-byte tp relative fixup.
Definition: MCFixup.h:39
MCFixupKind getKind() const
Definition: MCFixup.h:93
MCObjectWriter * createMipsELFObjectWriter(raw_pwrite_stream &OS, uint8_t OSABI, bool IsLittleEndian, bool Is64Bit)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
PowerPC TLS Dynamic Call Fixup
FindBestPredicateResult
The possible results of the Predicate function used by find_best.
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:27
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Target - Wrapper for Target specific information.
MCObjectWriter * createELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new ELF writer instance.
#define I(x, y, z)
Definition: MD5.cpp:54
A eight-byte fixup.
Definition: MCFixup.h:27
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:1726
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:333
const MCSymbolELF * OriginalSymbol
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:239
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
#define DEBUG(X)
Definition: Debug.h:100
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
A two-byte fixup.
Definition: MCFixup.h:25