1 //===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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/Debug.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include "llvm/Target/TargetRegistry.h"
26 #include "llvm/Target/TargetAsmBackend.h"
33 STATISTIC(EmittedFragments
, "Number of emitted assembler fragments");
34 STATISTIC(EvaluateFixup
, "Number of evaluated fixups");
35 STATISTIC(FragmentLayouts
, "Number of fragment layouts");
36 STATISTIC(ObjectBytes
, "Number of emitted object file bytes");
37 STATISTIC(RelaxationSteps
, "Number of assembler layout and relaxation steps");
38 STATISTIC(RelaxedInstructions
, "Number of relaxed instructions");
39 STATISTIC(SectionLayouts
, "Number of section layouts");
43 // FIXME FIXME FIXME: There are number of places in this file where we convert
44 // what is a 64-bit assembler value used for computation into a value in the
45 // object file, which may truncate it. We should detect that truncation where
46 // invalid and report errors back.
50 MCAsmLayout::MCAsmLayout(MCAssembler
&Asm
) : Assembler(Asm
) {
51 // Compute the section layout order. Virtual sections must go last.
52 for (MCAssembler::iterator it
= Asm
.begin(), ie
= Asm
.end(); it
!= ie
; ++it
)
53 if (!Asm
.getBackend().isVirtualSection(it
->getSection()))
54 SectionOrder
.push_back(&*it
);
55 for (MCAssembler::iterator it
= Asm
.begin(), ie
= Asm
.end(); it
!= ie
; ++it
)
56 if (Asm
.getBackend().isVirtualSection(it
->getSection()))
57 SectionOrder
.push_back(&*it
);
60 void MCAsmLayout::UpdateForSlide(MCFragment
*F
, int SlideAmount
) {
61 // We shouldn't have to do anything special to support negative slides, and it
62 // is a perfectly valid thing to do as long as other parts of the system can
63 // guarantee convergence.
64 assert(SlideAmount
>= 0 && "Negative slides not yet supported");
66 // Update the layout by simply recomputing the layout for the entire
67 // file. This is trivially correct, but very slow.
69 // FIXME-PERF: This is O(N^2), but will be eliminated once we get smarter.
71 // Layout the sections in order.
72 for (unsigned i
= 0, e
= getSectionOrder().size(); i
!= e
; ++i
)
73 getAssembler().LayoutSection(*this, i
);
76 uint64_t MCAsmLayout::getFragmentAddress(const MCFragment
*F
) const {
77 assert(F
->getParent() && "Missing section()!");
78 return getSectionAddress(F
->getParent()) + getFragmentOffset(F
);
81 uint64_t MCAsmLayout::getFragmentEffectiveSize(const MCFragment
*F
) const {
82 assert(F
->EffectiveSize
!= ~UINT64_C(0) && "Address not set!");
83 return F
->EffectiveSize
;
86 void MCAsmLayout::setFragmentEffectiveSize(MCFragment
*F
, uint64_t Value
) {
87 F
->EffectiveSize
= Value
;
90 uint64_t MCAsmLayout::getFragmentOffset(const MCFragment
*F
) const {
91 assert(F
->Offset
!= ~UINT64_C(0) && "Address not set!");
95 void MCAsmLayout::setFragmentOffset(MCFragment
*F
, uint64_t Value
) {
99 uint64_t MCAsmLayout::getSymbolAddress(const MCSymbolData
*SD
) const {
100 assert(SD
->getFragment() && "Invalid getAddress() on undefined symbol!");
101 return getFragmentAddress(SD
->getFragment()) + SD
->getOffset();
104 uint64_t MCAsmLayout::getSectionAddress(const MCSectionData
*SD
) const {
105 assert(SD
->Address
!= ~UINT64_C(0) && "Address not set!");
109 void MCAsmLayout::setSectionAddress(MCSectionData
*SD
, uint64_t Value
) {
113 uint64_t MCAsmLayout::getSectionAddressSize(const MCSectionData
*SD
) const {
114 // Empty sections have no size.
115 if (SD
->getFragmentList().empty())
118 // Otherwise, the size is the last fragment's end offset.
119 const MCFragment
&F
= SD
->getFragmentList().back();
120 return getFragmentOffset(&F
) + getFragmentEffectiveSize(&F
);
123 uint64_t MCAsmLayout::getSectionFileSize(const MCSectionData
*SD
) const {
124 // Virtual sections have no file size.
125 if (getAssembler().getBackend().isVirtualSection(SD
->getSection()))
128 // Otherwise, the file size is the same as the address space size.
129 return getSectionAddressSize(SD
);
132 uint64_t MCAsmLayout::getSectionSize(const MCSectionData
*SD
) const {
133 // Empty sections have no size.
134 if (SD
->getFragmentList().empty())
137 // The logical size is the address space size minus any tail padding.
138 uint64_t Size
= getSectionAddressSize(SD
);
139 const MCAlignFragment
*AF
=
140 dyn_cast
<MCAlignFragment
>(&(SD
->getFragmentList().back()));
141 if (AF
&& AF
->hasOnlyAlignAddress())
142 Size
-= getFragmentEffectiveSize(AF
);
149 MCFragment::MCFragment() : Kind(FragmentType(~0)) {
152 MCFragment::MCFragment(FragmentType _Kind
, MCSectionData
*_Parent
)
153 : Kind(_Kind
), Parent(_Parent
), Atom(0), EffectiveSize(~UINT64_C(0))
156 Parent
->getFragmentList().push_back(this);
159 MCFragment::~MCFragment() {
164 MCSectionData::MCSectionData() : Section(0) {}
166 MCSectionData::MCSectionData(const MCSection
&_Section
, MCAssembler
*A
)
167 : Section(&_Section
),
169 Address(~UINT64_C(0)),
170 HasInstructions(false)
173 A
->getSectionList().push_back(this);
178 MCSymbolData::MCSymbolData() : Symbol(0) {}
180 MCSymbolData::MCSymbolData(const MCSymbol
&_Symbol
, MCFragment
*_Fragment
,
181 uint64_t _Offset
, MCAssembler
*A
)
182 : Symbol(&_Symbol
), Fragment(_Fragment
), Offset(_Offset
),
183 IsExternal(false), IsPrivateExtern(false),
184 CommonSize(0), CommonAlign(0), Flags(0), Index(0)
187 A
->getSymbolList().push_back(this);
192 MCAssembler::MCAssembler(MCContext
&_Context
, TargetAsmBackend
&_Backend
,
193 MCCodeEmitter
&_Emitter
, raw_ostream
&_OS
)
194 : Context(_Context
), Backend(_Backend
), Emitter(_Emitter
),
195 OS(_OS
), RelaxAll(false), SubsectionsViaSymbols(false)
199 MCAssembler::~MCAssembler() {
202 static bool isScatteredFixupFullyResolvedSimple(const MCAssembler
&Asm
,
203 const MCAsmFixup
&Fixup
,
204 const MCValue Target
,
205 const MCSection
*BaseSection
) {
206 // The effective fixup address is
207 // addr(atom(A)) + offset(A)
208 // - addr(atom(B)) - offset(B)
209 // - addr(<base symbol>) + <fixup offset from base symbol>
210 // and the offsets are not relocatable, so the fixup is fully resolved when
211 // addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0.
213 // The simple (Darwin, except on x86_64) way of dealing with this was to
214 // assume that any reference to a temporary symbol *must* be a temporary
215 // symbol in the same atom, unless the sections differ. Therefore, any PCrel
216 // relocation to a temporary symbol (in the same section) is fully
217 // resolved. This also works in conjunction with absolutized .set, which
218 // requires the compiler to use .set to absolutize the differences between
219 // symbols which the compiler knows to be assembly time constants, so we don't
220 // need to worry about considering symbol differences fully resolved.
222 // Non-relative fixups are only resolved if constant.
224 return Target
.isAbsolute();
226 // Otherwise, relative fixups are only resolved if not a difference and the
227 // target is a temporary in the same section.
228 if (Target
.isAbsolute() || Target
.getSymB())
231 const MCSymbol
*A
= &Target
.getSymA()->getSymbol();
232 if (!A
->isTemporary() || !A
->isInSection() ||
233 &A
->getSection() != BaseSection
)
239 static bool isScatteredFixupFullyResolved(const MCAssembler
&Asm
,
240 const MCAsmLayout
&Layout
,
241 const MCAsmFixup
&Fixup
,
242 const MCValue Target
,
243 const MCSymbolData
*BaseSymbol
) {
244 // The effective fixup address is
245 // addr(atom(A)) + offset(A)
246 // - addr(atom(B)) - offset(B)
247 // - addr(BaseSymbol) + <fixup offset from base symbol>
248 // and the offsets are not relocatable, so the fixup is fully resolved when
249 // addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0.
251 // Note that "false" is almost always conservatively correct (it means we emit
252 // a relocation which is unnecessary), except when it would force us to emit a
253 // relocation which the target cannot encode.
255 const MCSymbolData
*A_Base
= 0, *B_Base
= 0;
256 if (const MCSymbolRefExpr
*A
= Target
.getSymA()) {
257 // Modified symbol references cannot be resolved.
258 if (A
->getKind() != MCSymbolRefExpr::VK_None
)
261 A_Base
= Asm
.getAtom(Layout
, &Asm
.getSymbolData(A
->getSymbol()));
266 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
267 // Modified symbol references cannot be resolved.
268 if (B
->getKind() != MCSymbolRefExpr::VK_None
)
271 B_Base
= Asm
.getAtom(Layout
, &Asm
.getSymbolData(B
->getSymbol()));
276 // If there is no base, A and B have to be the same atom for this fixup to be
279 return A_Base
== B_Base
;
281 // Otherwise, B must be missing and A must be the base.
282 return !B_Base
&& BaseSymbol
== A_Base
;
285 bool MCAssembler::isSymbolLinkerVisible(const MCSymbolData
*SD
) const {
286 // Non-temporary labels should always be visible to the linker.
287 if (!SD
->getSymbol().isTemporary())
290 // Absolute temporary labels are never visible.
291 if (!SD
->getFragment())
294 // Otherwise, check if the section requires symbols even for temporary labels.
295 return getBackend().doesSectionRequireSymbols(
296 SD
->getFragment()->getParent()->getSection());
299 const MCSymbolData
*MCAssembler::getAtom(const MCAsmLayout
&Layout
,
300 const MCSymbolData
*SD
) const {
301 // Linker visible symbols define atoms.
302 if (isSymbolLinkerVisible(SD
))
305 // Absolute and undefined symbols have no defining atom.
306 if (!SD
->getFragment())
309 // Non-linker visible symbols in sections which can't be atomized have no
311 if (!getBackend().isSectionAtomizable(
312 SD
->getFragment()->getParent()->getSection()))
315 // Otherwise, return the atom for the containing fragment.
316 return SD
->getFragment()->getAtom();
319 bool MCAssembler::EvaluateFixup(const MCAsmLayout
&Layout
,
320 const MCAsmFixup
&Fixup
, const MCFragment
*DF
,
321 MCValue
&Target
, uint64_t &Value
) const {
322 ++stats::EvaluateFixup
;
324 if (!Fixup
.Value
->EvaluateAsRelocatable(Target
, &Layout
))
325 report_fatal_error("expected relocatable expression");
327 // FIXME: How do non-scattered symbols work in ELF? I presume the linker
328 // doesn't support small relocations, but then under what criteria does the
329 // assembler allow symbol differences?
331 Value
= Target
.getConstant();
334 Emitter
.getFixupKindInfo(Fixup
.Kind
).Flags
& MCFixupKindInfo::FKF_IsPCRel
;
335 bool IsResolved
= true;
336 if (const MCSymbolRefExpr
*A
= Target
.getSymA()) {
337 if (A
->getSymbol().isDefined())
338 Value
+= Layout
.getSymbolAddress(&getSymbolData(A
->getSymbol()));
342 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
343 if (B
->getSymbol().isDefined())
344 Value
-= Layout
.getSymbolAddress(&getSymbolData(B
->getSymbol()));
349 // If we are using scattered symbols, determine whether this value is actually
350 // resolved; scattering may cause atoms to move.
351 if (IsResolved
&& getBackend().hasScatteredSymbols()) {
352 if (getBackend().hasReliableSymbolDifference()) {
353 // If this is a PCrel relocation, find the base atom (identified by its
354 // symbol) that the fixup value is relative to.
355 const MCSymbolData
*BaseSymbol
= 0;
357 BaseSymbol
= DF
->getAtom();
363 IsResolved
= isScatteredFixupFullyResolved(*this, Layout
, Fixup
, Target
,
366 const MCSection
*BaseSection
= 0;
368 BaseSection
= &DF
->getParent()->getSection();
370 IsResolved
= isScatteredFixupFullyResolvedSimple(*this, Fixup
, Target
,
376 Value
-= Layout
.getFragmentAddress(DF
) + Fixup
.Offset
;
381 void MCAssembler::LayoutFragment(MCAsmLayout
&Layout
, MCFragment
&F
) {
382 uint64_t StartAddress
= Layout
.getSectionAddress(F
.getParent());
384 // Get the fragment start address.
385 uint64_t Address
= StartAddress
;
386 MCSectionData::iterator it
= &F
;
387 if (MCFragment
*Prev
= F
.getPrevNode())
388 Address
= (StartAddress
+ Layout
.getFragmentOffset(Prev
) +
389 Layout
.getFragmentEffectiveSize(Prev
));
391 ++stats::FragmentLayouts
;
393 uint64_t FragmentOffset
= Address
- StartAddress
;
394 Layout
.setFragmentOffset(&F
, FragmentOffset
);
396 // Evaluate fragment size.
397 uint64_t EffectiveSize
= 0;
398 switch (F
.getKind()) {
399 case MCFragment::FT_Align
: {
400 MCAlignFragment
&AF
= cast
<MCAlignFragment
>(F
);
402 assert((!AF
.hasOnlyAlignAddress() || !AF
.getNextNode()) &&
403 "Invalid OnlyAlignAddress bit, not the last fragment!");
405 EffectiveSize
= OffsetToAlignment(Address
, AF
.getAlignment());
406 if (EffectiveSize
> AF
.getMaxBytesToEmit())
411 case MCFragment::FT_Data
:
412 EffectiveSize
= cast
<MCDataFragment
>(F
).getContents().size();
415 case MCFragment::FT_Fill
: {
416 EffectiveSize
= cast
<MCFillFragment
>(F
).getSize();
420 case MCFragment::FT_Inst
:
421 EffectiveSize
= cast
<MCInstFragment
>(F
).getInstSize();
424 case MCFragment::FT_Org
: {
425 MCOrgFragment
&OF
= cast
<MCOrgFragment
>(F
);
427 int64_t TargetLocation
;
428 if (!OF
.getOffset().EvaluateAsAbsolute(TargetLocation
, &Layout
))
429 report_fatal_error("expected assembly-time absolute expression");
431 // FIXME: We need a way to communicate this error.
432 int64_t Offset
= TargetLocation
- FragmentOffset
;
434 report_fatal_error("invalid .org offset '" + Twine(TargetLocation
) +
435 "' (at offset '" + Twine(FragmentOffset
) + "'");
437 EffectiveSize
= Offset
;
442 Layout
.setFragmentEffectiveSize(&F
, EffectiveSize
);
445 void MCAssembler::LayoutSection(MCAsmLayout
&Layout
,
446 unsigned SectionOrderIndex
) {
447 MCSectionData
&SD
= *Layout
.getSectionOrder()[SectionOrderIndex
];
449 ++stats::SectionLayouts
;
451 // Compute the section start address.
452 uint64_t StartAddress
= 0;
453 if (SectionOrderIndex
) {
454 MCSectionData
*Prev
= Layout
.getSectionOrder()[SectionOrderIndex
- 1];
455 StartAddress
= (Layout
.getSectionAddress(Prev
) +
456 Layout
.getSectionAddressSize(Prev
));
459 // Honor the section alignment requirements.
460 StartAddress
= RoundUpToAlignment(StartAddress
, SD
.getAlignment());
462 // Set the section address.
463 Layout
.setSectionAddress(&SD
, StartAddress
);
465 for (MCSectionData::iterator it
= SD
.begin(), ie
= SD
.end(); it
!= ie
; ++it
)
466 LayoutFragment(Layout
, *it
);
469 /// WriteFragmentData - Write the \arg F data to the output file.
470 static void WriteFragmentData(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
,
471 const MCFragment
&F
, MCObjectWriter
*OW
) {
472 uint64_t Start
= OW
->getStream().tell();
475 ++stats::EmittedFragments
;
477 // FIXME: Embed in fragments instead?
478 uint64_t FragmentSize
= Layout
.getFragmentEffectiveSize(&F
);
479 switch (F
.getKind()) {
480 case MCFragment::FT_Align
: {
481 MCAlignFragment
&AF
= cast
<MCAlignFragment
>(F
);
482 uint64_t Count
= FragmentSize
/ AF
.getValueSize();
484 assert(AF
.getValueSize() && "Invalid virtual align in concrete fragment!");
486 // FIXME: This error shouldn't actually occur (the front end should emit
487 // multiple .align directives to enforce the semantics it wants), but is
488 // severe enough that we want to report it. How to handle this?
489 if (Count
* AF
.getValueSize() != FragmentSize
)
490 report_fatal_error("undefined .align directive, value size '" +
491 Twine(AF
.getValueSize()) +
492 "' is not a divisor of padding size '" +
493 Twine(FragmentSize
) + "'");
495 // See if we are aligning with nops, and if so do that first to try to fill
496 // the Count bytes. Then if that did not fill any bytes or there are any
497 // bytes left to fill use the the Value and ValueSize to fill the rest.
498 // If we are aligning with nops, ask that target to emit the right data.
499 if (AF
.hasEmitNops()) {
500 if (!Asm
.getBackend().WriteNopData(Count
, OW
))
501 report_fatal_error("unable to write nop sequence of " +
502 Twine(Count
) + " bytes");
506 // Otherwise, write out in multiples of the value size.
507 for (uint64_t i
= 0; i
!= Count
; ++i
) {
508 switch (AF
.getValueSize()) {
510 assert(0 && "Invalid size!");
511 case 1: OW
->Write8 (uint8_t (AF
.getValue())); break;
512 case 2: OW
->Write16(uint16_t(AF
.getValue())); break;
513 case 4: OW
->Write32(uint32_t(AF
.getValue())); break;
514 case 8: OW
->Write64(uint64_t(AF
.getValue())); break;
520 case MCFragment::FT_Data
: {
521 MCDataFragment
&DF
= cast
<MCDataFragment
>(F
);
522 assert(FragmentSize
== DF
.getContents().size() && "Invalid size!");
523 OW
->WriteBytes(DF
.getContents().str());
527 case MCFragment::FT_Fill
: {
528 MCFillFragment
&FF
= cast
<MCFillFragment
>(F
);
530 assert(FF
.getValueSize() && "Invalid virtual align in concrete fragment!");
532 for (uint64_t i
= 0, e
= FF
.getSize() / FF
.getValueSize(); i
!= e
; ++i
) {
533 switch (FF
.getValueSize()) {
535 assert(0 && "Invalid size!");
536 case 1: OW
->Write8 (uint8_t (FF
.getValue())); break;
537 case 2: OW
->Write16(uint16_t(FF
.getValue())); break;
538 case 4: OW
->Write32(uint32_t(FF
.getValue())); break;
539 case 8: OW
->Write64(uint64_t(FF
.getValue())); break;
545 case MCFragment::FT_Inst
:
546 llvm_unreachable("unexpected inst fragment after lowering");
549 case MCFragment::FT_Org
: {
550 MCOrgFragment
&OF
= cast
<MCOrgFragment
>(F
);
552 for (uint64_t i
= 0, e
= FragmentSize
; i
!= e
; ++i
)
553 OW
->Write8(uint8_t(OF
.getValue()));
559 assert(OW
->getStream().tell() - Start
== FragmentSize
);
562 void MCAssembler::WriteSectionData(const MCSectionData
*SD
,
563 const MCAsmLayout
&Layout
,
564 MCObjectWriter
*OW
) const {
565 // Ignore virtual sections.
566 if (getBackend().isVirtualSection(SD
->getSection())) {
567 assert(Layout
.getSectionFileSize(SD
) == 0 && "Invalid size for section!");
569 // Check that contents are only things legal inside a virtual section.
570 for (MCSectionData::const_iterator it
= SD
->begin(),
571 ie
= SD
->end(); it
!= ie
; ++it
) {
572 switch (it
->getKind()) {
574 assert(0 && "Invalid fragment in virtual section!");
575 case MCFragment::FT_Align
:
576 assert(!cast
<MCAlignFragment
>(it
)->getValueSize() &&
577 "Invalid align in virtual section!");
579 case MCFragment::FT_Fill
:
580 assert(!cast
<MCFillFragment
>(it
)->getValueSize() &&
581 "Invalid fill in virtual section!");
589 uint64_t Start
= OW
->getStream().tell();
592 for (MCSectionData::const_iterator it
= SD
->begin(),
593 ie
= SD
->end(); it
!= ie
; ++it
)
594 WriteFragmentData(*this, Layout
, *it
, OW
);
596 assert(OW
->getStream().tell() - Start
== Layout
.getSectionFileSize(SD
));
599 void MCAssembler::Finish() {
600 DEBUG_WITH_TYPE("mc-dump", {
601 llvm::errs() << "assembler backend - pre-layout\n--\n";
604 // Assign section and fragment ordinals, all subsequent backend code is
605 // responsible for updating these in place.
606 unsigned SectionIndex
= 0;
607 unsigned FragmentIndex
= 0;
608 for (MCAssembler::iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
609 it
->setOrdinal(SectionIndex
++);
611 for (MCSectionData::iterator it2
= it
->begin(),
612 ie2
= it
->end(); it2
!= ie2
; ++it2
)
613 it2
->setOrdinal(FragmentIndex
++);
616 // Create the layout object.
617 MCAsmLayout
Layout(*this);
619 // Insert additional align fragments for concrete sections to explicitly pad
620 // the previous section to match their alignment requirements. This is for
621 // 'gas' compatibility, it shouldn't strictly be necessary.
623 // FIXME: This may be Mach-O specific.
624 for (unsigned i
= 1, e
= Layout
.getSectionOrder().size(); i
< e
; ++i
) {
625 MCSectionData
*SD
= Layout
.getSectionOrder()[i
];
627 // Ignore sections without alignment requirements.
628 unsigned Align
= SD
->getAlignment();
632 // Ignore virtual sections, they don't cause file size modifications.
633 if (getBackend().isVirtualSection(SD
->getSection()))
636 // Otherwise, create a new align fragment at the end of the previous
638 MCAlignFragment
*AF
= new MCAlignFragment(Align
, 0, 1, Align
,
639 Layout
.getSectionOrder()[i
- 1]);
640 AF
->setOnlyAlignAddress(true);
643 // Layout until everything fits.
644 while (LayoutOnce(Layout
))
647 DEBUG_WITH_TYPE("mc-dump", {
648 llvm::errs() << "assembler backend - post-relaxation\n--\n";
651 // Finalize the layout, including fragment lowering.
652 FinishLayout(Layout
);
654 DEBUG_WITH_TYPE("mc-dump", {
655 llvm::errs() << "assembler backend - final-layout\n--\n";
658 uint64_t StartOffset
= OS
.tell();
659 llvm::OwningPtr
<MCObjectWriter
> Writer(getBackend().createObjectWriter(OS
));
661 report_fatal_error("unable to create object writer!");
663 // Allow the object writer a chance to perform post-layout binding (for
664 // example, to set the index fields in the symbol data).
665 Writer
->ExecutePostLayoutBinding(*this);
667 // Evaluate and apply the fixups, generating relocation entries as necessary.
668 for (MCAssembler::iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
669 for (MCSectionData::iterator it2
= it
->begin(),
670 ie2
= it
->end(); it2
!= ie2
; ++it2
) {
671 MCDataFragment
*DF
= dyn_cast
<MCDataFragment
>(it2
);
675 for (MCDataFragment::fixup_iterator it3
= DF
->fixup_begin(),
676 ie3
= DF
->fixup_end(); it3
!= ie3
; ++it3
) {
677 MCAsmFixup
&Fixup
= *it3
;
679 // Evaluate the fixup.
682 if (!EvaluateFixup(Layout
, Fixup
, DF
, Target
, FixedValue
)) {
683 // The fixup was unresolved, we need a relocation. Inform the object
684 // writer of the relocation, and give it an opportunity to adjust the
685 // fixup value if need be.
686 Writer
->RecordRelocation(*this, Layout
, DF
, Fixup
, Target
,FixedValue
);
689 getBackend().ApplyFixup(Fixup
, *DF
, FixedValue
);
694 // Write the object file.
695 Writer
->WriteObject(*this, Layout
);
698 stats::ObjectBytes
+= OS
.tell() - StartOffset
;
701 bool MCAssembler::FixupNeedsRelaxation(const MCAsmFixup
&Fixup
,
702 const MCFragment
*DF
,
703 const MCAsmLayout
&Layout
) const {
707 // If we cannot resolve the fixup value, it requires relaxation.
710 if (!EvaluateFixup(Layout
, Fixup
, DF
, Target
, Value
))
713 // Otherwise, relax if the value is too big for a (signed) i8.
715 // FIXME: This is target dependent!
716 return int64_t(Value
) != int64_t(int8_t(Value
));
719 bool MCAssembler::FragmentNeedsRelaxation(const MCInstFragment
*IF
,
720 const MCAsmLayout
&Layout
) const {
721 // If this inst doesn't ever need relaxation, ignore it. This occurs when we
722 // are intentionally pushing out inst fragments, or because we relaxed a
723 // previous instruction to one that doesn't need relaxation.
724 if (!getBackend().MayNeedRelaxation(IF
->getInst(), IF
->getFixups()))
727 for (MCInstFragment::const_fixup_iterator it
= IF
->fixup_begin(),
728 ie
= IF
->fixup_end(); it
!= ie
; ++it
)
729 if (FixupNeedsRelaxation(*it
, IF
, Layout
))
735 bool MCAssembler::LayoutOnce(MCAsmLayout
&Layout
) {
736 ++stats::RelaxationSteps
;
738 // Layout the sections in order.
739 for (unsigned i
= 0, e
= Layout
.getSectionOrder().size(); i
!= e
; ++i
)
740 LayoutSection(Layout
, i
);
742 // Scan for fragments that need relaxation.
743 bool WasRelaxed
= false;
744 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
745 MCSectionData
&SD
= *it
;
747 for (MCSectionData::iterator it2
= SD
.begin(),
748 ie2
= SD
.end(); it2
!= ie2
; ++it2
) {
749 // Check if this is an instruction fragment that needs relaxation.
750 MCInstFragment
*IF
= dyn_cast
<MCInstFragment
>(it2
);
751 if (!IF
|| !FragmentNeedsRelaxation(IF
, Layout
))
754 ++stats::RelaxedInstructions
;
756 // FIXME-PERF: We could immediately lower out instructions if we can tell
757 // they are fully resolved, to avoid retesting on later passes.
759 // Relax the fragment.
762 getBackend().RelaxInstruction(IF
, Relaxed
);
764 // Encode the new instruction.
766 // FIXME-PERF: If it matters, we could let the target do this. It can
767 // probably do so more efficiently in many cases.
768 SmallVector
<MCFixup
, 4> Fixups
;
769 SmallString
<256> Code
;
770 raw_svector_ostream
VecOS(Code
);
771 getEmitter().EncodeInstruction(Relaxed
, VecOS
, Fixups
);
774 // Update the instruction fragment.
775 int SlideAmount
= Code
.size() - IF
->getInstSize();
776 IF
->setInst(Relaxed
);
777 IF
->getCode() = Code
;
778 IF
->getFixups().clear();
779 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
) {
780 MCFixup
&F
= Fixups
[i
];
781 IF
->getFixups().push_back(MCAsmFixup(F
.getOffset(), *F
.getValue(),
785 // Update the layout, and remember that we relaxed. If we are relaxing
786 // everything, we can skip this step since nothing will depend on updating
789 Layout
.UpdateForSlide(IF
, SlideAmount
);
797 void MCAssembler::FinishLayout(MCAsmLayout
&Layout
) {
798 // Lower out any instruction fragments, to simplify the fixup application and
801 // FIXME-PERF: We don't have to do this, but the assumption is that it is
802 // cheap (we will mostly end up eliminating fragments and appending on to data
803 // fragments), so the extra complexity downstream isn't worth it. Evaluate
805 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
806 MCSectionData
&SD
= *it
;
808 for (MCSectionData::iterator it2
= SD
.begin(),
809 ie2
= SD
.end(); it2
!= ie2
; ++it2
) {
810 MCInstFragment
*IF
= dyn_cast
<MCInstFragment
>(it2
);
814 // Create a new data fragment for the instruction.
816 // FIXME-PERF: Reuse previous data fragment if possible.
817 MCDataFragment
*DF
= new MCDataFragment();
818 SD
.getFragmentList().insert(it2
, DF
);
820 // Update the data fragments layout data.
822 // FIXME: Add MCAsmLayout utility for this.
823 DF
->setParent(IF
->getParent());
824 DF
->setAtom(IF
->getAtom());
825 DF
->setOrdinal(IF
->getOrdinal());
826 Layout
.setFragmentOffset(DF
, Layout
.getFragmentOffset(IF
));
827 Layout
.setFragmentEffectiveSize(DF
, Layout
.getFragmentEffectiveSize(IF
));
829 // Copy in the data and the fixups.
830 DF
->getContents().append(IF
->getCode().begin(), IF
->getCode().end());
831 for (unsigned i
= 0, e
= IF
->getFixups().size(); i
!= e
; ++i
)
832 DF
->getFixups().push_back(IF
->getFixups()[i
]);
834 // Delete the instruction fragment and update the iterator.
835 SD
.getFragmentList().erase(IF
);
845 raw_ostream
&operator<<(raw_ostream
&OS
, const MCAsmFixup
&AF
) {
846 OS
<< "<MCAsmFixup" << " Offset:" << AF
.Offset
<< " Value:" << *AF
.Value
847 << " Kind:" << AF
.Kind
<< ">";
853 void MCFragment::dump() {
854 raw_ostream
&OS
= llvm::errs();
856 OS
<< "<MCFragment " << (void*) this << " Offset:" << Offset
857 << " EffectiveSize:" << EffectiveSize
<< ">";
860 void MCAlignFragment::dump() {
861 raw_ostream
&OS
= llvm::errs();
863 OS
<< "<MCAlignFragment ";
864 this->MCFragment::dump();
866 OS
<< " (emit nops)";
867 if (hasOnlyAlignAddress())
868 OS
<< " (only align section)";
870 OS
<< " Alignment:" << getAlignment()
871 << " Value:" << getValue() << " ValueSize:" << getValueSize()
872 << " MaxBytesToEmit:" << getMaxBytesToEmit() << ">";
875 void MCDataFragment::dump() {
876 raw_ostream
&OS
= llvm::errs();
878 OS
<< "<MCDataFragment ";
879 this->MCFragment::dump();
882 for (unsigned i
= 0, e
= getContents().size(); i
!= e
; ++i
) {
884 OS
<< hexdigit((Contents
[i
] >> 4) & 0xF) << hexdigit(Contents
[i
] & 0xF);
886 OS
<< "] (" << getContents().size() << " bytes)";
888 if (!getFixups().empty()) {
891 for (fixup_iterator it
= fixup_begin(), ie
= fixup_end(); it
!= ie
; ++it
) {
892 if (it
!= fixup_begin()) OS
<< ",\n ";
901 void MCFillFragment::dump() {
902 raw_ostream
&OS
= llvm::errs();
904 OS
<< "<MCFillFragment ";
905 this->MCFragment::dump();
907 OS
<< " Value:" << getValue() << " ValueSize:" << getValueSize()
908 << " Size:" << getSize() << ">";
911 void MCInstFragment::dump() {
912 raw_ostream
&OS
= llvm::errs();
914 OS
<< "<MCInstFragment ";
915 this->MCFragment::dump();
918 getInst().dump_pretty(OS
);
922 void MCOrgFragment::dump() {
923 raw_ostream
&OS
= llvm::errs();
925 OS
<< "<MCOrgFragment ";
926 this->MCFragment::dump();
928 OS
<< " Offset:" << getOffset() << " Value:" << getValue() << ">";
931 void MCSectionData::dump() {
932 raw_ostream
&OS
= llvm::errs();
934 OS
<< "<MCSectionData";
935 OS
<< " Alignment:" << getAlignment() << " Address:" << Address
936 << " Fragments:[\n ";
937 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
938 if (it
!= begin()) OS
<< ",\n ";
944 void MCSymbolData::dump() {
945 raw_ostream
&OS
= llvm::errs();
947 OS
<< "<MCSymbolData Symbol:" << getSymbol()
948 << " Fragment:" << getFragment() << " Offset:" << getOffset()
949 << " Flags:" << getFlags() << " Index:" << getIndex();
951 OS
<< " (common, size:" << getCommonSize()
952 << " align: " << getCommonAlignment() << ")";
955 if (isPrivateExtern())
956 OS
<< " (private extern)";
960 void MCAssembler::dump() {
961 raw_ostream
&OS
= llvm::errs();
963 OS
<< "<MCAssembler\n";
964 OS
<< " Sections:[\n ";
965 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
966 if (it
!= begin()) OS
<< ",\n ";
972 for (symbol_iterator it
= symbol_begin(), ie
= symbol_end(); it
!= ie
; ++it
) {
973 if (it
!= symbol_begin()) OS
<< ",\n ";