lib/MC/MCAssembler.cpp

   1 //===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===//
   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 #define DEBUG_TYPE "assembler"
  11 #include "llvm/MC/MCAssembler.h"
  12 #include "llvm/MC/MCAsmLayout.h"
  13 #include "llvm/MC/MCCodeEmitter.h"
  14 #include "llvm/MC/MCExpr.h"
  15 #include "llvm/MC/MCObjectWriter.h"
  16 #include "llvm/MC/MCSymbol.h"
  17 #include "llvm/MC/MCValue.h"
  18 #include "llvm/ADT/OwningPtr.h"
  19 #include "llvm/ADT/Statistic.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Target/TargetRegistry.h"
  26 #include "llvm/Target/TargetAsmBackend.h"
  27
  28 // FIXME: Gross.
  29 #include "../Target/X86/X86FixupKinds.h"
  30
  31 #include <vector>
  32 using namespace llvm;
  33
  34 STATISTIC(EmittedFragments, "Number of emitted assembler fragments");
  35
  36 // FIXME FIXME FIXME: There are number of places in this file where we convert
  37 // what is a 64-bit assembler value used for computation into a value in the
  38 // object file, which may truncate it. We should detect that truncation where
  39 // invalid and report errors back.
  40
  41 /* *** */
  42
  43 MCFragment::MCFragment() : Kind(FragmentType(~0)) {
  44 }
  45
  46 MCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent)
  47   : Kind(_Kind),
  48     Parent(_Parent),
  49     FileSize(~UINT64_C(0))
  50 {
  51   if (Parent)
  52     Parent->getFragmentList().push_back(this);
  53 }
  54
  55 MCFragment::~MCFragment() {
  56 }
  57
  58 uint64_t MCFragment::getAddress() const {
  59   assert(getParent() && "Missing Section!");
  60   return getParent()->getAddress() + Offset;
  61 }
  62
  63 /* *** */
  64
  65 MCSectionData::MCSectionData() : Section(0) {}
  66
  67 MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A)
  68   : Section(&_Section),
  69     Alignment(1),
  70     Address(~UINT64_C(0)),
  71     Size(~UINT64_C(0)),
  72     FileSize(~UINT64_C(0)),
  73     HasInstructions(false)
  74 {
  75   if (A)
  76     A->getSectionList().push_back(this);
  77 }
  78
  79 /* *** */
  80
  81 MCSymbolData::MCSymbolData() : Symbol(0) {}
  82
  83 MCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment,
  84                            uint64_t _Offset, MCAssembler *A)
  85   : Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset),
  86     IsExternal(false), IsPrivateExtern(false),
  87     CommonSize(0), CommonAlign(0), Flags(0), Index(0)
  88 {
  89   if (A)
  90     A->getSymbolList().push_back(this);
  91 }
  92
  93 /* *** */
  94
  95 MCAssembler::MCAssembler(MCContext &_Context, TargetAsmBackend &_Backend,
  96                          MCCodeEmitter &_Emitter, raw_ostream &_OS)
  97   : Context(_Context), Backend(_Backend), Emitter(_Emitter),
  98     OS(_OS), SubsectionsViaSymbols(false)
  99 {
 100 }
 101
 102 MCAssembler::~MCAssembler() {
 103 }
 104
 105 static bool isScatteredFixupFullyResolvedSimple(const MCAssembler &Asm,
 106                                                 const MCAsmFixup &Fixup,
 107                                                 const MCValue Target,
 108                                                 const MCSection *BaseSection) {
 109   // The effective fixup address is
 110   //     addr(atom(A)) + offset(A)
 111   //   - addr(atom(B)) - offset(B)
 112   //   - addr(<base symbol>) + <fixup offset from base symbol>
 113   // and the offsets are not relocatable, so the fixup is fully resolved when
 114   //  addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0.
 115   //
 116   // The simple (Darwin, except on x86_64) way of dealing with this was to
 117   // assume that any reference to a temporary symbol *must* be a temporary
 118   // symbol in the same atom, unless the sections differ. Therefore, any PCrel
 119   // relocation to a temporary symbol (in the same section) is fully
 120   // resolved. This also works in conjunction with absolutized .set, which
 121   // requires the compiler to use .set to absolutize the differences between
 122   // symbols which the compiler knows to be assembly time constants, so we don't
 123   // need to worry about consider symbol differences fully resolved.
 124
 125   // Non-relative fixups are only resolved if constant.
 126   if (!BaseSection)
 127     return Target.isAbsolute();
 128
 129   // Otherwise, relative fixups are only resolved if not a difference and the
 130   // target is a temporary in the same section.
 131   if (Target.isAbsolute() || Target.getSymB())
 132     return false;
 133
 134   const MCSymbol *A = &Target.getSymA()->getSymbol();
 135   if (!A->isTemporary() || !A->isInSection() ||
 136       &A->getSection() != BaseSection)
 137     return false;
 138
 139   return true;
 140 }
 141
 142 static bool isScatteredFixupFullyResolved(const MCAssembler &Asm,
 143                                           const MCAsmFixup &Fixup,
 144                                           const MCValue Target,
 145                                           const MCSymbolData *BaseSymbol) {
 146   // The effective fixup address is
 147   //     addr(atom(A)) + offset(A)
 148   //   - addr(atom(B)) - offset(B)
 149   //   - addr(BaseSymbol) + <fixup offset from base symbol>
 150   // and the offsets are not relocatable, so the fixup is fully resolved when
 151   //  addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0.
 152   //
 153   // Note that "false" is almost always conservatively correct (it means we emit
 154   // a relocation which is unnecessary), except when it would force us to emit a
 155   // relocation which the target cannot encode.
 156
 157   const MCSymbolData *A_Base = 0, *B_Base = 0;
 158   if (const MCSymbolRefExpr *A = Target.getSymA()) {
 159     // Modified symbol references cannot be resolved.
 160     if (A->getKind() != MCSymbolRefExpr::VK_None)
 161       return false;
 162
 163     A_Base = Asm.getAtom(&Asm.getSymbolData(A->getSymbol()));
 164     if (!A_Base)
 165       return false;
 166   }
 167
 168   if (const MCSymbolRefExpr *B = Target.getSymB()) {
 169     // Modified symbol references cannot be resolved.
 170     if (B->getKind() != MCSymbolRefExpr::VK_None)
 171       return false;
 172
 173     B_Base = Asm.getAtom(&Asm.getSymbolData(B->getSymbol()));
 174     if (!B_Base)
 175       return false;
 176   }
 177
 178   // If there is no base, A and B have to be the same atom for this fixup to be
 179   // fully resolved.
 180   if (!BaseSymbol)
 181     return A_Base == B_Base;
 182
 183   // Otherwise, B must be missing and A must be the base.
 184   return !B_Base && BaseSymbol == A_Base;
 185 }
 186
 187 bool MCAssembler::isSymbolLinkerVisible(const MCSymbolData *SD) const {
 188   // Non-temporary labels should always be visible to the linker.
 189   if (!SD->getSymbol().isTemporary())
 190     return true;
 191
 192   // Absolute temporary labels are never visible.
 193   if (!SD->getFragment())
 194     return false;
 195
 196   // Otherwise, check if the section requires symbols even for temporary labels.
 197   return getBackend().doesSectionRequireSymbols(
 198     SD->getFragment()->getParent()->getSection());
 199 }
 200
 201 const MCSymbolData *MCAssembler::getAtomForAddress(const MCSectionData *Section,
 202                                                    uint64_t Address) const {
 203   const MCSymbolData *Best = 0;
 204   for (MCAssembler::const_symbol_iterator it = symbol_begin(),
 205          ie = symbol_end(); it != ie; ++it) {
 206     // Ignore non-linker visible symbols.
 207     if (!isSymbolLinkerVisible(it))
 208       continue;
 209
 210     // Ignore symbols not in the same section.
 211     if (!it->getFragment() || it->getFragment()->getParent() != Section)
 212       continue;
 213
 214     // Otherwise, find the closest symbol preceding this address (ties are
 215     // resolved in favor of the last defined symbol).
 216     if (it->getAddress() <= Address &&
 217         (!Best || it->getAddress() >= Best->getAddress()))
 218       Best = it;
 219   }
 220
 221   return Best;
 222 }
 223
 224 const MCSymbolData *MCAssembler::getAtom(const MCSymbolData *SD) const {
 225   // Linker visible symbols define atoms.
 226   if (isSymbolLinkerVisible(SD))
 227     return SD;
 228
 229   // Absolute and undefined symbols have no defining atom.
 230   if (!SD->getFragment())
 231     return 0;
 232
 233   // Otherwise, search by address.
 234   return getAtomForAddress(SD->getFragment()->getParent(), SD->getAddress());
 235 }
 236
 237 bool MCAssembler::EvaluateFixup(const MCAsmLayout &Layout, MCAsmFixup &Fixup,
 238                                 MCDataFragment *DF,
 239                                 MCValue &Target, uint64_t &Value) const {
 240   if (!Fixup.Value->EvaluateAsRelocatable(Target, &Layout))
 241     llvm_report_error("expected relocatable expression");
 242
 243   // FIXME: How do non-scattered symbols work in ELF? I presume the linker
 244   // doesn't support small relocations, but then under what criteria does the
 245   // assembler allow symbol differences?
 246
 247   Value = Target.getConstant();
 248
 249   bool IsPCRel =
 250     Emitter.getFixupKindInfo(Fixup.Kind).Flags & MCFixupKindInfo::FKF_IsPCRel;
 251   bool IsResolved = true;
 252   if (const MCSymbolRefExpr *A = Target.getSymA()) {
 253     if (A->getSymbol().isDefined())
 254       Value += getSymbolData(A->getSymbol()).getAddress();
 255     else
 256       IsResolved = false;
 257   }
 258   if (const MCSymbolRefExpr *B = Target.getSymB()) {
 259     if (B->getSymbol().isDefined())
 260       Value -= getSymbolData(B->getSymbol()).getAddress();
 261     else
 262       IsResolved = false;
 263   }
 264
 265   // If we are using scattered symbols, determine whether this value is actually
 266   // resolved; scattering may cause atoms to move.
 267   if (IsResolved && getBackend().hasScatteredSymbols()) {
 268     if (getBackend().hasReliableSymbolDifference()) {
 269       // If this is a PCrel relocation, find the base atom (identified by its
 270       // symbol) that the fixup value is relative to.
 271       const MCSymbolData *BaseSymbol = 0;
 272       if (IsPCRel) {
 273         BaseSymbol = getAtomForAddress(
 274           DF->getParent(), DF->getAddress() + Fixup.Offset);
 275         if (!BaseSymbol)
 276           IsResolved = false;
 277       }
 278
 279       if (IsResolved)
 280         IsResolved = isScatteredFixupFullyResolved(*this, Fixup, Target,
 281                                                    BaseSymbol);
 282     } else {
 283       const MCSection *BaseSection = 0;
 284       if (IsPCRel)
 285         BaseSection = &DF->getParent()->getSection();
 286
 287       IsResolved = isScatteredFixupFullyResolvedSimple(*this, Fixup, Target,
 288                                                        BaseSection);
 289     }
 290   }
 291
 292   if (IsPCRel)
 293     Value -= DF->getAddress() + Fixup.Offset;
 294
 295   return IsResolved;
 296 }
 297
 298 void MCAssembler::LayoutSection(MCSectionData &SD,
 299                                 MCAsmLayout &Layout) {
 300   uint64_t Address = SD.getAddress();
 301
 302   for (MCSectionData::iterator it = SD.begin(), ie = SD.end(); it != ie; ++it) {
 303     MCFragment &F = *it;
 304
 305     F.setOffset(Address - SD.getAddress());
 306
 307     // Evaluate fragment size.
 308     switch (F.getKind()) {
 309     case MCFragment::FT_Align: {
 310       MCAlignFragment &AF = cast<MCAlignFragment>(F);
 311
 312       uint64_t Size = OffsetToAlignment(Address, AF.getAlignment());
 313       if (Size > AF.getMaxBytesToEmit())
 314         AF.setFileSize(0);
 315       else
 316         AF.setFileSize(Size);
 317       break;
 318     }
 319
 320     case MCFragment::FT_Data:
 321       F.setFileSize(cast<MCDataFragment>(F).getContents().size());
 322       break;
 323
 324     case MCFragment::FT_Fill: {
 325       MCFillFragment &FF = cast<MCFillFragment>(F);
 326       F.setFileSize(FF.getValueSize() * FF.getCount());
 327       break;
 328     }
 329
 330     case MCFragment::FT_Org: {
 331       MCOrgFragment &OF = cast<MCOrgFragment>(F);
 332
 333       int64_t TargetLocation;
 334       if (!OF.getOffset().EvaluateAsAbsolute(TargetLocation, &Layout))
 335         llvm_report_error("expected assembly-time absolute expression");
 336
 337       // FIXME: We need a way to communicate this error.
 338       int64_t Offset = TargetLocation - F.getOffset();
 339       if (Offset < 0)
 340         llvm_report_error("invalid .org offset '" + Twine(TargetLocation) +
 341                           "' (at offset '" + Twine(F.getOffset()) + "'");
 342
 343       F.setFileSize(Offset);
 344       break;
 345     }
 346
 347     case MCFragment::FT_ZeroFill: {
 348       MCZeroFillFragment &ZFF = cast<MCZeroFillFragment>(F);
 349
 350       // Align the fragment offset; it is safe to adjust the offset freely since
 351       // this is only in virtual sections.
 352       Address = RoundUpToAlignment(Address, ZFF.getAlignment());
 353       F.setOffset(Address - SD.getAddress());
 354
 355       // FIXME: This is misnamed.
 356       F.setFileSize(ZFF.getSize());
 357       break;
 358     }
 359     }
 360
 361     Address += F.getFileSize();
 362   }
 363
 364   // Set the section sizes.
 365   SD.setSize(Address - SD.getAddress());
 366   if (getBackend().isVirtualSection(SD.getSection()))
 367     SD.setFileSize(0);
 368   else
 369     SD.setFileSize(Address - SD.getAddress());
 370 }
 371
 372 /// WriteNopData - Write optimal nops to the output file for the \arg Count
 373 /// bytes.  This returns the number of bytes written.  It may return 0 if
 374 /// the \arg Count is more than the maximum optimal nops.
 375 ///
 376 /// FIXME this is X86 32-bit specific and should move to a better place.
 377 static uint64_t WriteNopData(uint64_t Count, MCObjectWriter *OW) {
 378   static const uint8_t Nops[16][16] = {
 379     // nop
 380     {0x90},
 381     // xchg %ax,%ax
 382     {0x66, 0x90},
 383     // nopl (%[re]ax)
 384     {0x0f, 0x1f, 0x00},
 385     // nopl 0(%[re]ax)
 386     {0x0f, 0x1f, 0x40, 0x00},
 387     // nopl 0(%[re]ax,%[re]ax,1)
 388     {0x0f, 0x1f, 0x44, 0x00, 0x00},
 389     // nopw 0(%[re]ax,%[re]ax,1)
 390     {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00},
 391     // nopl 0L(%[re]ax)
 392     {0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00},
 393     // nopl 0L(%[re]ax,%[re]ax,1)
 394     {0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
 395     // nopw 0L(%[re]ax,%[re]ax,1)
 396     {0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
 397     // nopw %cs:0L(%[re]ax,%[re]ax,1)
 398     {0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
 399     // nopl 0(%[re]ax,%[re]ax,1)
 400     // nopw 0(%[re]ax,%[re]ax,1)
 401     {0x0f, 0x1f, 0x44, 0x00, 0x00,
 402      0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00},
 403     // nopw 0(%[re]ax,%[re]ax,1)
 404     // nopw 0(%[re]ax,%[re]ax,1)
 405     {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00,
 406      0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00},
 407     // nopw 0(%[re]ax,%[re]ax,1)
 408     // nopl 0L(%[re]ax) */
 409     {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00,
 410      0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00},
 411     // nopl 0L(%[re]ax)
 412     // nopl 0L(%[re]ax)
 413     {0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00,
 414      0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00},
 415     // nopl 0L(%[re]ax)
 416     // nopl 0L(%[re]ax,%[re]ax,1)
 417     {0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00,
 418      0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00}
 419   };
 420
 421   if (Count > 15)
 422     return 0;
 423
 424   for (uint64_t i = 0; i < Count; i++)
 425     OW->Write8(uint8_t(Nops[Count - 1][i]));
 426
 427   return Count;
 428 }
 429
 430 /// WriteFragmentData - Write the \arg F data to the output file.
 431 static void WriteFragmentData(const MCFragment &F, MCObjectWriter *OW) {
 432   uint64_t Start = OW->getStream().tell();
 433   (void) Start;
 434
 435   ++EmittedFragments;
 436
 437   // FIXME: Embed in fragments instead?
 438   switch (F.getKind()) {
 439   case MCFragment::FT_Align: {
 440     MCAlignFragment &AF = cast<MCAlignFragment>(F);
 441     uint64_t Count = AF.getFileSize() / AF.getValueSize();
 442
 443     // FIXME: This error shouldn't actually occur (the front end should emit
 444     // multiple .align directives to enforce the semantics it wants), but is
 445     // severe enough that we want to report it. How to handle this?
 446     if (Count * AF.getValueSize() != AF.getFileSize())
 447       llvm_report_error("undefined .align directive, value size '" +
 448                         Twine(AF.getValueSize()) +
 449                         "' is not a divisor of padding size '" +
 450                         Twine(AF.getFileSize()) + "'");
 451
 452     // See if we are aligning with nops, and if so do that first to try to fill
 453     // the Count bytes.  Then if that did not fill any bytes or there are any
 454     // bytes left to fill use the the Value and ValueSize to fill the rest.
 455     if (AF.getEmitNops()) {
 456       uint64_t NopByteCount = WriteNopData(Count, OW);
 457       Count -= NopByteCount;
 458     }
 459
 460     for (uint64_t i = 0; i != Count; ++i) {
 461       switch (AF.getValueSize()) {
 462       default:
 463         assert(0 && "Invalid size!");
 464       case 1: OW->Write8 (uint8_t (AF.getValue())); break;
 465       case 2: OW->Write16(uint16_t(AF.getValue())); break;
 466       case 4: OW->Write32(uint32_t(AF.getValue())); break;
 467       case 8: OW->Write64(uint64_t(AF.getValue())); break;
 468       }
 469     }
 470     break;
 471   }
 472
 473   case MCFragment::FT_Data: {
 474     OW->WriteBytes(cast<MCDataFragment>(F).getContents().str());
 475     break;
 476   }
 477
 478   case MCFragment::FT_Fill: {
 479     MCFillFragment &FF = cast<MCFillFragment>(F);
 480     for (uint64_t i = 0, e = FF.getCount(); i != e; ++i) {
 481       switch (FF.getValueSize()) {
 482       default:
 483         assert(0 && "Invalid size!");
 484       case 1: OW->Write8 (uint8_t (FF.getValue())); break;
 485       case 2: OW->Write16(uint16_t(FF.getValue())); break;
 486       case 4: OW->Write32(uint32_t(FF.getValue())); break;
 487       case 8: OW->Write64(uint64_t(FF.getValue())); break;
 488       }
 489     }
 490     break;
 491   }
 492
 493   case MCFragment::FT_Org: {
 494     MCOrgFragment &OF = cast<MCOrgFragment>(F);
 495
 496     for (uint64_t i = 0, e = OF.getFileSize(); i != e; ++i)
 497       OW->Write8(uint8_t(OF.getValue()));
 498
 499     break;
 500   }
 501
 502   case MCFragment::FT_ZeroFill: {
 503     assert(0 && "Invalid zero fill fragment in concrete section!");
 504     break;
 505   }
 506   }
 507
 508   assert(OW->getStream().tell() - Start == F.getFileSize());
 509 }
 510
 511 void MCAssembler::WriteSectionData(const MCSectionData *SD,
 512                                    MCObjectWriter *OW) const {
 513   // Ignore virtual sections.
 514   if (getBackend().isVirtualSection(SD->getSection())) {
 515     assert(SD->getFileSize() == 0);
 516     return;
 517   }
 518
 519   uint64_t Start = OW->getStream().tell();
 520   (void) Start;
 521
 522   for (MCSectionData::const_iterator it = SD->begin(),
 523          ie = SD->end(); it != ie; ++it)
 524     WriteFragmentData(*it, OW);
 525
 526   // Add section padding.
 527   assert(SD->getFileSize() >= SD->getSize() && "Invalid section sizes!");
 528   OW->WriteZeros(SD->getFileSize() - SD->getSize());
 529
 530   assert(OW->getStream().tell() - Start == SD->getFileSize());
 531 }
 532
 533 void MCAssembler::Finish() {
 534   DEBUG_WITH_TYPE("mc-dump", {
 535       llvm::errs() << "assembler backend - pre-layout\n--\n";
 536       dump(); });
 537
 538   // Layout until everything fits.
 539   MCAsmLayout Layout(*this);
 540   while (LayoutOnce(Layout))
 541     continue;
 542
 543   DEBUG_WITH_TYPE("mc-dump", {
 544       llvm::errs() << "assembler backend - post-layout\n--\n";
 545       dump(); });
 546
 547   llvm::OwningPtr<MCObjectWriter> Writer(getBackend().createObjectWriter(OS));
 548   if (!Writer)
 549     llvm_report_error("unable to create object writer!");
 550
 551   // Allow the object writer a chance to perform post-layout binding (for
 552   // example, to set the index fields in the symbol data).
 553   Writer->ExecutePostLayoutBinding(*this);
 554
 555   // Evaluate and apply the fixups, generating relocation entries as necessary.
 556   for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
 557     for (MCSectionData::iterator it2 = it->begin(),
 558            ie2 = it->end(); it2 != ie2; ++it2) {
 559       MCDataFragment *DF = dyn_cast<MCDataFragment>(it2);
 560       if (!DF)
 561         continue;
 562
 563       for (MCDataFragment::fixup_iterator it3 = DF->fixup_begin(),
 564              ie3 = DF->fixup_end(); it3 != ie3; ++it3) {
 565         MCAsmFixup &Fixup = *it3;
 566
 567         // Evaluate the fixup.
 568         MCValue Target;
 569         uint64_t FixedValue;
 570         if (!EvaluateFixup(Layout, Fixup, DF, Target, FixedValue)) {
 571           // The fixup was unresolved, we need a relocation. Inform the object
 572           // writer of the relocation, and give it an opportunity to adjust the
 573           // fixup value if need be.
 574           Writer->RecordRelocation(*this, DF, Fixup, Target, FixedValue);
 575         }
 576
 577         getBackend().ApplyFixup(Fixup, *DF, FixedValue);
 578       }
 579     }
 580   }
 581
 582   // Write the object file.
 583   Writer->WriteObject(*this);
 584   OS.flush();
 585 }
 586
 587 bool MCAssembler::FixupNeedsRelaxation(MCAsmFixup &Fixup, MCDataFragment *DF,
 588                                        const MCAsmLayout &Layout) const {
 589   // Currently we only need to relax X86::reloc_pcrel_1byte.
 590   if (unsigned(Fixup.Kind) != X86::reloc_pcrel_1byte)
 591     return false;
 592
 593   // If we cannot resolve the fixup value, it requires relaxation.
 594   MCValue Target;
 595   uint64_t Value;
 596   if (!EvaluateFixup(Layout, Fixup, DF, Target, Value))
 597     return true;
 598
 599   // Otherwise, relax if the value is too big for a (signed) i8.
 600   return int64_t(Value) != int64_t(int8_t(Value));
 601 }
 602
 603 bool MCAssembler::LayoutOnce(MCAsmLayout &Layout) {
 604   // Layout the concrete sections and fragments.
 605   uint64_t Address = 0;
 606   MCSectionData *Prev = 0;
 607   for (iterator it = begin(), ie = end(); it != ie; ++it) {
 608     MCSectionData &SD = *it;
 609
 610     // Skip virtual sections.
 611     if (getBackend().isVirtualSection(SD.getSection()))
 612       continue;
 613
 614     // Align this section if necessary by adding padding bytes to the previous
 615     // section.
 616     if (uint64_t Pad = OffsetToAlignment(Address, it->getAlignment())) {
 617       assert(Prev && "Missing prev section!");
 618       Prev->setFileSize(Prev->getFileSize() + Pad);
 619       Address += Pad;
 620     }
 621
 622     // Layout the section fragments and its size.
 623     SD.setAddress(Address);
 624     LayoutSection(SD, Layout);
 625     Address += SD.getFileSize();
 626
 627     Prev = &SD;
 628   }
 629
 630   // Layout the virtual sections.
 631   for (iterator it = begin(), ie = end(); it != ie; ++it) {
 632     MCSectionData &SD = *it;
 633
 634     if (!getBackend().isVirtualSection(SD.getSection()))
 635       continue;
 636
 637     // Align this section if necessary by adding padding bytes to the previous
 638     // section.
 639     if (uint64_t Pad = OffsetToAlignment(Address, it->getAlignment()))
 640       Address += Pad;
 641
 642     SD.setAddress(Address);
 643     LayoutSection(SD, Layout);
 644     Address += SD.getSize();
 645   }
 646
 647   // Scan the fixups in order and relax any that don't fit.
 648   for (iterator it = begin(), ie = end(); it != ie; ++it) {
 649     MCSectionData &SD = *it;
 650
 651     for (MCSectionData::iterator it2 = SD.begin(),
 652            ie2 = SD.end(); it2 != ie2; ++it2) {
 653       MCDataFragment *DF = dyn_cast<MCDataFragment>(it2);
 654       if (!DF)
 655         continue;
 656
 657       for (MCDataFragment::fixup_iterator it3 = DF->fixup_begin(),
 658              ie3 = DF->fixup_end(); it3 != ie3; ++it3) {
 659         MCAsmFixup &Fixup = *it3;
 660
 661         // Check whether we need to relax this fixup.
 662         if (!FixupNeedsRelaxation(Fixup, DF, Layout))
 663           continue;
 664
 665         // Relax the instruction.
 666         //
 667         // FIXME: This is a huge temporary hack which just looks for x86
 668         // branches; the only thing we need to relax on x86 is
 669         // 'X86::reloc_pcrel_1byte'. Once we have MCInst fragments, this will be
 670         // replaced by a TargetAsmBackend hook (most likely tblgen'd) to relax
 671         // an individual MCInst.
 672         SmallVectorImpl<char> &C = DF->getContents();
 673         uint64_t PrevOffset = Fixup.Offset;
 674         unsigned Amt = 0;
 675
 676           // jcc instructions
 677         if (unsigned(C[Fixup.Offset-1]) >= 0x70 &&
 678             unsigned(C[Fixup.Offset-1]) <= 0x7f) {
 679           C[Fixup.Offset] = C[Fixup.Offset-1] + 0x10;
 680           C[Fixup.Offset-1] = char(0x0f);
 681           ++Fixup.Offset;
 682           Amt = 4;
 683
 684           // jmp rel8
 685         } else if (C[Fixup.Offset-1] == char(0xeb)) {
 686           C[Fixup.Offset-1] = char(0xe9);
 687           Amt = 3;
 688
 689         } else
 690           llvm_unreachable("unknown 1 byte pcrel instruction!");
 691
 692         Fixup.Value = MCBinaryExpr::Create(
 693           MCBinaryExpr::Sub, Fixup.Value,
 694           MCConstantExpr::Create(3, getContext()),
 695           getContext());
 696         C.insert(C.begin() + Fixup.Offset, Amt, char(0));
 697         Fixup.Kind = MCFixupKind(X86::reloc_pcrel_4byte);
 698
 699         // Update the remaining fixups, which have slid.
 700         //
 701         // FIXME: This is bad for performance, but will be eliminated by the
 702         // move to MCInst specific fragments.
 703         ++it3;
 704         for (; it3 != ie3; ++it3)
 705           it3->Offset += Amt;
 706
 707         // Update all the symbols for this fragment, which may have slid.
 708         //
 709         // FIXME: This is really really bad for performance, but will be
 710         // eliminated by the move to MCInst specific fragments.
 711         for (MCAssembler::symbol_iterator it = symbol_begin(),
 712                ie = symbol_end(); it != ie; ++it) {
 713           MCSymbolData &SD = *it;
 714
 715           if (it->getFragment() != DF)
 716             continue;
 717
 718           if (SD.getOffset() > PrevOffset)
 719             SD.setOffset(SD.getOffset() + Amt);
 720         }
 721
 722         // Restart layout.
 723         //
 724         // FIXME: This is O(N^2), but will be eliminated once we have a smart
 725         // MCAsmLayout object.
 726         return true;
 727       }
 728     }
 729   }
 730
 731   return false;
 732 }
 733
 734 // Debugging methods
 735
 736 namespace llvm {
 737
 738 raw_ostream &operator<<(raw_ostream &OS, const MCAsmFixup &AF) {
 739   OS << "<MCAsmFixup" << " Offset:" << AF.Offset << " Value:" << *AF.Value
 740      << " Kind:" << AF.Kind << ">";
 741   return OS;
 742 }
 743
 744 }
 745
 746 void MCFragment::dump() {
 747   raw_ostream &OS = llvm::errs();
 748
 749   OS << "<MCFragment " << (void*) this << " Offset:" << Offset
 750      << " FileSize:" << FileSize;
 751
 752   OS << ">";
 753 }
 754
 755 void MCAlignFragment::dump() {
 756   raw_ostream &OS = llvm::errs();
 757
 758   OS << "<MCAlignFragment ";
 759   this->MCFragment::dump();
 760   OS << "\n       ";
 761   OS << " Alignment:" << getAlignment()
 762      << " Value:" << getValue() << " ValueSize:" << getValueSize()
 763      << " MaxBytesToEmit:" << getMaxBytesToEmit() << ">";
 764 }
 765
 766 void MCDataFragment::dump() {
 767   raw_ostream &OS = llvm::errs();
 768
 769   OS << "<MCDataFragment ";
 770   this->MCFragment::dump();
 771   OS << "\n       ";
 772   OS << " Contents:[";
 773   for (unsigned i = 0, e = getContents().size(); i != e; ++i) {
 774     if (i) OS << ",";
 775     OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
 776   }
 777   OS << "] (" << getContents().size() << " bytes)";
 778
 779   if (!getFixups().empty()) {
 780     OS << ",\n       ";
 781     OS << " Fixups:[";
 782     for (fixup_iterator it = fixup_begin(), ie = fixup_end(); it != ie; ++it) {
 783       if (it != fixup_begin()) OS << ",\n                ";
 784       OS << *it;
 785     }
 786     OS << "]";
 787   }
 788
 789   OS << ">";
 790 }
 791
 792 void MCFillFragment::dump() {
 793   raw_ostream &OS = llvm::errs();
 794
 795   OS << "<MCFillFragment ";
 796   this->MCFragment::dump();
 797   OS << "\n       ";
 798   OS << " Value:" << getValue() << " ValueSize:" << getValueSize()
 799      << " Count:" << getCount() << ">";
 800 }
 801
 802 void MCOrgFragment::dump() {
 803   raw_ostream &OS = llvm::errs();
 804
 805   OS << "<MCOrgFragment ";
 806   this->MCFragment::dump();
 807   OS << "\n       ";
 808   OS << " Offset:" << getOffset() << " Value:" << getValue() << ">";
 809 }
 810
 811 void MCZeroFillFragment::dump() {
 812   raw_ostream &OS = llvm::errs();
 813
 814   OS << "<MCZeroFillFragment ";
 815   this->MCFragment::dump();
 816   OS << "\n       ";
 817   OS << " Size:" << getSize() << " Alignment:" << getAlignment() << ">";
 818 }
 819
 820 void MCSectionData::dump() {
 821   raw_ostream &OS = llvm::errs();
 822
 823   OS << "<MCSectionData";
 824   OS << " Alignment:" << getAlignment() << " Address:" << Address
 825      << " Size:" << Size << " FileSize:" << FileSize
 826      << " Fragments:[\n      ";
 827   for (iterator it = begin(), ie = end(); it != ie; ++it) {
 828     if (it != begin()) OS << ",\n      ";
 829     it->dump();
 830   }
 831   OS << "]>";
 832 }
 833
 834 void MCSymbolData::dump() {
 835   raw_ostream &OS = llvm::errs();
 836
 837   OS << "<MCSymbolData Symbol:" << getSymbol()
 838      << " Fragment:" << getFragment() << " Offset:" << getOffset()
 839      << " Flags:" << getFlags() << " Index:" << getIndex();
 840   if (isCommon())
 841     OS << " (common, size:" << getCommonSize()
 842        << " align: " << getCommonAlignment() << ")";
 843   if (isExternal())
 844     OS << " (external)";
 845   if (isPrivateExtern())
 846     OS << " (private extern)";
 847   OS << ">";
 848 }
 849
 850 void MCAssembler::dump() {
 851   raw_ostream &OS = llvm::errs();
 852
 853   OS << "<MCAssembler\n";
 854   OS << "  Sections:[\n    ";
 855   for (iterator it = begin(), ie = end(); it != ie; ++it) {
 856     if (it != begin()) OS << ",\n    ";
 857     it->dump();
 858   }
 859   OS << "],\n";
 860   OS << "  Symbols:[";
 861
 862   for (symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) {
 863     if (it != symbol_begin()) OS << ",\n           ";
 864     it->dump();
 865   }
 866   OS << "]>\n";
 867 }