blob: 9cd0a12c12639a833cdbf5086b43e6d9e41d36d2 [file] [log] [blame]
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +00001//===- 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
Daniel Dunbar0adcd352009-08-25 21:10:45 +000010#define DEBUG_TYPE "assembler"
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000011#include "llvm/MC/MCAssembler.h"
Daniel Dunbar18ff2cc2010-03-11 05:53:33 +000012#include "llvm/MC/MCAsmLayout.h"
Daniel Dunbarb36052f2010-03-19 10:43:23 +000013#include "llvm/MC/MCCodeEmitter.h"
Daniel Dunbar1253a6f2009-10-16 01:58:03 +000014#include "llvm/MC/MCExpr.h"
Daniel Dunbar53b23382010-03-19 09:28:59 +000015#include "llvm/MC/MCObjectWriter.h"
Kevin Enderbyc0957932010-09-30 16:52:03 +000016#include "llvm/MC/MCSection.h"
Daniel Dunbar1253a6f2009-10-16 01:58:03 +000017#include "llvm/MC/MCSymbol.h"
18#include "llvm/MC/MCValue.h"
Kevin Enderbyc0957932010-09-30 16:52:03 +000019#include "llvm/MC/MCDwarf.h"
Daniel Dunbar1a9158c2010-03-19 10:43:26 +000020#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar0adcd352009-08-25 21:10:45 +000021#include "llvm/ADT/Statistic.h"
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +000022#include "llvm/ADT/StringExtras.h"
Daniel Dunbard6f761e2009-08-21 23:07:38 +000023#include "llvm/ADT/Twine.h"
Daniel Dunbarac2884a2010-03-25 22:49:09 +000024#include "llvm/Support/Debug.h"
Daniel Dunbar0705fbf2009-08-21 18:29:01 +000025#include "llvm/Support/ErrorHandling.h"
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000026#include "llvm/Support/raw_ostream.h"
Daniel Dunbaree0d8922010-03-13 22:10:17 +000027#include "llvm/Target/TargetRegistry.h"
Daniel Dunbardf3c8f22010-03-12 21:00:49 +000028#include "llvm/Target/TargetAsmBackend.h"
Daniel Dunbarf6346762010-02-13 09:29:02 +000029
Chris Lattner23132b12009-08-24 03:52:50 +000030#include <vector>
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000031using namespace llvm;
32
Daniel Dunbarff547842010-03-23 23:47:14 +000033namespace {
34namespace stats {
Daniel Dunbar0adcd352009-08-25 21:10:45 +000035STATISTIC(EmittedFragments, "Number of emitted assembler fragments");
Daniel Dunbarff547842010-03-23 23:47:14 +000036STATISTIC(EvaluateFixup, "Number of evaluated fixups");
Daniel Dunbarac2884a2010-03-25 22:49:09 +000037STATISTIC(FragmentLayouts, "Number of fragment layouts");
Daniel Dunbarff547842010-03-23 23:47:14 +000038STATISTIC(ObjectBytes, "Number of emitted object file bytes");
Daniel Dunbarac2884a2010-03-25 22:49:09 +000039STATISTIC(RelaxationSteps, "Number of assembler layout and relaxation steps");
40STATISTIC(RelaxedInstructions, "Number of relaxed instructions");
41STATISTIC(SectionLayouts, "Number of section layouts");
Daniel Dunbarff547842010-03-23 23:47:14 +000042}
43}
Daniel Dunbar0adcd352009-08-25 21:10:45 +000044
Daniel Dunbar8f4d1462009-08-28 07:08:35 +000045// FIXME FIXME FIXME: There are number of places in this file where we convert
46// what is a 64-bit assembler value used for computation into a value in the
47// object file, which may truncate it. We should detect that truncation where
48// invalid and report errors back.
49
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000050/* *** */
51
Daniel Dunbar9005d452010-05-14 00:37:21 +000052MCAsmLayout::MCAsmLayout(MCAssembler &Asm)
53 : Assembler(Asm), LastValidFragment(0)
54 {
Daniel Dunbarbc1a0cf2010-05-12 15:42:59 +000055 // Compute the section layout order. Virtual sections must go last.
56 for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it)
57 if (!Asm.getBackend().isVirtualSection(it->getSection()))
58 SectionOrder.push_back(&*it);
59 for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it)
60 if (Asm.getBackend().isVirtualSection(it->getSection()))
61 SectionOrder.push_back(&*it);
62}
63
Daniel Dunbar9005d452010-05-14 00:37:21 +000064bool MCAsmLayout::isSectionUpToDate(const MCSectionData *SD) const {
65 // The first section is always up-to-date.
66 unsigned Index = SD->getLayoutOrder();
67 if (!Index)
68 return true;
69
70 // Otherwise, sections are always implicitly computed when the preceeding
71 // fragment is layed out.
72 const MCSectionData *Prev = getSectionOrder()[Index - 1];
73 return isFragmentUpToDate(&(Prev->getFragmentList().back()));
74}
75
76bool MCAsmLayout::isFragmentUpToDate(const MCFragment *F) const {
77 return (LastValidFragment &&
78 F->getLayoutOrder() <= LastValidFragment->getLayoutOrder());
79}
80
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +000081void MCAsmLayout::UpdateForSlide(MCFragment *F, int SlideAmount) {
Daniel Dunbar47b3ec42010-05-14 00:51:14 +000082 // If this fragment wasn't already up-to-date, we don't need to do anything.
83 if (!isFragmentUpToDate(F))
84 return;
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +000085
Daniel Dunbar47b3ec42010-05-14 00:51:14 +000086 // Otherwise, reset the last valid fragment to the predecessor of the
87 // invalidated fragment.
88 LastValidFragment = F->getPrevNode();
89 if (!LastValidFragment) {
90 unsigned Index = F->getParent()->getLayoutOrder();
91 if (Index != 0) {
92 MCSectionData *Prev = getSectionOrder()[Index - 1];
93 LastValidFragment = &(Prev->getFragmentList().back());
94 }
95 }
96}
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +000097
Daniel Dunbar47b3ec42010-05-14 00:51:14 +000098void MCAsmLayout::EnsureValid(const MCFragment *F) const {
99 // Advance the layout position until the fragment is up-to-date.
100 while (!isFragmentUpToDate(F)) {
101 // Advance to the next fragment.
102 MCFragment *Cur = LastValidFragment;
103 if (Cur)
104 Cur = Cur->getNextNode();
105 if (!Cur) {
106 unsigned NextIndex = 0;
107 if (LastValidFragment)
108 NextIndex = LastValidFragment->getParent()->getLayoutOrder() + 1;
109 Cur = SectionOrder[NextIndex]->begin();
110 }
111
112 const_cast<MCAsmLayout*>(this)->LayoutFragment(Cur);
113 }
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +0000114}
115
Daniel Dunbaraa0d3502010-05-13 08:43:31 +0000116void MCAsmLayout::FragmentReplaced(MCFragment *Src, MCFragment *Dst) {
Daniel Dunbar9005d452010-05-14 00:37:21 +0000117 if (LastValidFragment == Src)
118 LastValidFragment = Dst;
119
Daniel Dunbaraa0d3502010-05-13 08:43:31 +0000120 Dst->Offset = Src->Offset;
121 Dst->EffectiveSize = Src->EffectiveSize;
122}
123
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000124uint64_t MCAsmLayout::getFragmentAddress(const MCFragment *F) const {
Daniel Dunbar7c3d45a2010-03-25 01:03:24 +0000125 assert(F->getParent() && "Missing section()!");
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000126 return getSectionAddress(F->getParent()) + getFragmentOffset(F);
127}
128
129uint64_t MCAsmLayout::getFragmentEffectiveSize(const MCFragment *F) const {
Daniel Dunbar47b3ec42010-05-14 00:51:14 +0000130 EnsureValid(F);
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000131 assert(F->EffectiveSize != ~UINT64_C(0) && "Address not set!");
132 return F->EffectiveSize;
133}
134
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000135uint64_t MCAsmLayout::getFragmentOffset(const MCFragment *F) const {
Daniel Dunbar47b3ec42010-05-14 00:51:14 +0000136 EnsureValid(F);
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000137 assert(F->Offset != ~UINT64_C(0) && "Address not set!");
138 return F->Offset;
139}
140
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000141uint64_t MCAsmLayout::getSymbolAddress(const MCSymbolData *SD) const {
Daniel Dunbar7c3d45a2010-03-25 01:03:24 +0000142 assert(SD->getFragment() && "Invalid getAddress() on undefined symbol!");
143 return getFragmentAddress(SD->getFragment()) + SD->getOffset();
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000144}
145
146uint64_t MCAsmLayout::getSectionAddress(const MCSectionData *SD) const {
Daniel Dunbar47b3ec42010-05-14 00:51:14 +0000147 EnsureValid(SD->begin());
Daniel Dunbar7c3d45a2010-03-25 01:03:24 +0000148 assert(SD->Address != ~UINT64_C(0) && "Address not set!");
149 return SD->Address;
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000150}
151
Daniel Dunbar2661f112010-05-13 03:19:50 +0000152uint64_t MCAsmLayout::getSectionAddressSize(const MCSectionData *SD) const {
Daniel Dunbarafc6acd2010-05-14 00:37:11 +0000153 // The size is the last fragment's end offset.
Daniel Dunbar2661f112010-05-13 03:19:50 +0000154 const MCFragment &F = SD->getFragmentList().back();
155 return getFragmentOffset(&F) + getFragmentEffectiveSize(&F);
Daniel Dunbar5d428512010-03-25 02:00:07 +0000156}
157
158uint64_t MCAsmLayout::getSectionFileSize(const MCSectionData *SD) const {
Daniel Dunbar2661f112010-05-13 03:19:50 +0000159 // Virtual sections have no file size.
160 if (getAssembler().getBackend().isVirtualSection(SD->getSection()))
161 return 0;
162
163 // Otherwise, the file size is the same as the address space size.
164 return getSectionAddressSize(SD);
Daniel Dunbar5d428512010-03-25 02:00:07 +0000165}
166
Daniel Dunbar2661f112010-05-13 03:19:50 +0000167uint64_t MCAsmLayout::getSectionSize(const MCSectionData *SD) const {
Daniel Dunbar2661f112010-05-13 03:19:50 +0000168 // The logical size is the address space size minus any tail padding.
169 uint64_t Size = getSectionAddressSize(SD);
170 const MCAlignFragment *AF =
171 dyn_cast<MCAlignFragment>(&(SD->getFragmentList().back()));
172 if (AF && AF->hasOnlyAlignAddress())
173 Size -= getFragmentEffectiveSize(AF);
174
175 return Size;
Daniel Dunbarb5844ff2010-05-13 01:10:22 +0000176}
177
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000178/* *** */
179
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000180MCFragment::MCFragment() : Kind(FragmentType(~0)) {
181}
182
Daniel Dunbar36880e72010-07-28 20:28:45 +0000183MCFragment::~MCFragment() {
184}
185
Daniel Dunbar5e835962009-08-26 02:48:04 +0000186MCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent)
Daniel Dunbar0ecdb6f2010-07-30 18:32:09 +0000187 : Kind(_Kind), Parent(_Parent), Atom(0), Offset(~UINT64_C(0)),
188 EffectiveSize(~UINT64_C(0))
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000189{
Daniel Dunbar5e835962009-08-26 02:48:04 +0000190 if (Parent)
191 Parent->getFragmentList().push_back(this);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000192}
193
194/* *** */
195
Daniel Dunbar81e40002009-08-27 00:38:04 +0000196MCSectionData::MCSectionData() : Section(0) {}
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000197
198MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A)
Daniel Dunbar81e40002009-08-27 00:38:04 +0000199 : Section(&_Section),
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000200 Alignment(1),
Daniel Dunbar5e835962009-08-26 02:48:04 +0000201 Address(~UINT64_C(0)),
Daniel Dunbare1ec6172010-02-02 21:44:01 +0000202 HasInstructions(false)
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000203{
204 if (A)
205 A->getSectionList().push_back(this);
206}
207
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000208/* *** */
209
Daniel Dunbarefbb5332009-09-01 04:09:03 +0000210MCSymbolData::MCSymbolData() : Symbol(0) {}
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +0000211
Daniel Dunbarcb579b32009-08-31 08:08:06 +0000212MCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment,
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +0000213 uint64_t _Offset, MCAssembler *A)
Daniel Dunbarefbb5332009-09-01 04:09:03 +0000214 : Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset),
Daniel Dunbar8f4d1462009-08-28 07:08:35 +0000215 IsExternal(false), IsPrivateExtern(false),
Matt Fleming6c8b3d22010-08-16 18:34:31 +0000216 CommonSize(0), SymbolSize(0), CommonAlign(0),
217 Flags(0), Index(0)
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +0000218{
219 if (A)
220 A->getSymbolList().push_back(this);
221}
222
223/* *** */
224
Daniel Dunbar1f3e4452010-03-11 01:34:27 +0000225MCAssembler::MCAssembler(MCContext &_Context, TargetAsmBackend &_Backend,
Rafael Espindola59ff3c92010-09-22 22:27:05 +0000226 MCCodeEmitter &_Emitter, bool _PadSectionToAlignment,
227 raw_ostream &_OS)
Daniel Dunbarcf871e52010-03-19 10:43:18 +0000228 : Context(_Context), Backend(_Backend), Emitter(_Emitter),
Rafael Espindola59ff3c92010-09-22 22:27:05 +0000229 OS(_OS), RelaxAll(false), SubsectionsViaSymbols(false),
230 PadSectionToAlignment(_PadSectionToAlignment)
Daniel Dunbar6009db42009-08-26 21:22:22 +0000231{
232}
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000233
234MCAssembler::~MCAssembler() {
235}
236
Daniel Dunbar843aa1f2010-06-16 20:04:29 +0000237bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const {
Daniel Dunbar23869852010-03-19 03:18:09 +0000238 // Non-temporary labels should always be visible to the linker.
Daniel Dunbar843aa1f2010-06-16 20:04:29 +0000239 if (!Symbol.isTemporary())
Daniel Dunbar23869852010-03-19 03:18:09 +0000240 return true;
241
242 // Absolute temporary labels are never visible.
Daniel Dunbar843aa1f2010-06-16 20:04:29 +0000243 if (!Symbol.isInSection())
Daniel Dunbar23869852010-03-19 03:18:09 +0000244 return false;
245
246 // Otherwise, check if the section requires symbols even for temporary labels.
Daniel Dunbar843aa1f2010-06-16 20:04:29 +0000247 return getBackend().doesSectionRequireSymbols(Symbol.getSection());
Daniel Dunbar23869852010-03-19 03:18:09 +0000248}
249
Rafael Espindolab8141102010-09-27 18:13:03 +0000250const MCSymbolData *MCAssembler::getAtom(const MCSymbolData *SD) const {
Daniel Dunbar8ad0dcc2010-03-19 03:18:15 +0000251 // Linker visible symbols define atoms.
Daniel Dunbar843aa1f2010-06-16 20:04:29 +0000252 if (isSymbolLinkerVisible(SD->getSymbol()))
Daniel Dunbar8ad0dcc2010-03-19 03:18:15 +0000253 return SD;
254
255 // Absolute and undefined symbols have no defining atom.
256 if (!SD->getFragment())
257 return 0;
258
Daniel Dunbara5f1d572010-05-12 00:38:17 +0000259 // Non-linker visible symbols in sections which can't be atomized have no
260 // defining atom.
261 if (!getBackend().isSectionAtomizable(
262 SD->getFragment()->getParent()->getSection()))
263 return 0;
264
Daniel Dunbar651804c2010-05-11 17:22:50 +0000265 // Otherwise, return the atom for the containing fragment.
266 return SD->getFragment()->getAtom();
Daniel Dunbar8ad0dcc2010-03-19 03:18:15 +0000267}
268
Rafael Espindola70703872010-09-30 02:22:20 +0000269bool MCAssembler::EvaluateFixup(const MCObjectWriter &Writer,
270 const MCAsmLayout &Layout,
Daniel Dunbarc90e30a2010-05-26 15:18:56 +0000271 const MCFixup &Fixup, const MCFragment *DF,
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000272 MCValue &Target, uint64_t &Value) const {
Daniel Dunbarff547842010-03-23 23:47:14 +0000273 ++stats::EvaluateFixup;
274
Daniel Dunbar482ad802010-05-26 15:18:31 +0000275 if (!Fixup.getValue()->EvaluateAsRelocatable(Target, &Layout))
Chris Lattner75361b62010-04-07 22:58:41 +0000276 report_fatal_error("expected relocatable expression");
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000277
278 // FIXME: How do non-scattered symbols work in ELF? I presume the linker
279 // doesn't support small relocations, but then under what criteria does the
280 // assembler allow symbol differences?
281
282 Value = Target.getConstant();
283
Daniel Dunbar482ad802010-05-26 15:18:31 +0000284 bool IsPCRel = Emitter.getFixupKindInfo(
285 Fixup.getKind()).Flags & MCFixupKindInfo::FKF_IsPCRel;
Daniel Dunbarb36052f2010-03-19 10:43:23 +0000286 bool IsResolved = true;
Daniel Dunbar9a1d2002010-03-18 00:59:10 +0000287 if (const MCSymbolRefExpr *A = Target.getSymA()) {
288 if (A->getSymbol().isDefined())
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000289 Value += Layout.getSymbolAddress(&getSymbolData(A->getSymbol()));
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000290 else
291 IsResolved = false;
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000292 }
Daniel Dunbar9a1d2002010-03-18 00:59:10 +0000293 if (const MCSymbolRefExpr *B = Target.getSymB()) {
294 if (B->getSymbol().isDefined())
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000295 Value -= Layout.getSymbolAddress(&getSymbolData(B->getSymbol()));
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000296 else
297 IsResolved = false;
Daniel Dunbar939f8d72010-03-19 03:18:12 +0000298 }
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000299
Rafael Espindola70703872010-09-30 02:22:20 +0000300 if (IsResolved)
301 IsResolved = Writer.IsFixupFullyResolved(*this, Target, IsPCRel, DF);
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000302
303 if (IsPCRel)
Daniel Dunbar482ad802010-05-26 15:18:31 +0000304 Value -= Layout.getFragmentAddress(DF) + Fixup.getOffset();
Daniel Dunbardf3c8f22010-03-12 21:00:49 +0000305
306 return IsResolved;
307}
308
Daniel Dunbar2c18d3b2010-05-13 18:35:06 +0000309uint64_t MCAssembler::ComputeFragmentSize(MCAsmLayout &Layout,
310 const MCFragment &F,
311 uint64_t SectionAddress,
312 uint64_t FragmentOffset) const {
313 switch (F.getKind()) {
314 case MCFragment::FT_Data:
315 return cast<MCDataFragment>(F).getContents().size();
316 case MCFragment::FT_Fill:
317 return cast<MCFillFragment>(F).getSize();
318 case MCFragment::FT_Inst:
319 return cast<MCInstFragment>(F).getInstSize();
320
321 case MCFragment::FT_Align: {
322 const MCAlignFragment &AF = cast<MCAlignFragment>(F);
323
324 assert((!AF.hasOnlyAlignAddress() || !AF.getNextNode()) &&
325 "Invalid OnlyAlignAddress bit, not the last fragment!");
326
327 uint64_t Size = OffsetToAlignment(SectionAddress + FragmentOffset,
328 AF.getAlignment());
329
330 // Honor MaxBytesToEmit.
331 if (Size > AF.getMaxBytesToEmit())
332 return 0;
333
334 return Size;
335 }
336
337 case MCFragment::FT_Org: {
338 const MCOrgFragment &OF = cast<MCOrgFragment>(F);
339
340 // FIXME: We should compute this sooner, we don't want to recurse here, and
341 // we would like to be more functional.
342 int64_t TargetLocation;
343 if (!OF.getOffset().EvaluateAsAbsolute(TargetLocation, &Layout))
344 report_fatal_error("expected assembly-time absolute expression");
345
346 // FIXME: We need a way to communicate this error.
347 int64_t Offset = TargetLocation - FragmentOffset;
Daniel Dunbara6c329d2010-09-09 16:23:33 +0000348 if (Offset < 0 || Offset >= 0x40000000)
Daniel Dunbar2c18d3b2010-05-13 18:35:06 +0000349 report_fatal_error("invalid .org offset '" + Twine(TargetLocation) +
Daniel Dunbar75413b12010-09-24 01:58:56 +0000350 "' (at offset '" + Twine(FragmentOffset) + "')");
Daniel Dunbar2c18d3b2010-05-13 18:35:06 +0000351
352 return Offset;
353 }
Kevin Enderbyc0957932010-09-30 16:52:03 +0000354
355 case MCFragment::FT_Dwarf: {
356 const MCDwarfLineAddrFragment &OF = cast<MCDwarfLineAddrFragment>(F);
357
358 // The AddrDelta is really unsigned and it can only increase.
359 int64_t AddrDelta;
360
361 OF.getAddrDelta().EvaluateAsAbsolute(AddrDelta, &Layout);
362
363 int64_t LineDelta;
364 LineDelta = OF.getLineDelta();
365
366 return MCDwarfLineAddr::ComputeSize(LineDelta, AddrDelta);
367 }
Daniel Dunbar2c18d3b2010-05-13 18:35:06 +0000368 }
369
370 assert(0 && "invalid fragment kind");
371 return 0;
372}
373
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000374void MCAsmLayout::LayoutFile() {
Daniel Dunbar47b3ec42010-05-14 00:51:14 +0000375 // Initialize the first section and set the valid fragment layout point. All
376 // actual layout computations are done lazily.
Daniel Dunbar9005d452010-05-14 00:37:21 +0000377 LastValidFragment = 0;
Daniel Dunbar11c41112010-05-14 00:37:17 +0000378 if (!getSectionOrder().empty())
379 getSectionOrder().front()->Address = 0;
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000380}
381
382void MCAsmLayout::LayoutFragment(MCFragment *F) {
Daniel Dunbar9005d452010-05-14 00:37:21 +0000383 MCFragment *Prev = F->getPrevNode();
Daniel Dunbarf0d17d22010-05-12 21:35:25 +0000384
Daniel Dunbar9005d452010-05-14 00:37:21 +0000385 // We should never try to recompute something which is up-to-date.
386 assert(!isFragmentUpToDate(F) && "Attempt to recompute up-to-date fragment!");
387 // We should never try to compute the fragment layout if the section isn't
388 // up-to-date.
389 assert(isSectionUpToDate(F->getParent()) &&
390 "Attempt to compute fragment before it's section!");
391 // We should never try to compute the fragment layout if it's predecessor
392 // isn't up-to-date.
393 assert((!Prev || isFragmentUpToDate(Prev)) &&
394 "Attempt to compute fragment before it's predecessor!");
Daniel Dunbarf0d17d22010-05-12 21:35:25 +0000395
396 ++stats::FragmentLayouts;
397
Daniel Dunbar9005d452010-05-14 00:37:21 +0000398 // Compute the fragment start address.
399 uint64_t StartAddress = F->getParent()->Address;
400 uint64_t Address = StartAddress;
401 if (Prev)
402 Address += Prev->Offset + Prev->EffectiveSize;
403
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000404 // Compute fragment offset and size.
Daniel Dunbarafc6acd2010-05-14 00:37:11 +0000405 F->Offset = Address - StartAddress;
406 F->EffectiveSize = getAssembler().ComputeFragmentSize(*this, *F, StartAddress,
407 F->Offset);
Daniel Dunbar9005d452010-05-14 00:37:21 +0000408 LastValidFragment = F;
Daniel Dunbar11c41112010-05-14 00:37:17 +0000409
410 // If this is the last fragment in a section, update the next section address.
411 if (!F->getNextNode()) {
412 unsigned NextIndex = F->getParent()->getLayoutOrder() + 1;
413 if (NextIndex != getSectionOrder().size())
414 LayoutSection(getSectionOrder()[NextIndex]);
415 }
Daniel Dunbarf0d17d22010-05-12 21:35:25 +0000416}
417
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000418void MCAsmLayout::LayoutSection(MCSectionData *SD) {
419 unsigned SectionOrderIndex = SD->getLayoutOrder();
Daniel Dunbarf476b002010-03-25 18:16:42 +0000420
Daniel Dunbarac2884a2010-03-25 22:49:09 +0000421 ++stats::SectionLayouts;
422
Daniel Dunbar61066db2010-05-13 02:34:14 +0000423 // Compute the section start address.
Daniel Dunbard13a0ca2010-05-12 17:56:47 +0000424 uint64_t StartAddress = 0;
425 if (SectionOrderIndex) {
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000426 MCSectionData *Prev = getSectionOrder()[SectionOrderIndex - 1];
427 StartAddress = getSectionAddress(Prev) + getSectionAddressSize(Prev);
Daniel Dunbard13a0ca2010-05-12 17:56:47 +0000428 }
429
Daniel Dunbar61066db2010-05-13 02:34:14 +0000430 // Honor the section alignment requirements.
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000431 StartAddress = RoundUpToAlignment(StartAddress, SD->getAlignment());
Daniel Dunbarf476b002010-03-25 18:16:42 +0000432
Daniel Dunbar61066db2010-05-13 02:34:14 +0000433 // Set the section address.
Daniel Dunbarafc6acd2010-05-14 00:37:11 +0000434 SD->Address = StartAddress;
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000435}
436
Daniel Dunbar53b23382010-03-19 09:28:59 +0000437/// WriteFragmentData - Write the \arg F data to the output file.
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000438static void WriteFragmentData(const MCAssembler &Asm, const MCAsmLayout &Layout,
439 const MCFragment &F, MCObjectWriter *OW) {
Daniel Dunbar53b23382010-03-19 09:28:59 +0000440 uint64_t Start = OW->getStream().tell();
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000441 (void) Start;
Daniel Dunbar7eb85192009-10-16 01:58:15 +0000442
Daniel Dunbarff547842010-03-23 23:47:14 +0000443 ++stats::EmittedFragments;
Daniel Dunbar0adcd352009-08-25 21:10:45 +0000444
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000445 // FIXME: Embed in fragments instead?
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000446 uint64_t FragmentSize = Layout.getFragmentEffectiveSize(&F);
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000447 switch (F.getKind()) {
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000448 case MCFragment::FT_Align: {
449 MCAlignFragment &AF = cast<MCAlignFragment>(F);
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000450 uint64_t Count = FragmentSize / AF.getValueSize();
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000451
Daniel Dunbare73d49e2010-05-12 22:51:27 +0000452 assert(AF.getValueSize() && "Invalid virtual align in concrete fragment!");
453
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000454 // FIXME: This error shouldn't actually occur (the front end should emit
455 // multiple .align directives to enforce the semantics it wants), but is
456 // severe enough that we want to report it. How to handle this?
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000457 if (Count * AF.getValueSize() != FragmentSize)
Chris Lattner75361b62010-04-07 22:58:41 +0000458 report_fatal_error("undefined .align directive, value size '" +
Daniel Dunbar7eb85192009-10-16 01:58:15 +0000459 Twine(AF.getValueSize()) +
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000460 "' is not a divisor of padding size '" +
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000461 Twine(FragmentSize) + "'");
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000462
Kevin Enderby6e720482010-02-23 18:26:34 +0000463 // See if we are aligning with nops, and if so do that first to try to fill
464 // the Count bytes. Then if that did not fill any bytes or there are any
465 // bytes left to fill use the the Value and ValueSize to fill the rest.
Daniel Dunbar8f9b80e2010-03-23 02:36:58 +0000466 // If we are aligning with nops, ask that target to emit the right data.
Daniel Dunbar1c154132010-05-12 22:56:23 +0000467 if (AF.hasEmitNops()) {
Daniel Dunbar8f9b80e2010-03-23 02:36:58 +0000468 if (!Asm.getBackend().WriteNopData(Count, OW))
Chris Lattner75361b62010-04-07 22:58:41 +0000469 report_fatal_error("unable to write nop sequence of " +
Daniel Dunbar8f9b80e2010-03-23 02:36:58 +0000470 Twine(Count) + " bytes");
471 break;
Kevin Enderby6e720482010-02-23 18:26:34 +0000472 }
473
Daniel Dunbar8f9b80e2010-03-23 02:36:58 +0000474 // Otherwise, write out in multiples of the value size.
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000475 for (uint64_t i = 0; i != Count; ++i) {
476 switch (AF.getValueSize()) {
477 default:
478 assert(0 && "Invalid size!");
Daniel Dunbarbdd92812010-03-19 09:28:55 +0000479 case 1: OW->Write8 (uint8_t (AF.getValue())); break;
480 case 2: OW->Write16(uint16_t(AF.getValue())); break;
481 case 4: OW->Write32(uint32_t(AF.getValue())); break;
482 case 8: OW->Write64(uint64_t(AF.getValue())); break;
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000483 }
484 }
485 break;
486 }
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000487
Daniel Dunbar3a30b822010-02-13 09:28:15 +0000488 case MCFragment::FT_Data: {
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000489 MCDataFragment &DF = cast<MCDataFragment>(F);
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000490 assert(FragmentSize == DF.getContents().size() && "Invalid size!");
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000491 OW->WriteBytes(DF.getContents().str());
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000492 break;
Daniel Dunbar3a30b822010-02-13 09:28:15 +0000493 }
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000494
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000495 case MCFragment::FT_Fill: {
496 MCFillFragment &FF = cast<MCFillFragment>(F);
Daniel Dunbare2fee5b2010-05-12 22:51:35 +0000497
498 assert(FF.getValueSize() && "Invalid virtual align in concrete fragment!");
499
Daniel Dunbar3153fec2010-05-12 22:51:32 +0000500 for (uint64_t i = 0, e = FF.getSize() / FF.getValueSize(); i != e; ++i) {
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000501 switch (FF.getValueSize()) {
502 default:
503 assert(0 && "Invalid size!");
Daniel Dunbarbdd92812010-03-19 09:28:55 +0000504 case 1: OW->Write8 (uint8_t (FF.getValue())); break;
505 case 2: OW->Write16(uint16_t(FF.getValue())); break;
506 case 4: OW->Write32(uint32_t(FF.getValue())); break;
507 case 8: OW->Write64(uint64_t(FF.getValue())); break;
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000508 }
509 }
510 break;
511 }
Daniel Dunbar7eb85192009-10-16 01:58:15 +0000512
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000513 case MCFragment::FT_Inst:
514 llvm_unreachable("unexpected inst fragment after lowering");
515 break;
516
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000517 case MCFragment::FT_Org: {
518 MCOrgFragment &OF = cast<MCOrgFragment>(F);
519
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000520 for (uint64_t i = 0, e = FragmentSize; i != e; ++i)
Daniel Dunbarbdd92812010-03-19 09:28:55 +0000521 OW->Write8(uint8_t(OF.getValue()));
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000522
523 break;
524 }
Kevin Enderbyc0957932010-09-30 16:52:03 +0000525
526 case MCFragment::FT_Dwarf: {
527 const MCDwarfLineAddrFragment &OF = cast<MCDwarfLineAddrFragment>(F);
528
529 // The AddrDelta is really unsigned and it can only increase.
530 int64_t AddrDelta;
531 OF.getAddrDelta().EvaluateAsAbsolute(AddrDelta, &Layout);
532
533 int64_t LineDelta;
534 LineDelta = OF.getLineDelta();
535
536 MCDwarfLineAddr::Write(OW, LineDelta, (uint64_t)AddrDelta);
537 break;
538 }
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000539 }
540
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000541 assert(OW->getStream().tell() - Start == FragmentSize);
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000542}
543
Daniel Dunbar53b23382010-03-19 09:28:59 +0000544void MCAssembler::WriteSectionData(const MCSectionData *SD,
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000545 const MCAsmLayout &Layout,
Daniel Dunbar53b23382010-03-19 09:28:59 +0000546 MCObjectWriter *OW) const {
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000547 // Ignore virtual sections.
Daniel Dunbarcc5b84c2010-03-19 09:29:03 +0000548 if (getBackend().isVirtualSection(SD->getSection())) {
Daniel Dunbar054be922010-05-13 03:50:50 +0000549 assert(Layout.getSectionFileSize(SD) == 0 && "Invalid size for section!");
Daniel Dunbare2fee5b2010-05-12 22:51:35 +0000550
551 // Check that contents are only things legal inside a virtual section.
552 for (MCSectionData::const_iterator it = SD->begin(),
553 ie = SD->end(); it != ie; ++it) {
554 switch (it->getKind()) {
555 default:
556 assert(0 && "Invalid fragment in virtual section!");
Daniel Dunbarc983b202010-08-18 18:22:37 +0000557 case MCFragment::FT_Data: {
558 // Check that we aren't trying to write a non-zero contents (or fixups)
559 // into a virtual section. This is to support clients which use standard
560 // directives to fill the contents of virtual sections.
561 MCDataFragment &DF = cast<MCDataFragment>(*it);
562 assert(DF.fixup_begin() == DF.fixup_end() &&
563 "Cannot have fixups in virtual section!");
564 for (unsigned i = 0, e = DF.getContents().size(); i != e; ++i)
565 assert(DF.getContents()[i] == 0 &&
566 "Invalid data value for virtual section!");
567 break;
568 }
Daniel Dunbare2fee5b2010-05-12 22:51:35 +0000569 case MCFragment::FT_Align:
Daniel Dunbarc983b202010-08-18 18:22:37 +0000570 // Check that we aren't trying to write a non-zero value into a virtual
571 // section.
572 assert((!cast<MCAlignFragment>(it)->getValueSize() ||
573 !cast<MCAlignFragment>(it)->getValue()) &&
Daniel Dunbare2fee5b2010-05-12 22:51:35 +0000574 "Invalid align in virtual section!");
575 break;
576 case MCFragment::FT_Fill:
577 assert(!cast<MCFillFragment>(it)->getValueSize() &&
578 "Invalid fill in virtual section!");
579 break;
Daniel Dunbare2fee5b2010-05-12 22:51:35 +0000580 }
581 }
582
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000583 return;
584 }
585
Daniel Dunbar53b23382010-03-19 09:28:59 +0000586 uint64_t Start = OW->getStream().tell();
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000587 (void) Start;
Daniel Dunbar7eb85192009-10-16 01:58:15 +0000588
Daniel Dunbar53b23382010-03-19 09:28:59 +0000589 for (MCSectionData::const_iterator it = SD->begin(),
590 ie = SD->end(); it != ie; ++it)
Daniel Dunbar432cd5f2010-03-25 02:00:02 +0000591 WriteFragmentData(*this, Layout, *it, OW);
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000592
Daniel Dunbar054be922010-05-13 03:50:50 +0000593 assert(OW->getStream().tell() - Start == Layout.getSectionFileSize(SD));
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000594}
595
Rafael Espindola70703872010-09-30 02:22:20 +0000596void MCAssembler::AddSectionToTheEnd(const MCObjectWriter &Writer,
597 MCSectionData &SD, MCAsmLayout &Layout) {
Matt Fleminga8bf4732010-08-16 18:35:06 +0000598 // Create dummy fragments and assign section ordinals.
599 unsigned SectionIndex = 0;
600 for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it)
601 SectionIndex++;
602
603 SD.setOrdinal(SectionIndex);
604
605 // Assign layout order indices to sections and fragments.
606 unsigned FragmentIndex = 0;
607 unsigned i = 0;
608 for (unsigned e = Layout.getSectionOrder().size(); i != e; ++i) {
609 MCSectionData *SD = Layout.getSectionOrder()[i];
610
611 for (MCSectionData::iterator it2 = SD->begin(),
612 ie2 = SD->end(); it2 != ie2; ++it2)
613 FragmentIndex++;
614 }
615
616 SD.setLayoutOrder(i);
617 for (MCSectionData::iterator it2 = SD.begin(),
618 ie2 = SD.end(); it2 != ie2; ++it2) {
619 it2->setLayoutOrder(FragmentIndex++);
620 }
621 Layout.getSectionOrder().push_back(&SD);
622
623 Layout.LayoutSection(&SD);
624
625 // Layout until everything fits.
Rafael Espindola70703872010-09-30 02:22:20 +0000626 while (LayoutOnce(Writer, Layout))
Matt Fleminga8bf4732010-08-16 18:35:06 +0000627 continue;
628
629}
630
Reid Klecknerc96a82a2010-07-22 05:58:53 +0000631void MCAssembler::Finish(MCObjectWriter *Writer) {
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000632 DEBUG_WITH_TYPE("mc-dump", {
633 llvm::errs() << "assembler backend - pre-layout\n--\n";
634 dump(); });
635
Daniel Dunbar61066db2010-05-13 02:34:14 +0000636 // Create the layout object.
Daniel Dunbar8d39eb42010-03-22 20:35:35 +0000637 MCAsmLayout Layout(*this);
Daniel Dunbar61066db2010-05-13 02:34:14 +0000638
639 // Insert additional align fragments for concrete sections to explicitly pad
640 // the previous section to match their alignment requirements. This is for
641 // 'gas' compatibility, it shouldn't strictly be necessary.
Rafael Espindola59ff3c92010-09-22 22:27:05 +0000642 if (PadSectionToAlignment) {
643 for (unsigned i = 1, e = Layout.getSectionOrder().size(); i < e; ++i) {
644 MCSectionData *SD = Layout.getSectionOrder()[i];
Daniel Dunbar61066db2010-05-13 02:34:14 +0000645
Rafael Espindola59ff3c92010-09-22 22:27:05 +0000646 // Ignore sections without alignment requirements.
647 unsigned Align = SD->getAlignment();
648 if (Align <= 1)
649 continue;
Daniel Dunbar61066db2010-05-13 02:34:14 +0000650
Rafael Espindola59ff3c92010-09-22 22:27:05 +0000651 // Ignore virtual sections, they don't cause file size modifications.
652 if (getBackend().isVirtualSection(SD->getSection()))
653 continue;
Daniel Dunbar61066db2010-05-13 02:34:14 +0000654
Rafael Espindola59ff3c92010-09-22 22:27:05 +0000655 // Otherwise, create a new align fragment at the end of the previous
656 // section.
657 MCAlignFragment *AF = new MCAlignFragment(Align, 0, 1, Align,
658 Layout.getSectionOrder()[i - 1]);
659 AF->setOnlyAlignAddress(true);
660 }
Daniel Dunbar61066db2010-05-13 02:34:14 +0000661 }
662
Daniel Dunbar337718e2010-05-14 00:37:14 +0000663 // Create dummy fragments and assign section ordinals.
Daniel Dunbar49ed9212010-05-13 08:43:37 +0000664 unsigned SectionIndex = 0;
Daniel Dunbar49ed9212010-05-13 08:43:37 +0000665 for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
666 // Create dummy fragments to eliminate any empty sections, this simplifies
667 // layout.
Duncan Sands6f74f692010-06-29 13:30:08 +0000668 if (it->getFragmentList().empty())
Rafael Espindolad80781b2010-09-15 21:48:40 +0000669 new MCDataFragment(it);
Daniel Dunbar49ed9212010-05-13 08:43:37 +0000670
671 it->setOrdinal(SectionIndex++);
Daniel Dunbar337718e2010-05-14 00:37:14 +0000672 }
Daniel Dunbar49ed9212010-05-13 08:43:37 +0000673
Daniel Dunbar337718e2010-05-14 00:37:14 +0000674 // Assign layout order indices to sections and fragments.
675 unsigned FragmentIndex = 0;
676 for (unsigned i = 0, e = Layout.getSectionOrder().size(); i != e; ++i) {
677 MCSectionData *SD = Layout.getSectionOrder()[i];
678 SD->setLayoutOrder(i);
679
680 for (MCSectionData::iterator it2 = SD->begin(),
681 ie2 = SD->end(); it2 != ie2; ++it2)
682 it2->setLayoutOrder(FragmentIndex++);
Daniel Dunbar49ed9212010-05-13 08:43:37 +0000683 }
684
Rafael Espindola70703872010-09-30 02:22:20 +0000685 llvm::OwningPtr<MCObjectWriter> OwnWriter(0);
686 if (Writer == 0) {
687 //no custom Writer_ : create the default one life-managed by OwningPtr
688 OwnWriter.reset(getBackend().createObjectWriter(OS));
689 Writer = OwnWriter.get();
690 if (!Writer)
691 report_fatal_error("unable to create object writer!");
692 }
693
Daniel Dunbar61066db2010-05-13 02:34:14 +0000694 // Layout until everything fits.
Rafael Espindola70703872010-09-30 02:22:20 +0000695 while (LayoutOnce(*Writer, Layout))
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000696 continue;
697
698 DEBUG_WITH_TYPE("mc-dump", {
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000699 llvm::errs() << "assembler backend - post-relaxation\n--\n";
700 dump(); });
701
702 // Finalize the layout, including fragment lowering.
703 FinishLayout(Layout);
704
705 DEBUG_WITH_TYPE("mc-dump", {
706 llvm::errs() << "assembler backend - final-layout\n--\n";
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000707 dump(); });
708
Daniel Dunbarff547842010-03-23 23:47:14 +0000709 uint64_t StartOffset = OS.tell();
Reid Klecknerc96a82a2010-07-22 05:58:53 +0000710
Daniel Dunbarbacba992010-03-19 07:09:33 +0000711 // Allow the object writer a chance to perform post-layout binding (for
712 // example, to set the index fields in the symbol data).
Daniel Dunbar1a9158c2010-03-19 10:43:26 +0000713 Writer->ExecutePostLayoutBinding(*this);
Daniel Dunbarbacba992010-03-19 07:09:33 +0000714
Daniel Dunbarb1e98942010-03-19 07:09:47 +0000715 // Evaluate and apply the fixups, generating relocation entries as necessary.
Daniel Dunbarb1e98942010-03-19 07:09:47 +0000716 for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
717 for (MCSectionData::iterator it2 = it->begin(),
718 ie2 = it->end(); it2 != ie2; ++it2) {
719 MCDataFragment *DF = dyn_cast<MCDataFragment>(it2);
720 if (!DF)
721 continue;
722
723 for (MCDataFragment::fixup_iterator it3 = DF->fixup_begin(),
724 ie3 = DF->fixup_end(); it3 != ie3; ++it3) {
Daniel Dunbarc90e30a2010-05-26 15:18:56 +0000725 MCFixup &Fixup = *it3;
Daniel Dunbarb1e98942010-03-19 07:09:47 +0000726
727 // Evaluate the fixup.
728 MCValue Target;
729 uint64_t FixedValue;
Rafael Espindola70703872010-09-30 02:22:20 +0000730 if (!EvaluateFixup(*Writer, Layout, Fixup, DF, Target, FixedValue)) {
Daniel Dunbarb1e98942010-03-19 07:09:47 +0000731 // The fixup was unresolved, we need a relocation. Inform the object
732 // writer of the relocation, and give it an opportunity to adjust the
733 // fixup value if need be.
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000734 Writer->RecordRelocation(*this, Layout, DF, Fixup, Target,FixedValue);
Daniel Dunbarb1e98942010-03-19 07:09:47 +0000735 }
736
Daniel Dunbar87190c42010-03-19 09:28:12 +0000737 getBackend().ApplyFixup(Fixup, *DF, FixedValue);
Daniel Dunbarb1e98942010-03-19 07:09:47 +0000738 }
739 }
740 }
741
Daniel Dunbarbacba992010-03-19 07:09:33 +0000742 // Write the object file.
Daniel Dunbar207e06e2010-03-24 03:43:40 +0000743 Writer->WriteObject(*this, Layout);
Daniel Dunbarff547842010-03-23 23:47:14 +0000744
745 stats::ObjectBytes += OS.tell() - StartOffset;
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000746}
747
Rafael Espindola70703872010-09-30 02:22:20 +0000748bool MCAssembler::FixupNeedsRelaxation(const MCObjectWriter &Writer,
749 const MCFixup &Fixup,
Daniel Dunbar9d39e612010-03-22 21:49:41 +0000750 const MCFragment *DF,
Daniel Dunbar8d39eb42010-03-22 20:35:35 +0000751 const MCAsmLayout &Layout) const {
Daniel Dunbarac2884a2010-03-25 22:49:09 +0000752 if (getRelaxAll())
753 return true;
754
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000755 // If we cannot resolve the fixup value, it requires relaxation.
756 MCValue Target;
757 uint64_t Value;
Rafael Espindola70703872010-09-30 02:22:20 +0000758 if (!EvaluateFixup(Writer, Layout, Fixup, DF, Target, Value))
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000759 return true;
760
761 // Otherwise, relax if the value is too big for a (signed) i8.
Daniel Dunbar31e8e1d2010-05-04 00:33:07 +0000762 //
763 // FIXME: This is target dependent!
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000764 return int64_t(Value) != int64_t(int8_t(Value));
765}
766
Rafael Espindola70703872010-09-30 02:22:20 +0000767bool MCAssembler::FragmentNeedsRelaxation(const MCObjectWriter &Writer,
768 const MCInstFragment *IF,
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000769 const MCAsmLayout &Layout) const {
770 // If this inst doesn't ever need relaxation, ignore it. This occurs when we
771 // are intentionally pushing out inst fragments, or because we relaxed a
772 // previous instruction to one that doesn't need relaxation.
Daniel Dunbar84882522010-05-26 17:45:29 +0000773 if (!getBackend().MayNeedRelaxation(IF->getInst()))
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000774 return false;
775
776 for (MCInstFragment::const_fixup_iterator it = IF->fixup_begin(),
777 ie = IF->fixup_end(); it != ie; ++it)
Rafael Espindola70703872010-09-30 02:22:20 +0000778 if (FixupNeedsRelaxation(Writer, *it, IF, Layout))
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000779 return true;
780
781 return false;
782}
783
Rafael Espindola70703872010-09-30 02:22:20 +0000784bool MCAssembler::LayoutOnce(const MCObjectWriter &Writer,
785 MCAsmLayout &Layout) {
Daniel Dunbarff547842010-03-23 23:47:14 +0000786 ++stats::RelaxationSteps;
787
Daniel Dunbard13a0ca2010-05-12 17:56:47 +0000788 // Layout the sections in order.
Daniel Dunbarb69fc042010-05-13 20:40:12 +0000789 Layout.LayoutFile();
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000790
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000791 // Scan for fragments that need relaxation.
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +0000792 bool WasRelaxed = false;
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000793 for (iterator it = begin(), ie = end(); it != ie; ++it) {
794 MCSectionData &SD = *it;
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000795
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000796 for (MCSectionData::iterator it2 = SD.begin(),
797 ie2 = SD.end(); it2 != ie2; ++it2) {
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000798 // Check if this is an instruction fragment that needs relaxation.
799 MCInstFragment *IF = dyn_cast<MCInstFragment>(it2);
Rafael Espindola70703872010-09-30 02:22:20 +0000800 if (!IF || !FragmentNeedsRelaxation(Writer, IF, Layout))
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000801 continue;
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000802
Daniel Dunbarff547842010-03-23 23:47:14 +0000803 ++stats::RelaxedInstructions;
804
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000805 // FIXME-PERF: We could immediately lower out instructions if we can tell
806 // they are fully resolved, to avoid retesting on later passes.
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000807
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000808 // Relax the fragment.
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000809
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000810 MCInst Relaxed;
Daniel Dunbar95506d42010-05-26 18:15:06 +0000811 getBackend().RelaxInstruction(IF->getInst(), Relaxed);
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000812
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000813 // Encode the new instruction.
814 //
815 // FIXME-PERF: If it matters, we could let the target do this. It can
816 // probably do so more efficiently in many cases.
817 SmallVector<MCFixup, 4> Fixups;
818 SmallString<256> Code;
819 raw_svector_ostream VecOS(Code);
820 getEmitter().EncodeInstruction(Relaxed, VecOS, Fixups);
821 VecOS.flush();
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000822
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000823 // Update the instruction fragment.
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +0000824 int SlideAmount = Code.size() - IF->getInstSize();
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000825 IF->setInst(Relaxed);
826 IF->getCode() = Code;
827 IF->getFixups().clear();
Daniel Dunbarc90e30a2010-05-26 15:18:56 +0000828 // FIXME: Eliminate copy.
829 for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
830 IF->getFixups().push_back(Fixups[i]);
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000831
Daniel Dunbar83194de2010-05-26 20:37:03 +0000832 // Update the layout, and remember that we relaxed.
833 Layout.UpdateForSlide(IF, SlideAmount);
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +0000834 WasRelaxed = true;
Daniel Dunbarf08fde42010-03-12 22:07:14 +0000835 }
836 }
837
Daniel Dunbar0cc8bd42010-03-25 19:35:56 +0000838 return WasRelaxed;
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000839}
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000840
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000841void MCAssembler::FinishLayout(MCAsmLayout &Layout) {
842 // Lower out any instruction fragments, to simplify the fixup application and
843 // output.
844 //
845 // FIXME-PERF: We don't have to do this, but the assumption is that it is
846 // cheap (we will mostly end up eliminating fragments and appending on to data
847 // fragments), so the extra complexity downstream isn't worth it. Evaluate
848 // this assumption.
849 for (iterator it = begin(), ie = end(); it != ie; ++it) {
850 MCSectionData &SD = *it;
851
852 for (MCSectionData::iterator it2 = SD.begin(),
853 ie2 = SD.end(); it2 != ie2; ++it2) {
854 MCInstFragment *IF = dyn_cast<MCInstFragment>(it2);
855 if (!IF)
856 continue;
857
858 // Create a new data fragment for the instruction.
859 //
Daniel Dunbar337055e2010-03-23 03:13:05 +0000860 // FIXME-PERF: Reuse previous data fragment if possible.
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000861 MCDataFragment *DF = new MCDataFragment();
862 SD.getFragmentList().insert(it2, DF);
863
864 // Update the data fragments layout data.
Daniel Dunbar9799de92010-03-23 01:39:05 +0000865 DF->setParent(IF->getParent());
Daniel Dunbar651804c2010-05-11 17:22:50 +0000866 DF->setAtom(IF->getAtom());
Daniel Dunbar337718e2010-05-14 00:37:14 +0000867 DF->setLayoutOrder(IF->getLayoutOrder());
Daniel Dunbaraa0d3502010-05-13 08:43:31 +0000868 Layout.FragmentReplaced(IF, DF);
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000869
Daniel Dunbar9799de92010-03-23 01:39:05 +0000870 // Copy in the data and the fixups.
871 DF->getContents().append(IF->getCode().begin(), IF->getCode().end());
872 for (unsigned i = 0, e = IF->getFixups().size(); i != e; ++i)
873 DF->getFixups().push_back(IF->getFixups()[i]);
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000874
875 // Delete the instruction fragment and update the iterator.
876 SD.getFragmentList().erase(IF);
877 it2 = DF;
878 }
879 }
880}
881
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000882// Debugging methods
883
884namespace llvm {
885
Daniel Dunbarc90e30a2010-05-26 15:18:56 +0000886raw_ostream &operator<<(raw_ostream &OS, const MCFixup &AF) {
887 OS << "<MCFixup" << " Offset:" << AF.getOffset()
Daniel Dunbar482ad802010-05-26 15:18:31 +0000888 << " Value:" << *AF.getValue()
889 << " Kind:" << AF.getKind() << ">";
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000890 return OS;
891}
892
893}
894
895void MCFragment::dump() {
896 raw_ostream &OS = llvm::errs();
897
Daniel Dunbare614e392010-05-26 06:50:57 +0000898 OS << "<";
899 switch (getKind()) {
900 case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
901 case MCFragment::FT_Data: OS << "MCDataFragment"; break;
902 case MCFragment::FT_Fill: OS << "MCFillFragment"; break;
903 case MCFragment::FT_Inst: OS << "MCInstFragment"; break;
904 case MCFragment::FT_Org: OS << "MCOrgFragment"; break;
Kevin Enderbyc0957932010-09-30 16:52:03 +0000905 case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
Daniel Dunbare614e392010-05-26 06:50:57 +0000906 }
907
Daniel Dunbar337718e2010-05-14 00:37:14 +0000908 OS << "<MCFragment " << (void*) this << " LayoutOrder:" << LayoutOrder
909 << " Offset:" << Offset << " EffectiveSize:" << EffectiveSize << ">";
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000910
Daniel Dunbare614e392010-05-26 06:50:57 +0000911 switch (getKind()) {
912 case MCFragment::FT_Align: {
913 const MCAlignFragment *AF = cast<MCAlignFragment>(this);
914 if (AF->hasEmitNops())
915 OS << " (emit nops)";
916 if (AF->hasOnlyAlignAddress())
917 OS << " (only align section)";
918 OS << "\n ";
919 OS << " Alignment:" << AF->getAlignment()
920 << " Value:" << AF->getValue() << " ValueSize:" << AF->getValueSize()
921 << " MaxBytesToEmit:" << AF->getMaxBytesToEmit() << ">";
922 break;
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000923 }
Daniel Dunbare614e392010-05-26 06:50:57 +0000924 case MCFragment::FT_Data: {
925 const MCDataFragment *DF = cast<MCDataFragment>(this);
926 OS << "\n ";
927 OS << " Contents:[";
928 const SmallVectorImpl<char> &Contents = DF->getContents();
929 for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
930 if (i) OS << ",";
931 OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
Daniel Dunbar0bcf0742010-02-13 09:28:43 +0000932 }
Daniel Dunbare614e392010-05-26 06:50:57 +0000933 OS << "] (" << Contents.size() << " bytes)";
934
935 if (!DF->getFixups().empty()) {
936 OS << ",\n ";
937 OS << " Fixups:[";
938 for (MCDataFragment::const_fixup_iterator it = DF->fixup_begin(),
939 ie = DF->fixup_end(); it != ie; ++it) {
940 if (it != DF->fixup_begin()) OS << ",\n ";
941 OS << *it;
942 }
943 OS << "]";
944 }
945 break;
Daniel Dunbar0bcf0742010-02-13 09:28:43 +0000946 }
Daniel Dunbare614e392010-05-26 06:50:57 +0000947 case MCFragment::FT_Fill: {
948 const MCFillFragment *FF = cast<MCFillFragment>(this);
949 OS << " Value:" << FF->getValue() << " ValueSize:" << FF->getValueSize()
950 << " Size:" << FF->getSize();
951 break;
952 }
953 case MCFragment::FT_Inst: {
954 const MCInstFragment *IF = cast<MCInstFragment>(this);
955 OS << "\n ";
956 OS << " Inst:";
957 IF->getInst().dump_pretty(OS);
958 break;
959 }
960 case MCFragment::FT_Org: {
961 const MCOrgFragment *OF = cast<MCOrgFragment>(this);
962 OS << "\n ";
963 OS << " Offset:" << OF->getOffset() << " Value:" << OF->getValue();
964 break;
965 }
Kevin Enderbyc0957932010-09-30 16:52:03 +0000966 case MCFragment::FT_Dwarf: {
967 const MCDwarfLineAddrFragment *OF = cast<MCDwarfLineAddrFragment>(this);
968 OS << "\n ";
969 OS << " AddrDelta:" << OF->getAddrDelta()
970 << " LineDelta:" << OF->getLineDelta();
971 break;
972 }
Daniel Dunbare614e392010-05-26 06:50:57 +0000973 }
Daniel Dunbar0bcf0742010-02-13 09:28:43 +0000974 OS << ">";
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000975}
976
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000977void MCSectionData::dump() {
978 raw_ostream &OS = llvm::errs();
979
980 OS << "<MCSectionData";
981 OS << " Alignment:" << getAlignment() << " Address:" << Address
Daniel Dunbar2661f112010-05-13 03:19:50 +0000982 << " Fragments:[\n ";
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +0000983 for (iterator it = begin(), ie = end(); it != ie; ++it) {
984 if (it != begin()) OS << ",\n ";
985 it->dump();
986 }
987 OS << "]>";
988}
989
990void MCSymbolData::dump() {
991 raw_ostream &OS = llvm::errs();
992
993 OS << "<MCSymbolData Symbol:" << getSymbol()
994 << " Fragment:" << getFragment() << " Offset:" << getOffset()
995 << " Flags:" << getFlags() << " Index:" << getIndex();
996 if (isCommon())
997 OS << " (common, size:" << getCommonSize()
998 << " align: " << getCommonAlignment() << ")";
999 if (isExternal())
1000 OS << " (external)";
1001 if (isPrivateExtern())
1002 OS << " (private extern)";
1003 OS << ">";
1004}
1005
1006void MCAssembler::dump() {
1007 raw_ostream &OS = llvm::errs();
1008
1009 OS << "<MCAssembler\n";
Daniel Dunbar45aefff2010-03-09 01:12:23 +00001010 OS << " Sections:[\n ";
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +00001011 for (iterator it = begin(), ie = end(); it != ie; ++it) {
1012 if (it != begin()) OS << ",\n ";
1013 it->dump();
1014 }
1015 OS << "],\n";
1016 OS << " Symbols:[";
1017
1018 for (symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) {
Daniel Dunbar45aefff2010-03-09 01:12:23 +00001019 if (it != symbol_begin()) OS << ",\n ";
Daniel Dunbarb7c3a4b2010-02-13 09:28:03 +00001020 it->dump();
1021 }
1022 OS << "]>\n";
1023}