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
)
51 : Assembler(Asm
), LastValidFragment(0)
53 // Compute the section layout order. Virtual sections must go last.
54 for (MCAssembler::iterator it
= Asm
.begin(), ie
= Asm
.end(); it
!= ie
; ++it
)
55 if (!Asm
.getBackend().isVirtualSection(it
->getSection()))
56 SectionOrder
.push_back(&*it
);
57 for (MCAssembler::iterator it
= Asm
.begin(), ie
= Asm
.end(); it
!= ie
; ++it
)
58 if (Asm
.getBackend().isVirtualSection(it
->getSection()))
59 SectionOrder
.push_back(&*it
);
62 bool MCAsmLayout::isSectionUpToDate(const MCSectionData
*SD
) const {
63 // The first section is always up-to-date.
64 unsigned Index
= SD
->getLayoutOrder();
68 // Otherwise, sections are always implicitly computed when the preceeding
69 // fragment is layed out.
70 const MCSectionData
*Prev
= getSectionOrder()[Index
- 1];
71 return isFragmentUpToDate(&(Prev
->getFragmentList().back()));
74 bool MCAsmLayout::isFragmentUpToDate(const MCFragment
*F
) const {
75 return (LastValidFragment
&&
76 F
->getLayoutOrder() <= LastValidFragment
->getLayoutOrder());
79 void MCAsmLayout::UpdateForSlide(MCFragment
*F
, int SlideAmount
) {
80 // If this fragment wasn't already up-to-date, we don't need to do anything.
81 if (!isFragmentUpToDate(F
))
84 // Otherwise, reset the last valid fragment to the predecessor of the
85 // invalidated fragment.
86 LastValidFragment
= F
->getPrevNode();
87 if (!LastValidFragment
) {
88 unsigned Index
= F
->getParent()->getLayoutOrder();
90 MCSectionData
*Prev
= getSectionOrder()[Index
- 1];
91 LastValidFragment
= &(Prev
->getFragmentList().back());
96 void MCAsmLayout::EnsureValid(const MCFragment
*F
) const {
97 // Advance the layout position until the fragment is up-to-date.
98 while (!isFragmentUpToDate(F
)) {
99 // Advance to the next fragment.
100 MCFragment
*Cur
= LastValidFragment
;
102 Cur
= Cur
->getNextNode();
104 unsigned NextIndex
= 0;
105 if (LastValidFragment
)
106 NextIndex
= LastValidFragment
->getParent()->getLayoutOrder() + 1;
107 Cur
= SectionOrder
[NextIndex
]->begin();
110 const_cast<MCAsmLayout
*>(this)->LayoutFragment(Cur
);
114 void MCAsmLayout::FragmentReplaced(MCFragment
*Src
, MCFragment
*Dst
) {
115 if (LastValidFragment
== Src
)
116 LastValidFragment
= Dst
;
118 Dst
->Offset
= Src
->Offset
;
119 Dst
->EffectiveSize
= Src
->EffectiveSize
;
122 uint64_t MCAsmLayout::getFragmentAddress(const MCFragment
*F
) const {
123 assert(F
->getParent() && "Missing section()!");
124 return getSectionAddress(F
->getParent()) + getFragmentOffset(F
);
127 uint64_t MCAsmLayout::getFragmentEffectiveSize(const MCFragment
*F
) const {
129 assert(F
->EffectiveSize
!= ~UINT64_C(0) && "Address not set!");
130 return F
->EffectiveSize
;
133 uint64_t MCAsmLayout::getFragmentOffset(const MCFragment
*F
) const {
135 assert(F
->Offset
!= ~UINT64_C(0) && "Address not set!");
139 uint64_t MCAsmLayout::getSymbolAddress(const MCSymbolData
*SD
) const {
140 assert(SD
->getFragment() && "Invalid getAddress() on undefined symbol!");
141 return getFragmentAddress(SD
->getFragment()) + SD
->getOffset();
144 uint64_t MCAsmLayout::getSectionAddress(const MCSectionData
*SD
) const {
145 EnsureValid(SD
->begin());
146 assert(SD
->Address
!= ~UINT64_C(0) && "Address not set!");
150 uint64_t MCAsmLayout::getSectionAddressSize(const MCSectionData
*SD
) const {
151 // The size is the last fragment's end offset.
152 const MCFragment
&F
= SD
->getFragmentList().back();
153 return getFragmentOffset(&F
) + getFragmentEffectiveSize(&F
);
156 uint64_t MCAsmLayout::getSectionFileSize(const MCSectionData
*SD
) const {
157 // Virtual sections have no file size.
158 if (getAssembler().getBackend().isVirtualSection(SD
->getSection()))
161 // Otherwise, the file size is the same as the address space size.
162 return getSectionAddressSize(SD
);
165 uint64_t MCAsmLayout::getSectionSize(const MCSectionData
*SD
) const {
166 // The logical size is the address space size minus any tail padding.
167 uint64_t Size
= getSectionAddressSize(SD
);
168 const MCAlignFragment
*AF
=
169 dyn_cast
<MCAlignFragment
>(&(SD
->getFragmentList().back()));
170 if (AF
&& AF
->hasOnlyAlignAddress())
171 Size
-= getFragmentEffectiveSize(AF
);
178 MCFragment::MCFragment() : Kind(FragmentType(~0)) {
181 MCFragment::~MCFragment() {
184 MCFragment::MCFragment(FragmentType _Kind
, MCSectionData
*_Parent
)
185 : Kind(_Kind
), Parent(_Parent
), Atom(0), Offset(~UINT64_C(0)),
186 EffectiveSize(~UINT64_C(0))
189 Parent
->getFragmentList().push_back(this);
194 MCSectionData::MCSectionData() : Section(0) {}
196 MCSectionData::MCSectionData(const MCSection
&_Section
, MCAssembler
*A
)
197 : Section(&_Section
),
199 Address(~UINT64_C(0)),
200 HasInstructions(false)
203 A
->getSectionList().push_back(this);
208 MCSymbolData::MCSymbolData() : Symbol(0) {}
210 MCSymbolData::MCSymbolData(const MCSymbol
&_Symbol
, MCFragment
*_Fragment
,
211 uint64_t _Offset
, MCAssembler
*A
)
212 : Symbol(&_Symbol
), Fragment(_Fragment
), Offset(_Offset
),
213 IsExternal(false), IsPrivateExtern(false),
214 CommonSize(0), CommonAlign(0), Flags(0), Index(0)
217 A
->getSymbolList().push_back(this);
222 MCAssembler::MCAssembler(MCContext
&_Context
, TargetAsmBackend
&_Backend
,
223 MCCodeEmitter
&_Emitter
, raw_ostream
&_OS
)
224 : Context(_Context
), Backend(_Backend
), Emitter(_Emitter
),
225 OS(_OS
), RelaxAll(false), SubsectionsViaSymbols(false)
229 MCAssembler::~MCAssembler() {
232 static bool isScatteredFixupFullyResolvedSimple(const MCAssembler
&Asm
,
233 const MCFixup
&Fixup
,
234 const MCValue Target
,
235 const MCSection
*BaseSection
) {
236 // The effective fixup address is
237 // addr(atom(A)) + offset(A)
238 // - addr(atom(B)) - offset(B)
239 // - addr(<base symbol>) + <fixup offset from base symbol>
240 // and the offsets are not relocatable, so the fixup is fully resolved when
241 // addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0.
243 // The simple (Darwin, except on x86_64) way of dealing with this was to
244 // assume that any reference to a temporary symbol *must* be a temporary
245 // symbol in the same atom, unless the sections differ. Therefore, any PCrel
246 // relocation to a temporary symbol (in the same section) is fully
247 // resolved. This also works in conjunction with absolutized .set, which
248 // requires the compiler to use .set to absolutize the differences between
249 // symbols which the compiler knows to be assembly time constants, so we don't
250 // need to worry about considering symbol differences fully resolved.
252 // Non-relative fixups are only resolved if constant.
254 return Target
.isAbsolute();
256 // Otherwise, relative fixups are only resolved if not a difference and the
257 // target is a temporary in the same section.
258 if (Target
.isAbsolute() || Target
.getSymB())
261 const MCSymbol
*A
= &Target
.getSymA()->getSymbol();
262 if (!A
->isTemporary() || !A
->isInSection() ||
263 &A
->getSection() != BaseSection
)
269 static bool isScatteredFixupFullyResolved(const MCAssembler
&Asm
,
270 const MCAsmLayout
&Layout
,
271 const MCFixup
&Fixup
,
272 const MCValue Target
,
273 const MCSymbolData
*BaseSymbol
) {
274 // The effective fixup address is
275 // addr(atom(A)) + offset(A)
276 // - addr(atom(B)) - offset(B)
277 // - addr(BaseSymbol) + <fixup offset from base symbol>
278 // and the offsets are not relocatable, so the fixup is fully resolved when
279 // addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0.
281 // Note that "false" is almost always conservatively correct (it means we emit
282 // a relocation which is unnecessary), except when it would force us to emit a
283 // relocation which the target cannot encode.
285 const MCSymbolData
*A_Base
= 0, *B_Base
= 0;
286 if (const MCSymbolRefExpr
*A
= Target
.getSymA()) {
287 // Modified symbol references cannot be resolved.
288 if (A
->getKind() != MCSymbolRefExpr::VK_None
)
291 A_Base
= Asm
.getAtom(Layout
, &Asm
.getSymbolData(A
->getSymbol()));
296 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
297 // Modified symbol references cannot be resolved.
298 if (B
->getKind() != MCSymbolRefExpr::VK_None
)
301 B_Base
= Asm
.getAtom(Layout
, &Asm
.getSymbolData(B
->getSymbol()));
306 // If there is no base, A and B have to be the same atom for this fixup to be
309 return A_Base
== B_Base
;
311 // Otherwise, B must be missing and A must be the base.
312 return !B_Base
&& BaseSymbol
== A_Base
;
315 bool MCAssembler::isSymbolLinkerVisible(const MCSymbol
&Symbol
) const {
316 // Non-temporary labels should always be visible to the linker.
317 if (!Symbol
.isTemporary())
320 // Absolute temporary labels are never visible.
321 if (!Symbol
.isInSection())
324 // Otherwise, check if the section requires symbols even for temporary labels.
325 return getBackend().doesSectionRequireSymbols(Symbol
.getSection());
328 const MCSymbolData
*MCAssembler::getAtom(const MCAsmLayout
&Layout
,
329 const MCSymbolData
*SD
) const {
330 // Linker visible symbols define atoms.
331 if (isSymbolLinkerVisible(SD
->getSymbol()))
334 // Absolute and undefined symbols have no defining atom.
335 if (!SD
->getFragment())
338 // Non-linker visible symbols in sections which can't be atomized have no
340 if (!getBackend().isSectionAtomizable(
341 SD
->getFragment()->getParent()->getSection()))
344 // Otherwise, return the atom for the containing fragment.
345 return SD
->getFragment()->getAtom();
348 bool MCAssembler::EvaluateFixup(const MCAsmLayout
&Layout
,
349 const MCFixup
&Fixup
, const MCFragment
*DF
,
350 MCValue
&Target
, uint64_t &Value
) const {
351 ++stats::EvaluateFixup
;
353 if (!Fixup
.getValue()->EvaluateAsRelocatable(Target
, &Layout
))
354 report_fatal_error("expected relocatable expression");
356 // FIXME: How do non-scattered symbols work in ELF? I presume the linker
357 // doesn't support small relocations, but then under what criteria does the
358 // assembler allow symbol differences?
360 Value
= Target
.getConstant();
362 bool IsPCRel
= Emitter
.getFixupKindInfo(
363 Fixup
.getKind()).Flags
& MCFixupKindInfo::FKF_IsPCRel
;
364 bool IsResolved
= true;
365 if (const MCSymbolRefExpr
*A
= Target
.getSymA()) {
366 if (A
->getSymbol().isDefined())
367 Value
+= Layout
.getSymbolAddress(&getSymbolData(A
->getSymbol()));
371 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
372 if (B
->getSymbol().isDefined())
373 Value
-= Layout
.getSymbolAddress(&getSymbolData(B
->getSymbol()));
378 // If we are using scattered symbols, determine whether this value is actually
379 // resolved; scattering may cause atoms to move.
380 if (IsResolved
&& getBackend().hasScatteredSymbols()) {
381 if (getBackend().hasReliableSymbolDifference()) {
382 // If this is a PCrel relocation, find the base atom (identified by its
383 // symbol) that the fixup value is relative to.
384 const MCSymbolData
*BaseSymbol
= 0;
386 BaseSymbol
= DF
->getAtom();
392 IsResolved
= isScatteredFixupFullyResolved(*this, Layout
, Fixup
, Target
,
395 const MCSection
*BaseSection
= 0;
397 BaseSection
= &DF
->getParent()->getSection();
399 IsResolved
= isScatteredFixupFullyResolvedSimple(*this, Fixup
, Target
,
405 Value
-= Layout
.getFragmentAddress(DF
) + Fixup
.getOffset();
410 uint64_t MCAssembler::ComputeFragmentSize(MCAsmLayout
&Layout
,
412 uint64_t SectionAddress
,
413 uint64_t FragmentOffset
) const {
414 switch (F
.getKind()) {
415 case MCFragment::FT_Data
:
416 return cast
<MCDataFragment
>(F
).getContents().size();
417 case MCFragment::FT_Fill
:
418 return cast
<MCFillFragment
>(F
).getSize();
419 case MCFragment::FT_Inst
:
420 return cast
<MCInstFragment
>(F
).getInstSize();
422 case MCFragment::FT_Align
: {
423 const MCAlignFragment
&AF
= cast
<MCAlignFragment
>(F
);
425 assert((!AF
.hasOnlyAlignAddress() || !AF
.getNextNode()) &&
426 "Invalid OnlyAlignAddress bit, not the last fragment!");
428 uint64_t Size
= OffsetToAlignment(SectionAddress
+ FragmentOffset
,
431 // Honor MaxBytesToEmit.
432 if (Size
> AF
.getMaxBytesToEmit())
438 case MCFragment::FT_Org
: {
439 const MCOrgFragment
&OF
= cast
<MCOrgFragment
>(F
);
441 // FIXME: We should compute this sooner, we don't want to recurse here, and
442 // we would like to be more functional.
443 int64_t TargetLocation
;
444 if (!OF
.getOffset().EvaluateAsAbsolute(TargetLocation
, &Layout
))
445 report_fatal_error("expected assembly-time absolute expression");
447 // FIXME: We need a way to communicate this error.
448 int64_t Offset
= TargetLocation
- FragmentOffset
;
450 report_fatal_error("invalid .org offset '" + Twine(TargetLocation
) +
451 "' (at offset '" + Twine(FragmentOffset
) + "'");
457 assert(0 && "invalid fragment kind");
461 void MCAsmLayout::LayoutFile() {
462 // Initialize the first section and set the valid fragment layout point. All
463 // actual layout computations are done lazily.
464 LastValidFragment
= 0;
465 if (!getSectionOrder().empty())
466 getSectionOrder().front()->Address
= 0;
469 void MCAsmLayout::LayoutFragment(MCFragment
*F
) {
470 MCFragment
*Prev
= F
->getPrevNode();
472 // We should never try to recompute something which is up-to-date.
473 assert(!isFragmentUpToDate(F
) && "Attempt to recompute up-to-date fragment!");
474 // We should never try to compute the fragment layout if the section isn't
476 assert(isSectionUpToDate(F
->getParent()) &&
477 "Attempt to compute fragment before it's section!");
478 // We should never try to compute the fragment layout if it's predecessor
480 assert((!Prev
|| isFragmentUpToDate(Prev
)) &&
481 "Attempt to compute fragment before it's predecessor!");
483 ++stats::FragmentLayouts
;
485 // Compute the fragment start address.
486 uint64_t StartAddress
= F
->getParent()->Address
;
487 uint64_t Address
= StartAddress
;
489 Address
+= Prev
->Offset
+ Prev
->EffectiveSize
;
491 // Compute fragment offset and size.
492 F
->Offset
= Address
- StartAddress
;
493 F
->EffectiveSize
= getAssembler().ComputeFragmentSize(*this, *F
, StartAddress
,
495 LastValidFragment
= F
;
497 // If this is the last fragment in a section, update the next section address.
498 if (!F
->getNextNode()) {
499 unsigned NextIndex
= F
->getParent()->getLayoutOrder() + 1;
500 if (NextIndex
!= getSectionOrder().size())
501 LayoutSection(getSectionOrder()[NextIndex
]);
505 void MCAsmLayout::LayoutSection(MCSectionData
*SD
) {
506 unsigned SectionOrderIndex
= SD
->getLayoutOrder();
508 ++stats::SectionLayouts
;
510 // Compute the section start address.
511 uint64_t StartAddress
= 0;
512 if (SectionOrderIndex
) {
513 MCSectionData
*Prev
= getSectionOrder()[SectionOrderIndex
- 1];
514 StartAddress
= getSectionAddress(Prev
) + getSectionAddressSize(Prev
);
517 // Honor the section alignment requirements.
518 StartAddress
= RoundUpToAlignment(StartAddress
, SD
->getAlignment());
520 // Set the section address.
521 SD
->Address
= StartAddress
;
524 /// WriteFragmentData - Write the \arg F data to the output file.
525 static void WriteFragmentData(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
,
526 const MCFragment
&F
, MCObjectWriter
*OW
) {
527 uint64_t Start
= OW
->getStream().tell();
530 ++stats::EmittedFragments
;
532 // FIXME: Embed in fragments instead?
533 uint64_t FragmentSize
= Layout
.getFragmentEffectiveSize(&F
);
534 switch (F
.getKind()) {
535 case MCFragment::FT_Align
: {
536 MCAlignFragment
&AF
= cast
<MCAlignFragment
>(F
);
537 uint64_t Count
= FragmentSize
/ AF
.getValueSize();
539 assert(AF
.getValueSize() && "Invalid virtual align in concrete fragment!");
541 // FIXME: This error shouldn't actually occur (the front end should emit
542 // multiple .align directives to enforce the semantics it wants), but is
543 // severe enough that we want to report it. How to handle this?
544 if (Count
* AF
.getValueSize() != FragmentSize
)
545 report_fatal_error("undefined .align directive, value size '" +
546 Twine(AF
.getValueSize()) +
547 "' is not a divisor of padding size '" +
548 Twine(FragmentSize
) + "'");
550 // See if we are aligning with nops, and if so do that first to try to fill
551 // the Count bytes. Then if that did not fill any bytes or there are any
552 // bytes left to fill use the the Value and ValueSize to fill the rest.
553 // If we are aligning with nops, ask that target to emit the right data.
554 if (AF
.hasEmitNops()) {
555 if (!Asm
.getBackend().WriteNopData(Count
, OW
))
556 report_fatal_error("unable to write nop sequence of " +
557 Twine(Count
) + " bytes");
561 // Otherwise, write out in multiples of the value size.
562 for (uint64_t i
= 0; i
!= Count
; ++i
) {
563 switch (AF
.getValueSize()) {
565 assert(0 && "Invalid size!");
566 case 1: OW
->Write8 (uint8_t (AF
.getValue())); break;
567 case 2: OW
->Write16(uint16_t(AF
.getValue())); break;
568 case 4: OW
->Write32(uint32_t(AF
.getValue())); break;
569 case 8: OW
->Write64(uint64_t(AF
.getValue())); break;
575 case MCFragment::FT_Data
: {
576 MCDataFragment
&DF
= cast
<MCDataFragment
>(F
);
577 assert(FragmentSize
== DF
.getContents().size() && "Invalid size!");
578 OW
->WriteBytes(DF
.getContents().str());
582 case MCFragment::FT_Fill
: {
583 MCFillFragment
&FF
= cast
<MCFillFragment
>(F
);
585 assert(FF
.getValueSize() && "Invalid virtual align in concrete fragment!");
587 for (uint64_t i
= 0, e
= FF
.getSize() / FF
.getValueSize(); i
!= e
; ++i
) {
588 switch (FF
.getValueSize()) {
590 assert(0 && "Invalid size!");
591 case 1: OW
->Write8 (uint8_t (FF
.getValue())); break;
592 case 2: OW
->Write16(uint16_t(FF
.getValue())); break;
593 case 4: OW
->Write32(uint32_t(FF
.getValue())); break;
594 case 8: OW
->Write64(uint64_t(FF
.getValue())); break;
600 case MCFragment::FT_Inst
:
601 llvm_unreachable("unexpected inst fragment after lowering");
604 case MCFragment::FT_Org
: {
605 MCOrgFragment
&OF
= cast
<MCOrgFragment
>(F
);
607 for (uint64_t i
= 0, e
= FragmentSize
; i
!= e
; ++i
)
608 OW
->Write8(uint8_t(OF
.getValue()));
614 assert(OW
->getStream().tell() - Start
== FragmentSize
);
617 void MCAssembler::WriteSectionData(const MCSectionData
*SD
,
618 const MCAsmLayout
&Layout
,
619 MCObjectWriter
*OW
) const {
620 // Ignore virtual sections.
621 if (getBackend().isVirtualSection(SD
->getSection())) {
622 assert(Layout
.getSectionFileSize(SD
) == 0 && "Invalid size for section!");
624 // Check that contents are only things legal inside a virtual section.
625 for (MCSectionData::const_iterator it
= SD
->begin(),
626 ie
= SD
->end(); it
!= ie
; ++it
) {
627 switch (it
->getKind()) {
629 assert(0 && "Invalid fragment in virtual section!");
630 case MCFragment::FT_Align
:
631 assert(!cast
<MCAlignFragment
>(it
)->getValueSize() &&
632 "Invalid align in virtual section!");
634 case MCFragment::FT_Fill
:
635 assert(!cast
<MCFillFragment
>(it
)->getValueSize() &&
636 "Invalid fill in virtual section!");
644 uint64_t Start
= OW
->getStream().tell();
647 for (MCSectionData::const_iterator it
= SD
->begin(),
648 ie
= SD
->end(); it
!= ie
; ++it
)
649 WriteFragmentData(*this, Layout
, *it
, OW
);
651 assert(OW
->getStream().tell() - Start
== Layout
.getSectionFileSize(SD
));
654 void MCAssembler::Finish(MCObjectWriter
*Writer
) {
655 DEBUG_WITH_TYPE("mc-dump", {
656 llvm::errs() << "assembler backend - pre-layout\n--\n";
659 // Create the layout object.
660 MCAsmLayout
Layout(*this);
662 // Insert additional align fragments for concrete sections to explicitly pad
663 // the previous section to match their alignment requirements. This is for
664 // 'gas' compatibility, it shouldn't strictly be necessary.
666 // FIXME: This may be Mach-O specific.
667 for (unsigned i
= 1, e
= Layout
.getSectionOrder().size(); i
< e
; ++i
) {
668 MCSectionData
*SD
= Layout
.getSectionOrder()[i
];
670 // Ignore sections without alignment requirements.
671 unsigned Align
= SD
->getAlignment();
675 // Ignore virtual sections, they don't cause file size modifications.
676 if (getBackend().isVirtualSection(SD
->getSection()))
679 // Otherwise, create a new align fragment at the end of the previous
681 MCAlignFragment
*AF
= new MCAlignFragment(Align
, 0, 1, Align
,
682 Layout
.getSectionOrder()[i
- 1]);
683 AF
->setOnlyAlignAddress(true);
686 // Create dummy fragments and assign section ordinals.
687 unsigned SectionIndex
= 0;
688 for (MCAssembler::iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
689 // Create dummy fragments to eliminate any empty sections, this simplifies
691 if (it
->getFragmentList().empty())
692 new MCFillFragment(0, 1, 0, it
);
694 it
->setOrdinal(SectionIndex
++);
697 // Assign layout order indices to sections and fragments.
698 unsigned FragmentIndex
= 0;
699 for (unsigned i
= 0, e
= Layout
.getSectionOrder().size(); i
!= e
; ++i
) {
700 MCSectionData
*SD
= Layout
.getSectionOrder()[i
];
701 SD
->setLayoutOrder(i
);
703 for (MCSectionData::iterator it2
= SD
->begin(),
704 ie2
= SD
->end(); it2
!= ie2
; ++it2
)
705 it2
->setLayoutOrder(FragmentIndex
++);
708 // Layout until everything fits.
709 while (LayoutOnce(Layout
))
712 DEBUG_WITH_TYPE("mc-dump", {
713 llvm::errs() << "assembler backend - post-relaxation\n--\n";
716 // Finalize the layout, including fragment lowering.
717 FinishLayout(Layout
);
719 DEBUG_WITH_TYPE("mc-dump", {
720 llvm::errs() << "assembler backend - final-layout\n--\n";
723 uint64_t StartOffset
= OS
.tell();
725 llvm::OwningPtr
<MCObjectWriter
> OwnWriter(0);
727 //no custom Writer_ : create the default one life-managed by OwningPtr
728 OwnWriter
.reset(getBackend().createObjectWriter(OS
));
729 Writer
= OwnWriter
.get();
731 report_fatal_error("unable to create object writer!");
734 // Allow the object writer a chance to perform post-layout binding (for
735 // example, to set the index fields in the symbol data).
736 Writer
->ExecutePostLayoutBinding(*this);
738 // Evaluate and apply the fixups, generating relocation entries as necessary.
739 for (MCAssembler::iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
740 for (MCSectionData::iterator it2
= it
->begin(),
741 ie2
= it
->end(); it2
!= ie2
; ++it2
) {
742 MCDataFragment
*DF
= dyn_cast
<MCDataFragment
>(it2
);
746 for (MCDataFragment::fixup_iterator it3
= DF
->fixup_begin(),
747 ie3
= DF
->fixup_end(); it3
!= ie3
; ++it3
) {
748 MCFixup
&Fixup
= *it3
;
750 // Evaluate the fixup.
753 if (!EvaluateFixup(Layout
, Fixup
, DF
, Target
, FixedValue
)) {
754 // The fixup was unresolved, we need a relocation. Inform the object
755 // writer of the relocation, and give it an opportunity to adjust the
756 // fixup value if need be.
757 Writer
->RecordRelocation(*this, Layout
, DF
, Fixup
, Target
,FixedValue
);
760 getBackend().ApplyFixup(Fixup
, *DF
, FixedValue
);
765 // Write the object file.
766 Writer
->WriteObject(*this, Layout
);
768 stats::ObjectBytes
+= OS
.tell() - StartOffset
;
771 bool MCAssembler::FixupNeedsRelaxation(const MCFixup
&Fixup
,
772 const MCFragment
*DF
,
773 const MCAsmLayout
&Layout
) const {
777 // If we cannot resolve the fixup value, it requires relaxation.
780 if (!EvaluateFixup(Layout
, Fixup
, DF
, Target
, Value
))
783 // Otherwise, relax if the value is too big for a (signed) i8.
785 // FIXME: This is target dependent!
786 return int64_t(Value
) != int64_t(int8_t(Value
));
789 bool MCAssembler::FragmentNeedsRelaxation(const MCInstFragment
*IF
,
790 const MCAsmLayout
&Layout
) const {
791 // If this inst doesn't ever need relaxation, ignore it. This occurs when we
792 // are intentionally pushing out inst fragments, or because we relaxed a
793 // previous instruction to one that doesn't need relaxation.
794 if (!getBackend().MayNeedRelaxation(IF
->getInst()))
797 for (MCInstFragment::const_fixup_iterator it
= IF
->fixup_begin(),
798 ie
= IF
->fixup_end(); it
!= ie
; ++it
)
799 if (FixupNeedsRelaxation(*it
, IF
, Layout
))
805 bool MCAssembler::LayoutOnce(MCAsmLayout
&Layout
) {
806 ++stats::RelaxationSteps
;
808 // Layout the sections in order.
811 // Scan for fragments that need relaxation.
812 bool WasRelaxed
= false;
813 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
814 MCSectionData
&SD
= *it
;
816 for (MCSectionData::iterator it2
= SD
.begin(),
817 ie2
= SD
.end(); it2
!= ie2
; ++it2
) {
818 // Check if this is an instruction fragment that needs relaxation.
819 MCInstFragment
*IF
= dyn_cast
<MCInstFragment
>(it2
);
820 if (!IF
|| !FragmentNeedsRelaxation(IF
, Layout
))
823 ++stats::RelaxedInstructions
;
825 // FIXME-PERF: We could immediately lower out instructions if we can tell
826 // they are fully resolved, to avoid retesting on later passes.
828 // Relax the fragment.
831 getBackend().RelaxInstruction(IF
->getInst(), Relaxed
);
833 // Encode the new instruction.
835 // FIXME-PERF: If it matters, we could let the target do this. It can
836 // probably do so more efficiently in many cases.
837 SmallVector
<MCFixup
, 4> Fixups
;
838 SmallString
<256> Code
;
839 raw_svector_ostream
VecOS(Code
);
840 getEmitter().EncodeInstruction(Relaxed
, VecOS
, Fixups
);
843 // Update the instruction fragment.
844 int SlideAmount
= Code
.size() - IF
->getInstSize();
845 IF
->setInst(Relaxed
);
846 IF
->getCode() = Code
;
847 IF
->getFixups().clear();
848 // FIXME: Eliminate copy.
849 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
)
850 IF
->getFixups().push_back(Fixups
[i
]);
852 // Update the layout, and remember that we relaxed.
853 Layout
.UpdateForSlide(IF
, SlideAmount
);
861 void MCAssembler::FinishLayout(MCAsmLayout
&Layout
) {
862 // Lower out any instruction fragments, to simplify the fixup application and
865 // FIXME-PERF: We don't have to do this, but the assumption is that it is
866 // cheap (we will mostly end up eliminating fragments and appending on to data
867 // fragments), so the extra complexity downstream isn't worth it. Evaluate
869 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
870 MCSectionData
&SD
= *it
;
872 for (MCSectionData::iterator it2
= SD
.begin(),
873 ie2
= SD
.end(); it2
!= ie2
; ++it2
) {
874 MCInstFragment
*IF
= dyn_cast
<MCInstFragment
>(it2
);
878 // Create a new data fragment for the instruction.
880 // FIXME-PERF: Reuse previous data fragment if possible.
881 MCDataFragment
*DF
= new MCDataFragment();
882 SD
.getFragmentList().insert(it2
, DF
);
884 // Update the data fragments layout data.
885 DF
->setParent(IF
->getParent());
886 DF
->setAtom(IF
->getAtom());
887 DF
->setLayoutOrder(IF
->getLayoutOrder());
888 Layout
.FragmentReplaced(IF
, DF
);
890 // Copy in the data and the fixups.
891 DF
->getContents().append(IF
->getCode().begin(), IF
->getCode().end());
892 for (unsigned i
= 0, e
= IF
->getFixups().size(); i
!= e
; ++i
)
893 DF
->getFixups().push_back(IF
->getFixups()[i
]);
895 // Delete the instruction fragment and update the iterator.
896 SD
.getFragmentList().erase(IF
);
906 raw_ostream
&operator<<(raw_ostream
&OS
, const MCFixup
&AF
) {
907 OS
<< "<MCFixup" << " Offset:" << AF
.getOffset()
908 << " Value:" << *AF
.getValue()
909 << " Kind:" << AF
.getKind() << ">";
915 void MCFragment::dump() {
916 raw_ostream
&OS
= llvm::errs();
920 case MCFragment::FT_Align
: OS
<< "MCAlignFragment"; break;
921 case MCFragment::FT_Data
: OS
<< "MCDataFragment"; break;
922 case MCFragment::FT_Fill
: OS
<< "MCFillFragment"; break;
923 case MCFragment::FT_Inst
: OS
<< "MCInstFragment"; break;
924 case MCFragment::FT_Org
: OS
<< "MCOrgFragment"; break;
927 OS
<< "<MCFragment " << (void*) this << " LayoutOrder:" << LayoutOrder
928 << " Offset:" << Offset
<< " EffectiveSize:" << EffectiveSize
<< ">";
931 case MCFragment::FT_Align
: {
932 const MCAlignFragment
*AF
= cast
<MCAlignFragment
>(this);
933 if (AF
->hasEmitNops())
934 OS
<< " (emit nops)";
935 if (AF
->hasOnlyAlignAddress())
936 OS
<< " (only align section)";
938 OS
<< " Alignment:" << AF
->getAlignment()
939 << " Value:" << AF
->getValue() << " ValueSize:" << AF
->getValueSize()
940 << " MaxBytesToEmit:" << AF
->getMaxBytesToEmit() << ">";
943 case MCFragment::FT_Data
: {
944 const MCDataFragment
*DF
= cast
<MCDataFragment
>(this);
947 const SmallVectorImpl
<char> &Contents
= DF
->getContents();
948 for (unsigned i
= 0, e
= Contents
.size(); i
!= e
; ++i
) {
950 OS
<< hexdigit((Contents
[i
] >> 4) & 0xF) << hexdigit(Contents
[i
] & 0xF);
952 OS
<< "] (" << Contents
.size() << " bytes)";
954 if (!DF
->getFixups().empty()) {
957 for (MCDataFragment::const_fixup_iterator it
= DF
->fixup_begin(),
958 ie
= DF
->fixup_end(); it
!= ie
; ++it
) {
959 if (it
!= DF
->fixup_begin()) OS
<< ",\n ";
966 case MCFragment::FT_Fill
: {
967 const MCFillFragment
*FF
= cast
<MCFillFragment
>(this);
968 OS
<< " Value:" << FF
->getValue() << " ValueSize:" << FF
->getValueSize()
969 << " Size:" << FF
->getSize();
972 case MCFragment::FT_Inst
: {
973 const MCInstFragment
*IF
= cast
<MCInstFragment
>(this);
976 IF
->getInst().dump_pretty(OS
);
979 case MCFragment::FT_Org
: {
980 const MCOrgFragment
*OF
= cast
<MCOrgFragment
>(this);
982 OS
<< " Offset:" << OF
->getOffset() << " Value:" << OF
->getValue();
989 void MCSectionData::dump() {
990 raw_ostream
&OS
= llvm::errs();
992 OS
<< "<MCSectionData";
993 OS
<< " Alignment:" << getAlignment() << " Address:" << Address
994 << " Fragments:[\n ";
995 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
996 if (it
!= begin()) OS
<< ",\n ";
1002 void MCSymbolData::dump() {
1003 raw_ostream
&OS
= llvm::errs();
1005 OS
<< "<MCSymbolData Symbol:" << getSymbol()
1006 << " Fragment:" << getFragment() << " Offset:" << getOffset()
1007 << " Flags:" << getFlags() << " Index:" << getIndex();
1009 OS
<< " (common, size:" << getCommonSize()
1010 << " align: " << getCommonAlignment() << ")";
1012 OS
<< " (external)";
1013 if (isPrivateExtern())
1014 OS
<< " (private extern)";
1018 void MCAssembler::dump() {
1019 raw_ostream
&OS
= llvm::errs();
1021 OS
<< "<MCAssembler\n";
1022 OS
<< " Sections:[\n ";
1023 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
1024 if (it
!= begin()) OS
<< ",\n ";
1030 for (symbol_iterator it
= symbol_begin(), ie
= symbol_end(); it
!= ie
; ++it
) {
1031 if (it
!= symbol_begin()) OS
<< ",\n ";