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 void MCAsmLayout::FragmentReplaced(MCFragment
*Src
, MCFragment
*Dst
) {
77 Dst
->Offset
= Src
->Offset
;
78 Dst
->EffectiveSize
= Src
->EffectiveSize
;
81 uint64_t MCAsmLayout::getFragmentAddress(const MCFragment
*F
) const {
82 assert(F
->getParent() && "Missing section()!");
83 return getSectionAddress(F
->getParent()) + getFragmentOffset(F
);
86 uint64_t MCAsmLayout::getFragmentEffectiveSize(const MCFragment
*F
) const {
87 assert(F
->EffectiveSize
!= ~UINT64_C(0) && "Address not set!");
88 return F
->EffectiveSize
;
91 void MCAsmLayout::setFragmentEffectiveSize(MCFragment
*F
, uint64_t Value
) {
92 F
->EffectiveSize
= Value
;
95 uint64_t MCAsmLayout::getFragmentOffset(const MCFragment
*F
) const {
96 assert(F
->Offset
!= ~UINT64_C(0) && "Address not set!");
100 void MCAsmLayout::setFragmentOffset(MCFragment
*F
, uint64_t Value
) {
104 uint64_t MCAsmLayout::getSymbolAddress(const MCSymbolData
*SD
) const {
105 assert(SD
->getFragment() && "Invalid getAddress() on undefined symbol!");
106 return getFragmentAddress(SD
->getFragment()) + SD
->getOffset();
109 uint64_t MCAsmLayout::getSectionAddress(const MCSectionData
*SD
) const {
110 assert(SD
->Address
!= ~UINT64_C(0) && "Address not set!");
114 void MCAsmLayout::setSectionAddress(MCSectionData
*SD
, uint64_t Value
) {
118 uint64_t MCAsmLayout::getSectionAddressSize(const MCSectionData
*SD
) const {
119 // Otherwise, the size is the last fragment's end offset.
120 const MCFragment
&F
= SD
->getFragmentList().back();
121 return getFragmentOffset(&F
) + getFragmentEffectiveSize(&F
);
124 uint64_t MCAsmLayout::getSectionFileSize(const MCSectionData
*SD
) const {
125 // Virtual sections have no file size.
126 if (getAssembler().getBackend().isVirtualSection(SD
->getSection()))
129 // Otherwise, the file size is the same as the address space size.
130 return getSectionAddressSize(SD
);
133 uint64_t MCAsmLayout::getSectionSize(const MCSectionData
*SD
) const {
134 // The logical size is the address space size minus any tail padding.
135 uint64_t Size
= getSectionAddressSize(SD
);
136 const MCAlignFragment
*AF
=
137 dyn_cast
<MCAlignFragment
>(&(SD
->getFragmentList().back()));
138 if (AF
&& AF
->hasOnlyAlignAddress())
139 Size
-= getFragmentEffectiveSize(AF
);
146 MCFragment::MCFragment() : Kind(FragmentType(~0)) {
149 MCFragment::MCFragment(FragmentType _Kind
, MCSectionData
*_Parent
)
150 : Kind(_Kind
), Parent(_Parent
), Atom(0), EffectiveSize(~UINT64_C(0))
153 Parent
->getFragmentList().push_back(this);
156 MCFragment::~MCFragment() {
161 MCSectionData::MCSectionData() : Section(0) {}
163 MCSectionData::MCSectionData(const MCSection
&_Section
, MCAssembler
*A
)
164 : Section(&_Section
),
166 Address(~UINT64_C(0)),
167 HasInstructions(false)
170 A
->getSectionList().push_back(this);
175 MCSymbolData::MCSymbolData() : Symbol(0) {}
177 MCSymbolData::MCSymbolData(const MCSymbol
&_Symbol
, MCFragment
*_Fragment
,
178 uint64_t _Offset
, MCAssembler
*A
)
179 : Symbol(&_Symbol
), Fragment(_Fragment
), Offset(_Offset
),
180 IsExternal(false), IsPrivateExtern(false),
181 CommonSize(0), CommonAlign(0), Flags(0), Index(0)
184 A
->getSymbolList().push_back(this);
189 MCAssembler::MCAssembler(MCContext
&_Context
, TargetAsmBackend
&_Backend
,
190 MCCodeEmitter
&_Emitter
, raw_ostream
&_OS
)
191 : Context(_Context
), Backend(_Backend
), Emitter(_Emitter
),
192 OS(_OS
), RelaxAll(false), SubsectionsViaSymbols(false)
196 MCAssembler::~MCAssembler() {
199 static bool isScatteredFixupFullyResolvedSimple(const MCAssembler
&Asm
,
200 const MCAsmFixup
&Fixup
,
201 const MCValue Target
,
202 const MCSection
*BaseSection
) {
203 // The effective fixup address is
204 // addr(atom(A)) + offset(A)
205 // - addr(atom(B)) - offset(B)
206 // - addr(<base symbol>) + <fixup offset from base symbol>
207 // and the offsets are not relocatable, so the fixup is fully resolved when
208 // addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0.
210 // The simple (Darwin, except on x86_64) way of dealing with this was to
211 // assume that any reference to a temporary symbol *must* be a temporary
212 // symbol in the same atom, unless the sections differ. Therefore, any PCrel
213 // relocation to a temporary symbol (in the same section) is fully
214 // resolved. This also works in conjunction with absolutized .set, which
215 // requires the compiler to use .set to absolutize the differences between
216 // symbols which the compiler knows to be assembly time constants, so we don't
217 // need to worry about considering symbol differences fully resolved.
219 // Non-relative fixups are only resolved if constant.
221 return Target
.isAbsolute();
223 // Otherwise, relative fixups are only resolved if not a difference and the
224 // target is a temporary in the same section.
225 if (Target
.isAbsolute() || Target
.getSymB())
228 const MCSymbol
*A
= &Target
.getSymA()->getSymbol();
229 if (!A
->isTemporary() || !A
->isInSection() ||
230 &A
->getSection() != BaseSection
)
236 static bool isScatteredFixupFullyResolved(const MCAssembler
&Asm
,
237 const MCAsmLayout
&Layout
,
238 const MCAsmFixup
&Fixup
,
239 const MCValue Target
,
240 const MCSymbolData
*BaseSymbol
) {
241 // The effective fixup address is
242 // addr(atom(A)) + offset(A)
243 // - addr(atom(B)) - offset(B)
244 // - addr(BaseSymbol) + <fixup offset from base symbol>
245 // and the offsets are not relocatable, so the fixup is fully resolved when
246 // addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0.
248 // Note that "false" is almost always conservatively correct (it means we emit
249 // a relocation which is unnecessary), except when it would force us to emit a
250 // relocation which the target cannot encode.
252 const MCSymbolData
*A_Base
= 0, *B_Base
= 0;
253 if (const MCSymbolRefExpr
*A
= Target
.getSymA()) {
254 // Modified symbol references cannot be resolved.
255 if (A
->getKind() != MCSymbolRefExpr::VK_None
)
258 A_Base
= Asm
.getAtom(Layout
, &Asm
.getSymbolData(A
->getSymbol()));
263 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
264 // Modified symbol references cannot be resolved.
265 if (B
->getKind() != MCSymbolRefExpr::VK_None
)
268 B_Base
= Asm
.getAtom(Layout
, &Asm
.getSymbolData(B
->getSymbol()));
273 // If there is no base, A and B have to be the same atom for this fixup to be
276 return A_Base
== B_Base
;
278 // Otherwise, B must be missing and A must be the base.
279 return !B_Base
&& BaseSymbol
== A_Base
;
282 bool MCAssembler::isSymbolLinkerVisible(const MCSymbolData
*SD
) const {
283 // Non-temporary labels should always be visible to the linker.
284 if (!SD
->getSymbol().isTemporary())
287 // Absolute temporary labels are never visible.
288 if (!SD
->getFragment())
291 // Otherwise, check if the section requires symbols even for temporary labels.
292 return getBackend().doesSectionRequireSymbols(
293 SD
->getFragment()->getParent()->getSection());
296 const MCSymbolData
*MCAssembler::getAtom(const MCAsmLayout
&Layout
,
297 const MCSymbolData
*SD
) const {
298 // Linker visible symbols define atoms.
299 if (isSymbolLinkerVisible(SD
))
302 // Absolute and undefined symbols have no defining atom.
303 if (!SD
->getFragment())
306 // Non-linker visible symbols in sections which can't be atomized have no
308 if (!getBackend().isSectionAtomizable(
309 SD
->getFragment()->getParent()->getSection()))
312 // Otherwise, return the atom for the containing fragment.
313 return SD
->getFragment()->getAtom();
316 bool MCAssembler::EvaluateFixup(const MCAsmLayout
&Layout
,
317 const MCAsmFixup
&Fixup
, const MCFragment
*DF
,
318 MCValue
&Target
, uint64_t &Value
) const {
319 ++stats::EvaluateFixup
;
321 if (!Fixup
.Value
->EvaluateAsRelocatable(Target
, &Layout
))
322 report_fatal_error("expected relocatable expression");
324 // FIXME: How do non-scattered symbols work in ELF? I presume the linker
325 // doesn't support small relocations, but then under what criteria does the
326 // assembler allow symbol differences?
328 Value
= Target
.getConstant();
331 Emitter
.getFixupKindInfo(Fixup
.Kind
).Flags
& MCFixupKindInfo::FKF_IsPCRel
;
332 bool IsResolved
= true;
333 if (const MCSymbolRefExpr
*A
= Target
.getSymA()) {
334 if (A
->getSymbol().isDefined())
335 Value
+= Layout
.getSymbolAddress(&getSymbolData(A
->getSymbol()));
339 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
340 if (B
->getSymbol().isDefined())
341 Value
-= Layout
.getSymbolAddress(&getSymbolData(B
->getSymbol()));
346 // If we are using scattered symbols, determine whether this value is actually
347 // resolved; scattering may cause atoms to move.
348 if (IsResolved
&& getBackend().hasScatteredSymbols()) {
349 if (getBackend().hasReliableSymbolDifference()) {
350 // If this is a PCrel relocation, find the base atom (identified by its
351 // symbol) that the fixup value is relative to.
352 const MCSymbolData
*BaseSymbol
= 0;
354 BaseSymbol
= DF
->getAtom();
360 IsResolved
= isScatteredFixupFullyResolved(*this, Layout
, Fixup
, Target
,
363 const MCSection
*BaseSection
= 0;
365 BaseSection
= &DF
->getParent()->getSection();
367 IsResolved
= isScatteredFixupFullyResolvedSimple(*this, Fixup
, Target
,
373 Value
-= Layout
.getFragmentAddress(DF
) + Fixup
.Offset
;
378 void MCAssembler::LayoutFragment(MCAsmLayout
&Layout
, MCFragment
&F
) {
379 uint64_t StartAddress
= Layout
.getSectionAddress(F
.getParent());
381 // Get the fragment start address.
382 uint64_t Address
= StartAddress
;
383 MCSectionData::iterator it
= &F
;
384 if (MCFragment
*Prev
= F
.getPrevNode())
385 Address
= (StartAddress
+ Layout
.getFragmentOffset(Prev
) +
386 Layout
.getFragmentEffectiveSize(Prev
));
388 ++stats::FragmentLayouts
;
390 uint64_t FragmentOffset
= Address
- StartAddress
;
391 Layout
.setFragmentOffset(&F
, FragmentOffset
);
393 // Evaluate fragment size.
394 uint64_t EffectiveSize
= 0;
395 switch (F
.getKind()) {
396 case MCFragment::FT_Align
: {
397 MCAlignFragment
&AF
= cast
<MCAlignFragment
>(F
);
399 assert((!AF
.hasOnlyAlignAddress() || !AF
.getNextNode()) &&
400 "Invalid OnlyAlignAddress bit, not the last fragment!");
402 EffectiveSize
= OffsetToAlignment(Address
, AF
.getAlignment());
403 if (EffectiveSize
> AF
.getMaxBytesToEmit())
408 case MCFragment::FT_Data
:
409 EffectiveSize
= cast
<MCDataFragment
>(F
).getContents().size();
412 case MCFragment::FT_Fill
: {
413 EffectiveSize
= cast
<MCFillFragment
>(F
).getSize();
417 case MCFragment::FT_Inst
:
418 EffectiveSize
= cast
<MCInstFragment
>(F
).getInstSize();
421 case MCFragment::FT_Org
: {
422 MCOrgFragment
&OF
= cast
<MCOrgFragment
>(F
);
424 int64_t TargetLocation
;
425 if (!OF
.getOffset().EvaluateAsAbsolute(TargetLocation
, &Layout
))
426 report_fatal_error("expected assembly-time absolute expression");
428 // FIXME: We need a way to communicate this error.
429 int64_t Offset
= TargetLocation
- FragmentOffset
;
431 report_fatal_error("invalid .org offset '" + Twine(TargetLocation
) +
432 "' (at offset '" + Twine(FragmentOffset
) + "'");
434 EffectiveSize
= Offset
;
439 Layout
.setFragmentEffectiveSize(&F
, EffectiveSize
);
442 void MCAssembler::LayoutSection(MCAsmLayout
&Layout
,
443 unsigned SectionOrderIndex
) {
444 MCSectionData
&SD
= *Layout
.getSectionOrder()[SectionOrderIndex
];
446 ++stats::SectionLayouts
;
448 // Compute the section start address.
449 uint64_t StartAddress
= 0;
450 if (SectionOrderIndex
) {
451 MCSectionData
*Prev
= Layout
.getSectionOrder()[SectionOrderIndex
- 1];
452 StartAddress
= (Layout
.getSectionAddress(Prev
) +
453 Layout
.getSectionAddressSize(Prev
));
456 // Honor the section alignment requirements.
457 StartAddress
= RoundUpToAlignment(StartAddress
, SD
.getAlignment());
459 // Set the section address.
460 Layout
.setSectionAddress(&SD
, StartAddress
);
462 for (MCSectionData::iterator it
= SD
.begin(), ie
= SD
.end(); it
!= ie
; ++it
)
463 LayoutFragment(Layout
, *it
);
466 /// WriteFragmentData - Write the \arg F data to the output file.
467 static void WriteFragmentData(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
,
468 const MCFragment
&F
, MCObjectWriter
*OW
) {
469 uint64_t Start
= OW
->getStream().tell();
472 ++stats::EmittedFragments
;
474 // FIXME: Embed in fragments instead?
475 uint64_t FragmentSize
= Layout
.getFragmentEffectiveSize(&F
);
476 switch (F
.getKind()) {
477 case MCFragment::FT_Align
: {
478 MCAlignFragment
&AF
= cast
<MCAlignFragment
>(F
);
479 uint64_t Count
= FragmentSize
/ AF
.getValueSize();
481 assert(AF
.getValueSize() && "Invalid virtual align in concrete fragment!");
483 // FIXME: This error shouldn't actually occur (the front end should emit
484 // multiple .align directives to enforce the semantics it wants), but is
485 // severe enough that we want to report it. How to handle this?
486 if (Count
* AF
.getValueSize() != FragmentSize
)
487 report_fatal_error("undefined .align directive, value size '" +
488 Twine(AF
.getValueSize()) +
489 "' is not a divisor of padding size '" +
490 Twine(FragmentSize
) + "'");
492 // See if we are aligning with nops, and if so do that first to try to fill
493 // the Count bytes. Then if that did not fill any bytes or there are any
494 // bytes left to fill use the the Value and ValueSize to fill the rest.
495 // If we are aligning with nops, ask that target to emit the right data.
496 if (AF
.hasEmitNops()) {
497 if (!Asm
.getBackend().WriteNopData(Count
, OW
))
498 report_fatal_error("unable to write nop sequence of " +
499 Twine(Count
) + " bytes");
503 // Otherwise, write out in multiples of the value size.
504 for (uint64_t i
= 0; i
!= Count
; ++i
) {
505 switch (AF
.getValueSize()) {
507 assert(0 && "Invalid size!");
508 case 1: OW
->Write8 (uint8_t (AF
.getValue())); break;
509 case 2: OW
->Write16(uint16_t(AF
.getValue())); break;
510 case 4: OW
->Write32(uint32_t(AF
.getValue())); break;
511 case 8: OW
->Write64(uint64_t(AF
.getValue())); break;
517 case MCFragment::FT_Data
: {
518 MCDataFragment
&DF
= cast
<MCDataFragment
>(F
);
519 assert(FragmentSize
== DF
.getContents().size() && "Invalid size!");
520 OW
->WriteBytes(DF
.getContents().str());
524 case MCFragment::FT_Fill
: {
525 MCFillFragment
&FF
= cast
<MCFillFragment
>(F
);
527 assert(FF
.getValueSize() && "Invalid virtual align in concrete fragment!");
529 for (uint64_t i
= 0, e
= FF
.getSize() / FF
.getValueSize(); i
!= e
; ++i
) {
530 switch (FF
.getValueSize()) {
532 assert(0 && "Invalid size!");
533 case 1: OW
->Write8 (uint8_t (FF
.getValue())); break;
534 case 2: OW
->Write16(uint16_t(FF
.getValue())); break;
535 case 4: OW
->Write32(uint32_t(FF
.getValue())); break;
536 case 8: OW
->Write64(uint64_t(FF
.getValue())); break;
542 case MCFragment::FT_Inst
:
543 llvm_unreachable("unexpected inst fragment after lowering");
546 case MCFragment::FT_Org
: {
547 MCOrgFragment
&OF
= cast
<MCOrgFragment
>(F
);
549 for (uint64_t i
= 0, e
= FragmentSize
; i
!= e
; ++i
)
550 OW
->Write8(uint8_t(OF
.getValue()));
556 assert(OW
->getStream().tell() - Start
== FragmentSize
);
559 void MCAssembler::WriteSectionData(const MCSectionData
*SD
,
560 const MCAsmLayout
&Layout
,
561 MCObjectWriter
*OW
) const {
562 // Ignore virtual sections.
563 if (getBackend().isVirtualSection(SD
->getSection())) {
564 assert(Layout
.getSectionFileSize(SD
) == 0 && "Invalid size for section!");
566 // Check that contents are only things legal inside a virtual section.
567 for (MCSectionData::const_iterator it
= SD
->begin(),
568 ie
= SD
->end(); it
!= ie
; ++it
) {
569 switch (it
->getKind()) {
571 assert(0 && "Invalid fragment in virtual section!");
572 case MCFragment::FT_Align
:
573 assert(!cast
<MCAlignFragment
>(it
)->getValueSize() &&
574 "Invalid align in virtual section!");
576 case MCFragment::FT_Fill
:
577 assert(!cast
<MCFillFragment
>(it
)->getValueSize() &&
578 "Invalid fill in virtual section!");
586 uint64_t Start
= OW
->getStream().tell();
589 for (MCSectionData::const_iterator it
= SD
->begin(),
590 ie
= SD
->end(); it
!= ie
; ++it
)
591 WriteFragmentData(*this, Layout
, *it
, OW
);
593 assert(OW
->getStream().tell() - Start
== Layout
.getSectionFileSize(SD
));
596 void MCAssembler::Finish() {
597 DEBUG_WITH_TYPE("mc-dump", {
598 llvm::errs() << "assembler backend - pre-layout\n--\n";
601 // Create the layout object.
602 MCAsmLayout
Layout(*this);
604 // Assign layout order indices.
605 for (unsigned i
= 0, e
= Layout
.getSectionOrder().size(); i
!= e
; ++i
)
606 Layout
.getSectionOrder()[i
]->setLayoutOrder(i
);
608 // Insert additional align fragments for concrete sections to explicitly pad
609 // the previous section to match their alignment requirements. This is for
610 // 'gas' compatibility, it shouldn't strictly be necessary.
612 // FIXME: This may be Mach-O specific.
613 for (unsigned i
= 1, e
= Layout
.getSectionOrder().size(); i
< e
; ++i
) {
614 MCSectionData
*SD
= Layout
.getSectionOrder()[i
];
616 // Ignore sections without alignment requirements.
617 unsigned Align
= SD
->getAlignment();
621 // Ignore virtual sections, they don't cause file size modifications.
622 if (getBackend().isVirtualSection(SD
->getSection()))
625 // Otherwise, create a new align fragment at the end of the previous
627 MCAlignFragment
*AF
= new MCAlignFragment(Align
, 0, 1, Align
,
628 Layout
.getSectionOrder()[i
- 1]);
629 AF
->setOnlyAlignAddress(true);
632 // Assign section and fragment ordinals, all subsequent backend code is
633 // responsible for updating these in place.
634 unsigned SectionIndex
= 0;
635 unsigned FragmentIndex
= 0;
636 for (MCAssembler::iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
637 // Create dummy fragments to eliminate any empty sections, this simplifies
639 if (it
->getFragmentList().empty()) {
640 unsigned ValueSize
= 1;
641 if (getBackend().isVirtualSection(it
->getSection()))
643 new MCFillFragment(0, 1, 0, it
);
646 it
->setOrdinal(SectionIndex
++);
648 for (MCSectionData::iterator it2
= it
->begin(),
649 ie2
= it
->end(); it2
!= ie2
; ++it2
)
650 it2
->setOrdinal(FragmentIndex
++);
653 // Layout until everything fits.
654 while (LayoutOnce(Layout
))
657 DEBUG_WITH_TYPE("mc-dump", {
658 llvm::errs() << "assembler backend - post-relaxation\n--\n";
661 // Finalize the layout, including fragment lowering.
662 FinishLayout(Layout
);
664 DEBUG_WITH_TYPE("mc-dump", {
665 llvm::errs() << "assembler backend - final-layout\n--\n";
668 uint64_t StartOffset
= OS
.tell();
669 llvm::OwningPtr
<MCObjectWriter
> Writer(getBackend().createObjectWriter(OS
));
671 report_fatal_error("unable to create object writer!");
673 // Allow the object writer a chance to perform post-layout binding (for
674 // example, to set the index fields in the symbol data).
675 Writer
->ExecutePostLayoutBinding(*this);
677 // Evaluate and apply the fixups, generating relocation entries as necessary.
678 for (MCAssembler::iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
679 for (MCSectionData::iterator it2
= it
->begin(),
680 ie2
= it
->end(); it2
!= ie2
; ++it2
) {
681 MCDataFragment
*DF
= dyn_cast
<MCDataFragment
>(it2
);
685 for (MCDataFragment::fixup_iterator it3
= DF
->fixup_begin(),
686 ie3
= DF
->fixup_end(); it3
!= ie3
; ++it3
) {
687 MCAsmFixup
&Fixup
= *it3
;
689 // Evaluate the fixup.
692 if (!EvaluateFixup(Layout
, Fixup
, DF
, Target
, FixedValue
)) {
693 // The fixup was unresolved, we need a relocation. Inform the object
694 // writer of the relocation, and give it an opportunity to adjust the
695 // fixup value if need be.
696 Writer
->RecordRelocation(*this, Layout
, DF
, Fixup
, Target
,FixedValue
);
699 getBackend().ApplyFixup(Fixup
, *DF
, FixedValue
);
704 // Write the object file.
705 Writer
->WriteObject(*this, Layout
);
708 stats::ObjectBytes
+= OS
.tell() - StartOffset
;
711 bool MCAssembler::FixupNeedsRelaxation(const MCAsmFixup
&Fixup
,
712 const MCFragment
*DF
,
713 const MCAsmLayout
&Layout
) const {
717 // If we cannot resolve the fixup value, it requires relaxation.
720 if (!EvaluateFixup(Layout
, Fixup
, DF
, Target
, Value
))
723 // Otherwise, relax if the value is too big for a (signed) i8.
725 // FIXME: This is target dependent!
726 return int64_t(Value
) != int64_t(int8_t(Value
));
729 bool MCAssembler::FragmentNeedsRelaxation(const MCInstFragment
*IF
,
730 const MCAsmLayout
&Layout
) const {
731 // If this inst doesn't ever need relaxation, ignore it. This occurs when we
732 // are intentionally pushing out inst fragments, or because we relaxed a
733 // previous instruction to one that doesn't need relaxation.
734 if (!getBackend().MayNeedRelaxation(IF
->getInst(), IF
->getFixups()))
737 for (MCInstFragment::const_fixup_iterator it
= IF
->fixup_begin(),
738 ie
= IF
->fixup_end(); it
!= ie
; ++it
)
739 if (FixupNeedsRelaxation(*it
, IF
, Layout
))
745 bool MCAssembler::LayoutOnce(MCAsmLayout
&Layout
) {
746 ++stats::RelaxationSteps
;
748 // Layout the sections in order.
749 for (unsigned i
= 0, e
= Layout
.getSectionOrder().size(); i
!= e
; ++i
)
750 LayoutSection(Layout
, i
);
752 // Scan for fragments that need relaxation.
753 bool WasRelaxed
= false;
754 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
755 MCSectionData
&SD
= *it
;
757 for (MCSectionData::iterator it2
= SD
.begin(),
758 ie2
= SD
.end(); it2
!= ie2
; ++it2
) {
759 // Check if this is an instruction fragment that needs relaxation.
760 MCInstFragment
*IF
= dyn_cast
<MCInstFragment
>(it2
);
761 if (!IF
|| !FragmentNeedsRelaxation(IF
, Layout
))
764 ++stats::RelaxedInstructions
;
766 // FIXME-PERF: We could immediately lower out instructions if we can tell
767 // they are fully resolved, to avoid retesting on later passes.
769 // Relax the fragment.
772 getBackend().RelaxInstruction(IF
, Relaxed
);
774 // Encode the new instruction.
776 // FIXME-PERF: If it matters, we could let the target do this. It can
777 // probably do so more efficiently in many cases.
778 SmallVector
<MCFixup
, 4> Fixups
;
779 SmallString
<256> Code
;
780 raw_svector_ostream
VecOS(Code
);
781 getEmitter().EncodeInstruction(Relaxed
, VecOS
, Fixups
);
784 // Update the instruction fragment.
785 int SlideAmount
= Code
.size() - IF
->getInstSize();
786 IF
->setInst(Relaxed
);
787 IF
->getCode() = Code
;
788 IF
->getFixups().clear();
789 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
) {
790 MCFixup
&F
= Fixups
[i
];
791 IF
->getFixups().push_back(MCAsmFixup(F
.getOffset(), *F
.getValue(),
795 // Update the layout, and remember that we relaxed. If we are relaxing
796 // everything, we can skip this step since nothing will depend on updating
799 Layout
.UpdateForSlide(IF
, SlideAmount
);
807 void MCAssembler::FinishLayout(MCAsmLayout
&Layout
) {
808 // Lower out any instruction fragments, to simplify the fixup application and
811 // FIXME-PERF: We don't have to do this, but the assumption is that it is
812 // cheap (we will mostly end up eliminating fragments and appending on to data
813 // fragments), so the extra complexity downstream isn't worth it. Evaluate
815 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
816 MCSectionData
&SD
= *it
;
818 for (MCSectionData::iterator it2
= SD
.begin(),
819 ie2
= SD
.end(); it2
!= ie2
; ++it2
) {
820 MCInstFragment
*IF
= dyn_cast
<MCInstFragment
>(it2
);
824 // Create a new data fragment for the instruction.
826 // FIXME-PERF: Reuse previous data fragment if possible.
827 MCDataFragment
*DF
= new MCDataFragment();
828 SD
.getFragmentList().insert(it2
, DF
);
830 // Update the data fragments layout data.
831 DF
->setParent(IF
->getParent());
832 DF
->setAtom(IF
->getAtom());
833 DF
->setOrdinal(IF
->getOrdinal());
834 Layout
.FragmentReplaced(IF
, DF
);
836 // Copy in the data and the fixups.
837 DF
->getContents().append(IF
->getCode().begin(), IF
->getCode().end());
838 for (unsigned i
= 0, e
= IF
->getFixups().size(); i
!= e
; ++i
)
839 DF
->getFixups().push_back(IF
->getFixups()[i
]);
841 // Delete the instruction fragment and update the iterator.
842 SD
.getFragmentList().erase(IF
);
852 raw_ostream
&operator<<(raw_ostream
&OS
, const MCAsmFixup
&AF
) {
853 OS
<< "<MCAsmFixup" << " Offset:" << AF
.Offset
<< " Value:" << *AF
.Value
854 << " Kind:" << AF
.Kind
<< ">";
860 void MCFragment::dump() {
861 raw_ostream
&OS
= llvm::errs();
863 OS
<< "<MCFragment " << (void*) this << " Offset:" << Offset
864 << " EffectiveSize:" << EffectiveSize
<< ">";
867 void MCAlignFragment::dump() {
868 raw_ostream
&OS
= llvm::errs();
870 OS
<< "<MCAlignFragment ";
871 this->MCFragment::dump();
873 OS
<< " (emit nops)";
874 if (hasOnlyAlignAddress())
875 OS
<< " (only align section)";
877 OS
<< " Alignment:" << getAlignment()
878 << " Value:" << getValue() << " ValueSize:" << getValueSize()
879 << " MaxBytesToEmit:" << getMaxBytesToEmit() << ">";
882 void MCDataFragment::dump() {
883 raw_ostream
&OS
= llvm::errs();
885 OS
<< "<MCDataFragment ";
886 this->MCFragment::dump();
889 for (unsigned i
= 0, e
= getContents().size(); i
!= e
; ++i
) {
891 OS
<< hexdigit((Contents
[i
] >> 4) & 0xF) << hexdigit(Contents
[i
] & 0xF);
893 OS
<< "] (" << getContents().size() << " bytes)";
895 if (!getFixups().empty()) {
898 for (fixup_iterator it
= fixup_begin(), ie
= fixup_end(); it
!= ie
; ++it
) {
899 if (it
!= fixup_begin()) OS
<< ",\n ";
908 void MCFillFragment::dump() {
909 raw_ostream
&OS
= llvm::errs();
911 OS
<< "<MCFillFragment ";
912 this->MCFragment::dump();
914 OS
<< " Value:" << getValue() << " ValueSize:" << getValueSize()
915 << " Size:" << getSize() << ">";
918 void MCInstFragment::dump() {
919 raw_ostream
&OS
= llvm::errs();
921 OS
<< "<MCInstFragment ";
922 this->MCFragment::dump();
925 getInst().dump_pretty(OS
);
929 void MCOrgFragment::dump() {
930 raw_ostream
&OS
= llvm::errs();
932 OS
<< "<MCOrgFragment ";
933 this->MCFragment::dump();
935 OS
<< " Offset:" << getOffset() << " Value:" << getValue() << ">";
938 void MCSectionData::dump() {
939 raw_ostream
&OS
= llvm::errs();
941 OS
<< "<MCSectionData";
942 OS
<< " Alignment:" << getAlignment() << " Address:" << Address
943 << " Fragments:[\n ";
944 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
945 if (it
!= begin()) OS
<< ",\n ";
951 void MCSymbolData::dump() {
952 raw_ostream
&OS
= llvm::errs();
954 OS
<< "<MCSymbolData Symbol:" << getSymbol()
955 << " Fragment:" << getFragment() << " Offset:" << getOffset()
956 << " Flags:" << getFlags() << " Index:" << getIndex();
958 OS
<< " (common, size:" << getCommonSize()
959 << " align: " << getCommonAlignment() << ")";
962 if (isPrivateExtern())
963 OS
<< " (private extern)";
967 void MCAssembler::dump() {
968 raw_ostream
&OS
= llvm::errs();
970 OS
<< "<MCAssembler\n";
971 OS
<< " Sections:[\n ";
972 for (iterator it
= begin(), ie
= end(); it
!= ie
; ++it
) {
973 if (it
!= begin()) OS
<< ",\n ";
979 for (symbol_iterator it
= symbol_begin(), ie
= symbol_end(); it
!= ie
; ++it
) {
980 if (it
!= symbol_begin()) OS
<< ",\n ";