MCAssembler.cpp revision b69fc044db8c193348b6611f46432bb21b3cbe90
1fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar//===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===// 2fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar// 3fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar// The LLVM Compiler Infrastructure 4fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar// 5fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar// This file is distributed under the University of Illinois Open Source 6fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar// License. See LICENSE.TXT for details. 7fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar// 8fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar//===----------------------------------------------------------------------===// 9fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 100adcd35f78b89bf70eb634b7f9ac2103516ca2b2Daniel Dunbar#define DEBUG_TYPE "assembler" 11fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar#include "llvm/MC/MCAssembler.h" 1218ff2cced7e08ac76d8d5bcff8160a5f9a109cbbDaniel Dunbar#include "llvm/MC/MCAsmLayout.h" 13b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar#include "llvm/MC/MCCodeEmitter.h" 141253a6fa3b0d79dc6ea25f2578f6473219d40047Daniel Dunbar#include "llvm/MC/MCExpr.h" 1553b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar#include "llvm/MC/MCObjectWriter.h" 161253a6fa3b0d79dc6ea25f2578f6473219d40047Daniel Dunbar#include "llvm/MC/MCSymbol.h" 171253a6fa3b0d79dc6ea25f2578f6473219d40047Daniel Dunbar#include "llvm/MC/MCValue.h" 181a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar#include "llvm/ADT/OwningPtr.h" 190adcd35f78b89bf70eb634b7f9ac2103516ca2b2Daniel Dunbar#include "llvm/ADT/Statistic.h" 20b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar#include "llvm/ADT/StringExtras.h" 21d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar#include "llvm/ADT/Twine.h" 22ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar#include "llvm/Support/Debug.h" 230705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar#include "llvm/Support/ErrorHandling.h" 24fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar#include "llvm/Support/raw_ostream.h" 25ee0d89245eabf93d89b5fef7ac8707680796826dDaniel Dunbar#include "llvm/Target/TargetRegistry.h" 26df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar#include "llvm/Target/TargetAsmBackend.h" 27f6346769b344f9b134f0661e8bd2b4245f6490eaDaniel Dunbar 2823132b188ba651ba172380cd082cc286df73d440Chris Lattner#include <vector> 29fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbarusing namespace llvm; 30fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 31ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbarnamespace { 32ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbarnamespace stats { 330adcd35f78b89bf70eb634b7f9ac2103516ca2b2Daniel DunbarSTATISTIC(EmittedFragments, "Number of emitted assembler fragments"); 34ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel DunbarSTATISTIC(EvaluateFixup, "Number of evaluated fixups"); 35ac2884a717daf3ad2aa8425320795d661e8a980bDaniel DunbarSTATISTIC(FragmentLayouts, "Number of fragment layouts"); 36ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel DunbarSTATISTIC(ObjectBytes, "Number of emitted object file bytes"); 37ac2884a717daf3ad2aa8425320795d661e8a980bDaniel DunbarSTATISTIC(RelaxationSteps, "Number of assembler layout and relaxation steps"); 38ac2884a717daf3ad2aa8425320795d661e8a980bDaniel DunbarSTATISTIC(RelaxedInstructions, "Number of relaxed instructions"); 39ac2884a717daf3ad2aa8425320795d661e8a980bDaniel DunbarSTATISTIC(SectionLayouts, "Number of section layouts"); 40ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar} 41ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar} 420adcd35f78b89bf70eb634b7f9ac2103516ca2b2Daniel Dunbar 438f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar// FIXME FIXME FIXME: There are number of places in this file where we convert 448f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar// what is a 64-bit assembler value used for computation into a value in the 458f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar// object file, which may truncate it. We should detect that truncation where 468f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar// invalid and report errors back. 478f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar 48fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar/* *** */ 49fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 50bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel DunbarMCAsmLayout::MCAsmLayout(MCAssembler &Asm) : Assembler(Asm) { 51bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar // Compute the section layout order. Virtual sections must go last. 52bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it) 53bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar if (!Asm.getBackend().isVirtualSection(it->getSection())) 54bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar SectionOrder.push_back(&*it); 55bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it) 56bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar if (Asm.getBackend().isVirtualSection(it->getSection())) 57bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar SectionOrder.push_back(&*it); 58bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar} 59bc1a0cf13950dcd64d6d0398df5419a0a2931721Daniel Dunbar 600cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbarvoid MCAsmLayout::UpdateForSlide(MCFragment *F, int SlideAmount) { 610cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // We shouldn't have to do anything special to support negative slides, and it 62651804c3d63a05f72221a6d133e5b344e6aaa093Daniel Dunbar // is a perfectly valid thing to do as long as other parts of the system can 63651804c3d63a05f72221a6d133e5b344e6aaa093Daniel Dunbar // guarantee convergence. 640cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar assert(SlideAmount >= 0 && "Negative slides not yet supported"); 650cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 660cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Update the layout by simply recomputing the layout for the entire 670cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // file. This is trivially correct, but very slow. 680cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // 690cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // FIXME-PERF: This is O(N^2), but will be eliminated once we get smarter. 700cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 71d13a0caf726e05c9bd939d752ef371d6d467ef28Daniel Dunbar // Layout the sections in order. 72b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar LayoutFile(); 730cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar} 740cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 75aa0d350fe54b0bf13947cdb08d8e76e4ec233d6fDaniel Dunbarvoid MCAsmLayout::FragmentReplaced(MCFragment *Src, MCFragment *Dst) { 76aa0d350fe54b0bf13947cdb08d8e76e4ec233d6fDaniel Dunbar Dst->Offset = Src->Offset; 77aa0d350fe54b0bf13947cdb08d8e76e4ec233d6fDaniel Dunbar Dst->EffectiveSize = Src->EffectiveSize; 78aa0d350fe54b0bf13947cdb08d8e76e4ec233d6fDaniel Dunbar} 79aa0d350fe54b0bf13947cdb08d8e76e4ec233d6fDaniel Dunbar 80207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbaruint64_t MCAsmLayout::getFragmentAddress(const MCFragment *F) const { 817c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar assert(F->getParent() && "Missing section()!"); 82432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar return getSectionAddress(F->getParent()) + getFragmentOffset(F); 83432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 84432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 85432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbaruint64_t MCAsmLayout::getFragmentEffectiveSize(const MCFragment *F) const { 86432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(F->EffectiveSize != ~UINT64_C(0) && "Address not set!"); 87432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar return F->EffectiveSize; 88432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 89432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 90432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbarvoid MCAsmLayout::setFragmentEffectiveSize(MCFragment *F, uint64_t Value) { 91432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar F->EffectiveSize = Value; 92432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 93432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 94432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbaruint64_t MCAsmLayout::getFragmentOffset(const MCFragment *F) const { 95432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(F->Offset != ~UINT64_C(0) && "Address not set!"); 96432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar return F->Offset; 97432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 98432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 99432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbarvoid MCAsmLayout::setFragmentOffset(MCFragment *F, uint64_t Value) { 100432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar F->Offset = Value; 101207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 102207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 103207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbaruint64_t MCAsmLayout::getSymbolAddress(const MCSymbolData *SD) const { 1047c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar assert(SD->getFragment() && "Invalid getAddress() on undefined symbol!"); 1057c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar return getFragmentAddress(SD->getFragment()) + SD->getOffset(); 106207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 107207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 108207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbaruint64_t MCAsmLayout::getSectionAddress(const MCSectionData *SD) const { 1097c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar assert(SD->Address != ~UINT64_C(0) && "Address not set!"); 1107c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar return SD->Address; 111207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 112207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 113207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbarvoid MCAsmLayout::setSectionAddress(MCSectionData *SD, uint64_t Value) { 1147c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar SD->Address = Value; 115207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 116207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 1172661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbaruint64_t MCAsmLayout::getSectionAddressSize(const MCSectionData *SD) const { 1182661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar // Otherwise, the size is the last fragment's end offset. 1192661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar const MCFragment &F = SD->getFragmentList().back(); 1202661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar return getFragmentOffset(&F) + getFragmentEffectiveSize(&F); 1215d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar} 1225d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar 1235d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbaruint64_t MCAsmLayout::getSectionFileSize(const MCSectionData *SD) const { 1242661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar // Virtual sections have no file size. 1252661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar if (getAssembler().getBackend().isVirtualSection(SD->getSection())) 1262661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar return 0; 1275d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar 1282661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar // Otherwise, the file size is the same as the address space size. 1292661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar return getSectionAddressSize(SD); 130b5844ff1c44f0427bcf132eaece945da411e650fDaniel Dunbar} 1312661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar 1322661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbaruint64_t MCAsmLayout::getSectionSize(const MCSectionData *SD) const { 1332661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar // The logical size is the address space size minus any tail padding. 1342661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar uint64_t Size = getSectionAddressSize(SD); 1352661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar const MCAlignFragment *AF = 1362661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar dyn_cast<MCAlignFragment>(&(SD->getFragmentList().back())); 1372661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar if (AF && AF->hasOnlyAlignAddress()) 1382661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar Size -= getFragmentEffectiveSize(AF); 1392661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar 1402661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar return Size; 141b5844ff1c44f0427bcf132eaece945da411e650fDaniel Dunbar} 142b5844ff1c44f0427bcf132eaece945da411e650fDaniel Dunbar 143207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar/* *** */ 144207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 1450705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel DunbarMCFragment::MCFragment() : Kind(FragmentType(~0)) { 1460705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 1470705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 1485e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel DunbarMCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent) 149071f73db4a0c3f7f00ef14d38af17f3c8d69827aDaniel Dunbar : Kind(_Kind), Parent(_Parent), Atom(0), EffectiveSize(~UINT64_C(0)) 150fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar{ 1515e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar if (Parent) 1525e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar Parent->getFragmentList().push_back(this); 153fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar} 154fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 1550705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel DunbarMCFragment::~MCFragment() { 1560705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 1570705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 158fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar/* *** */ 159fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 16081e400092f55c2eba157172bfc0dd0df8317638dDaniel DunbarMCSectionData::MCSectionData() : Section(0) {} 161fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 162fb4a6b397665df011348ade24a8e38d2219f095aDaniel DunbarMCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A) 16381e400092f55c2eba157172bfc0dd0df8317638dDaniel Dunbar : Section(&_Section), 164fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar Alignment(1), 1655e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar Address(~UINT64_C(0)), 166e1ec617c6abf0b9dc1eecbbfe483bda3bb2b7795Daniel Dunbar HasInstructions(false) 167fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar{ 168fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar if (A) 169fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar A->getSectionList().push_back(this); 170fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar} 171fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 172fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar/* *** */ 173fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 174efbb5330b8d383a393c83d2da5d631c98b0bb3fdDaniel DunbarMCSymbolData::MCSymbolData() : Symbol(0) {} 175f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar 176cb579b3338fe8d9e4424b138f597a4696cb89de3Daniel DunbarMCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment, 177f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar uint64_t _Offset, MCAssembler *A) 178efbb5330b8d383a393c83d2da5d631c98b0bb3fdDaniel Dunbar : Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset), 1798f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar IsExternal(false), IsPrivateExtern(false), 1808f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar CommonSize(0), CommonAlign(0), Flags(0), Index(0) 181f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar{ 182f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar if (A) 183f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar A->getSymbolList().push_back(this); 184f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar} 185f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar 186f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar/* *** */ 187f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar 1881f3e445184e5ca2aa4295c2a77f2a4e0b957fea1Daniel DunbarMCAssembler::MCAssembler(MCContext &_Context, TargetAsmBackend &_Backend, 189cf871e5abff63a53f9e97ff9e37fb7297d0cb847Daniel Dunbar MCCodeEmitter &_Emitter, raw_ostream &_OS) 190cf871e5abff63a53f9e97ff9e37fb7297d0cb847Daniel Dunbar : Context(_Context), Backend(_Backend), Emitter(_Emitter), 191ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar OS(_OS), RelaxAll(false), SubsectionsViaSymbols(false) 1926009db486e7fba448ccb28dff676c012efade8f0Daniel Dunbar{ 1936009db486e7fba448ccb28dff676c012efade8f0Daniel Dunbar} 194fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 195fb4a6b397665df011348ade24a8e38d2219f095aDaniel DunbarMCAssembler::~MCAssembler() { 196fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar} 197fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 198939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbarstatic bool isScatteredFixupFullyResolvedSimple(const MCAssembler &Asm, 199939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCAsmFixup &Fixup, 200939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCValue Target, 201939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCSection *BaseSection) { 202939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // The effective fixup address is 203939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // addr(atom(A)) + offset(A) 204939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // - addr(atom(B)) - offset(B) 205939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // - addr(<base symbol>) + <fixup offset from base symbol> 206939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // and the offsets are not relocatable, so the fixup is fully resolved when 207939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0. 208939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // 209939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // The simple (Darwin, except on x86_64) way of dealing with this was to 210939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // assume that any reference to a temporary symbol *must* be a temporary 211939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // symbol in the same atom, unless the sections differ. Therefore, any PCrel 212939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // relocation to a temporary symbol (in the same section) is fully 213939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // resolved. This also works in conjunction with absolutized .set, which 214939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // requires the compiler to use .set to absolutize the differences between 215939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // symbols which the compiler knows to be assembly time constants, so we don't 21631e8e1d08566c9b169df003d499a7e22856e5408Daniel Dunbar // need to worry about considering symbol differences fully resolved. 217939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 218939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // Non-relative fixups are only resolved if constant. 219939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (!BaseSection) 220939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return Target.isAbsolute(); 221939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 222939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // Otherwise, relative fixups are only resolved if not a difference and the 223939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // target is a temporary in the same section. 224939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (Target.isAbsolute() || Target.getSymB()) 225939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return false; 226939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 227939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCSymbol *A = &Target.getSymA()->getSymbol(); 228939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (!A->isTemporary() || !A->isInSection() || 229939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar &A->getSection() != BaseSection) 230939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return false; 231939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 232939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return true; 233939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar} 234939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 235034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbarstatic bool isScatteredFixupFullyResolved(const MCAssembler &Asm, 236207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar const MCAsmLayout &Layout, 237034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCAsmFixup &Fixup, 238034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCValue Target, 239034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCSymbolData *BaseSymbol) { 240034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // The effective fixup address is 241034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // addr(atom(A)) + offset(A) 242034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // - addr(atom(B)) - offset(B) 243034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // - addr(BaseSymbol) + <fixup offset from base symbol> 244034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // and the offsets are not relocatable, so the fixup is fully resolved when 245034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0. 246034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // 247034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Note that "false" is almost always conservatively correct (it means we emit 248034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // a relocation which is unnecessary), except when it would force us to emit a 249034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // relocation which the target cannot encode. 250034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 251034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCSymbolData *A_Base = 0, *B_Base = 0; 252034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (const MCSymbolRefExpr *A = Target.getSymA()) { 253034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Modified symbol references cannot be resolved. 254034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (A->getKind() != MCSymbolRefExpr::VK_None) 255034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 256034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 257207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar A_Base = Asm.getAtom(Layout, &Asm.getSymbolData(A->getSymbol())); 258034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!A_Base) 259034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 260034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar } 261034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 262034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (const MCSymbolRefExpr *B = Target.getSymB()) { 263034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Modified symbol references cannot be resolved. 264034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (B->getKind() != MCSymbolRefExpr::VK_None) 265034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 266034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 267207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar B_Base = Asm.getAtom(Layout, &Asm.getSymbolData(B->getSymbol())); 268034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!B_Base) 269034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 270034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar } 271034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 272034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // If there is no base, A and B have to be the same atom for this fixup to be 273034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // fully resolved. 274034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!BaseSymbol) 275034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return A_Base == B_Base; 276034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 277034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Otherwise, B must be missing and A must be the base. 278034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return !B_Base && BaseSymbol == A_Base; 279034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar} 280034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 281238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbarbool MCAssembler::isSymbolLinkerVisible(const MCSymbolData *SD) const { 282238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar // Non-temporary labels should always be visible to the linker. 283238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar if (!SD->getSymbol().isTemporary()) 284238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar return true; 285238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar 286238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar // Absolute temporary labels are never visible. 287238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar if (!SD->getFragment()) 288238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar return false; 289238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar 290238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar // Otherwise, check if the section requires symbols even for temporary labels. 291238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar return getBackend().doesSectionRequireSymbols( 292238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar SD->getFragment()->getParent()->getSection()); 293238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar} 294238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar 295207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbarconst MCSymbolData *MCAssembler::getAtom(const MCAsmLayout &Layout, 296207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar const MCSymbolData *SD) const { 2978ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Linker visible symbols define atoms. 2988ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar if (isSymbolLinkerVisible(SD)) 2998ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar return SD; 3008ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3018ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Absolute and undefined symbols have no defining atom. 3028ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar if (!SD->getFragment()) 3038ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar return 0; 3048ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 305a5f1d57f65ae601ec181c0f4e36cf0df5e8d79d8Daniel Dunbar // Non-linker visible symbols in sections which can't be atomized have no 306a5f1d57f65ae601ec181c0f4e36cf0df5e8d79d8Daniel Dunbar // defining atom. 307a5f1d57f65ae601ec181c0f4e36cf0df5e8d79d8Daniel Dunbar if (!getBackend().isSectionAtomizable( 308a5f1d57f65ae601ec181c0f4e36cf0df5e8d79d8Daniel Dunbar SD->getFragment()->getParent()->getSection())) 309a5f1d57f65ae601ec181c0f4e36cf0df5e8d79d8Daniel Dunbar return 0; 310a5f1d57f65ae601ec181c0f4e36cf0df5e8d79d8Daniel Dunbar 311651804c3d63a05f72221a6d133e5b344e6aaa093Daniel Dunbar // Otherwise, return the atom for the containing fragment. 312651804c3d63a05f72221a6d133e5b344e6aaa093Daniel Dunbar return SD->getFragment()->getAtom(); 3138ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar} 3148ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3159d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbarbool MCAssembler::EvaluateFixup(const MCAsmLayout &Layout, 3169d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbar const MCAsmFixup &Fixup, const MCFragment *DF, 317df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar MCValue &Target, uint64_t &Value) const { 318ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::EvaluateFixup; 319ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 320df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar if (!Fixup.Value->EvaluateAsRelocatable(Target, &Layout)) 32175361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("expected relocatable expression"); 322df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 323df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar // FIXME: How do non-scattered symbols work in ELF? I presume the linker 324df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar // doesn't support small relocations, but then under what criteria does the 325df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar // assembler allow symbol differences? 326df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 327df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar Value = Target.getConstant(); 328df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 329b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar bool IsPCRel = 330b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar Emitter.getFixupKindInfo(Fixup.Kind).Flags & MCFixupKindInfo::FKF_IsPCRel; 331b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar bool IsResolved = true; 3329a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (const MCSymbolRefExpr *A = Target.getSymA()) { 3339a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (A->getSymbol().isDefined()) 334207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Value += Layout.getSymbolAddress(&getSymbolData(A->getSymbol())); 335df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar else 336df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar IsResolved = false; 337df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar } 3389a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (const MCSymbolRefExpr *B = Target.getSymB()) { 3399a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (B->getSymbol().isDefined()) 340207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Value -= Layout.getSymbolAddress(&getSymbolData(B->getSymbol())); 341df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar else 342df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar IsResolved = false; 343939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar } 344df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 345939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // If we are using scattered symbols, determine whether this value is actually 346939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // resolved; scattering may cause atoms to move. 347939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (IsResolved && getBackend().hasScatteredSymbols()) { 348939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (getBackend().hasReliableSymbolDifference()) { 349034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // If this is a PCrel relocation, find the base atom (identified by its 350034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // symbol) that the fixup value is relative to. 351034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCSymbolData *BaseSymbol = 0; 352034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (IsPCRel) { 353651804c3d63a05f72221a6d133e5b344e6aaa093Daniel Dunbar BaseSymbol = DF->getAtom(); 354034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!BaseSymbol) 355034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar IsResolved = false; 356034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar } 357034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 358034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (IsResolved) 359207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar IsResolved = isScatteredFixupFullyResolved(*this, Layout, Fixup, Target, 360034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar BaseSymbol); 361939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar } else { 362939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCSection *BaseSection = 0; 363939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (IsPCRel) 364939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar BaseSection = &DF->getParent()->getSection(); 365939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 366c6f598209a6ffc1e5273d867c7fd545359c4f209Daniel Dunbar IsResolved = isScatteredFixupFullyResolvedSimple(*this, Fixup, Target, 367939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar BaseSection); 368939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar } 369df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar } 370df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 371df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar if (IsPCRel) 372207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Value -= Layout.getFragmentAddress(DF) + Fixup.Offset; 373df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 374df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar return IsResolved; 375df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar} 376df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 3772c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbaruint64_t MCAssembler::ComputeFragmentSize(MCAsmLayout &Layout, 3782c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar const MCFragment &F, 3792c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar uint64_t SectionAddress, 3802c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar uint64_t FragmentOffset) const { 381f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar switch (F.getKind()) { 3822c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar case MCFragment::FT_Data: 3832c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return cast<MCDataFragment>(F).getContents().size(); 3842c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar case MCFragment::FT_Fill: 3852c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return cast<MCFillFragment>(F).getSize(); 3862c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar case MCFragment::FT_Inst: 3872c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return cast<MCInstFragment>(F).getInstSize(); 3882c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar 389f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar case MCFragment::FT_Align: { 3902c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar const MCAlignFragment &AF = cast<MCAlignFragment>(F); 391f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 392456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar assert((!AF.hasOnlyAlignAddress() || !AF.getNextNode()) && 393456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar "Invalid OnlyAlignAddress bit, not the last fragment!"); 394456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar 3952c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar uint64_t Size = OffsetToAlignment(SectionAddress + FragmentOffset, 3962c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar AF.getAlignment()); 397f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 3982c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar // Honor MaxBytesToEmit. 3992c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar if (Size > AF.getMaxBytesToEmit()) 4002c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return 0; 401f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 4022c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return Size; 403f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar } 404f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 405f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar case MCFragment::FT_Org: { 4062c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar const MCOrgFragment &OF = cast<MCOrgFragment>(F); 407f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 4082c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar // FIXME: We should compute this sooner, we don't want to recurse here, and 4092c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar // we would like to be more functional. 410f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar int64_t TargetLocation; 411f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar if (!OF.getOffset().EvaluateAsAbsolute(TargetLocation, &Layout)) 412f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar report_fatal_error("expected assembly-time absolute expression"); 413f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 414f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar // FIXME: We need a way to communicate this error. 415f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar int64_t Offset = TargetLocation - FragmentOffset; 416f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar if (Offset < 0) 417f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar report_fatal_error("invalid .org offset '" + Twine(TargetLocation) + 418f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar "' (at offset '" + Twine(FragmentOffset) + "'"); 419f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 4202c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return Offset; 421f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar } 422f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar } 423f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 4242c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar assert(0 && "invalid fragment kind"); 4252c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar return 0; 4262c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar} 4272c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar 428b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbarvoid MCAsmLayout::LayoutFile() { 429b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar for (unsigned i = 0, e = getSectionOrder().size(); i != e; ++i) 430b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar LayoutSection(getSectionOrder()[i]); 431b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar} 432b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar 433b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbarvoid MCAsmLayout::LayoutFragment(MCFragment *F) { 434b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar uint64_t StartAddress = getSectionAddress(F->getParent()); 4352c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar 4362c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar // Get the fragment start address. 4372c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar uint64_t Address = StartAddress; 438b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar MCSectionData::iterator it = F; 439b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar if (MCFragment *Prev = F->getPrevNode()) 440b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar Address = (StartAddress + getFragmentOffset(Prev) + 441b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar getFragmentEffectiveSize(Prev)); 4422c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar 4432c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar ++stats::FragmentLayouts; 4442c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar 445b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar // Compute fragment offset and size. 446b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar uint64_t Offset = Address - StartAddress; 447b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar uint64_t EffectiveSize = 448b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar getAssembler().ComputeFragmentSize(*this, *F, StartAddress, Offset); 4492c18d3b0fec25b2b7befc7ac5751e84005f4a869Daniel Dunbar 450b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar setFragmentOffset(F, Offset); 451b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar setFragmentEffectiveSize(F, EffectiveSize); 452f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar} 453f0d17d2461a6458568672f611ba4a590d26b1e1aDaniel Dunbar 454b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbarvoid MCAsmLayout::LayoutSection(MCSectionData *SD) { 455b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar unsigned SectionOrderIndex = SD->getLayoutOrder(); 456f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar 457ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar ++stats::SectionLayouts; 458ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar 45961066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Compute the section start address. 460d13a0caf726e05c9bd939d752ef371d6d467ef28Daniel Dunbar uint64_t StartAddress = 0; 461d13a0caf726e05c9bd939d752ef371d6d467ef28Daniel Dunbar if (SectionOrderIndex) { 462b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar MCSectionData *Prev = getSectionOrder()[SectionOrderIndex - 1]; 463b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar StartAddress = getSectionAddress(Prev) + getSectionAddressSize(Prev); 464d13a0caf726e05c9bd939d752ef371d6d467ef28Daniel Dunbar } 465d13a0caf726e05c9bd939d752ef371d6d467ef28Daniel Dunbar 46661066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Honor the section alignment requirements. 467b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar StartAddress = RoundUpToAlignment(StartAddress, SD->getAlignment()); 468f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar 46961066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Set the section address. 470b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar setSectionAddress(SD, StartAddress); 4710705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 472b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar for (MCSectionData::iterator it = SD->begin(), ie = SD->end(); it != ie; ++it) 473b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar LayoutFragment(it); 4740705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 4750705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 47653b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar/// WriteFragmentData - Write the \arg F data to the output file. 477432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbarstatic void WriteFragmentData(const MCAssembler &Asm, const MCAsmLayout &Layout, 478432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar const MCFragment &F, MCObjectWriter *OW) { 47953b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar uint64_t Start = OW->getStream().tell(); 4800705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar (void) Start; 4817eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 482ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::EmittedFragments; 4830adcd35f78b89bf70eb634b7f9ac2103516ca2b2Daniel Dunbar 4840705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar // FIXME: Embed in fragments instead? 485432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar uint64_t FragmentSize = Layout.getFragmentEffectiveSize(&F); 4860705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar switch (F.getKind()) { 487d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Align: { 488d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar MCAlignFragment &AF = cast<MCAlignFragment>(F); 489432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar uint64_t Count = FragmentSize / AF.getValueSize(); 490d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 491e73d49eda2cb4fc30b52c4a241acf69c8af98302Daniel Dunbar assert(AF.getValueSize() && "Invalid virtual align in concrete fragment!"); 492e73d49eda2cb4fc30b52c4a241acf69c8af98302Daniel Dunbar 493d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // FIXME: This error shouldn't actually occur (the front end should emit 494d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // multiple .align directives to enforce the semantics it wants), but is 495d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // severe enough that we want to report it. How to handle this? 496432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar if (Count * AF.getValueSize() != FragmentSize) 49775361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("undefined .align directive, value size '" + 4987eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar Twine(AF.getValueSize()) + 499d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar "' is not a divisor of padding size '" + 500432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Twine(FragmentSize) + "'"); 501d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 5026e72048add2a6464e038121c6c275da37528aa0aKevin Enderby // See if we are aligning with nops, and if so do that first to try to fill 5036e72048add2a6464e038121c6c275da37528aa0aKevin Enderby // the Count bytes. Then if that did not fill any bytes or there are any 5046e72048add2a6464e038121c6c275da37528aa0aKevin Enderby // bytes left to fill use the the Value and ValueSize to fill the rest. 5058f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar // If we are aligning with nops, ask that target to emit the right data. 5061c15413ebc8f4a35545a381a789a718627396d03Daniel Dunbar if (AF.hasEmitNops()) { 5078f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar if (!Asm.getBackend().WriteNopData(Count, OW)) 50875361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("unable to write nop sequence of " + 5098f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar Twine(Count) + " bytes"); 5108f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar break; 5116e72048add2a6464e038121c6c275da37528aa0aKevin Enderby } 5126e72048add2a6464e038121c6c275da37528aa0aKevin Enderby 5138f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar // Otherwise, write out in multiples of the value size. 514d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar for (uint64_t i = 0; i != Count; ++i) { 515d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar switch (AF.getValueSize()) { 516d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar default: 517d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar assert(0 && "Invalid size!"); 518bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 1: OW->Write8 (uint8_t (AF.getValue())); break; 519bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 2: OW->Write16(uint16_t(AF.getValue())); break; 520bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 4: OW->Write32(uint32_t(AF.getValue())); break; 521bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 8: OW->Write64(uint64_t(AF.getValue())); break; 522d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 523d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 524d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 525d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 5260705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 5273a30b827a5c9bf0ed8f31177b6e447083ce9afecDaniel Dunbar case MCFragment::FT_Data: { 5283f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCDataFragment &DF = cast<MCDataFragment>(F); 529432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(FragmentSize == DF.getContents().size() && "Invalid size!"); 5303f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OW->WriteBytes(DF.getContents().str()); 5310705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar break; 5323a30b827a5c9bf0ed8f31177b6e447083ce9afecDaniel Dunbar } 5330705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 5340705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar case MCFragment::FT_Fill: { 5350705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar MCFillFragment &FF = cast<MCFillFragment>(F); 536e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar 537e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar assert(FF.getValueSize() && "Invalid virtual align in concrete fragment!"); 538e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar 5393153fec733acd079a9e681d16d39253b9517e02cDaniel Dunbar for (uint64_t i = 0, e = FF.getSize() / FF.getValueSize(); i != e; ++i) { 5400705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar switch (FF.getValueSize()) { 5410705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar default: 5420705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar assert(0 && "Invalid size!"); 543bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 1: OW->Write8 (uint8_t (FF.getValue())); break; 544bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 2: OW->Write16(uint16_t(FF.getValue())); break; 545bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 4: OW->Write32(uint32_t(FF.getValue())); break; 546bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 8: OW->Write64(uint64_t(FF.getValue())); break; 5470705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5480705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5490705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar break; 5500705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5517eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 5523f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar case MCFragment::FT_Inst: 5533f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar llvm_unreachable("unexpected inst fragment after lowering"); 5543f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar break; 5553f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 556d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Org: { 557d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar MCOrgFragment &OF = cast<MCOrgFragment>(F); 558d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 559432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar for (uint64_t i = 0, e = FragmentSize; i != e; ++i) 560bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar OW->Write8(uint8_t(OF.getValue())); 561d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 562d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 563d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 5640705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5650705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 566432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(OW->getStream().tell() - Start == FragmentSize); 5670705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 5680705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 56953b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbarvoid MCAssembler::WriteSectionData(const MCSectionData *SD, 570432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar const MCAsmLayout &Layout, 57153b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar MCObjectWriter *OW) const { 572d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // Ignore virtual sections. 573cc5b84c6fba79a798e86ea604e54ca9429273a13Daniel Dunbar if (getBackend().isVirtualSection(SD->getSection())) { 574054be92e1da7015190377d6bade57196f28cf33aDaniel Dunbar assert(Layout.getSectionFileSize(SD) == 0 && "Invalid size for section!"); 575e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar 576e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar // Check that contents are only things legal inside a virtual section. 577e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar for (MCSectionData::const_iterator it = SD->begin(), 578e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar ie = SD->end(); it != ie; ++it) { 579e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar switch (it->getKind()) { 580e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar default: 581e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar assert(0 && "Invalid fragment in virtual section!"); 582e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar case MCFragment::FT_Align: 583e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar assert(!cast<MCAlignFragment>(it)->getValueSize() && 584e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar "Invalid align in virtual section!"); 585e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar break; 586e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar case MCFragment::FT_Fill: 587e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar assert(!cast<MCFillFragment>(it)->getValueSize() && 588e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar "Invalid fill in virtual section!"); 589e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar break; 590e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar } 591e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar } 592e2fee5b2369b4d6c31d3ad3b0a7d257e6df22041Daniel Dunbar 593d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar return; 594d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar } 595d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 59653b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar uint64_t Start = OW->getStream().tell(); 5970705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar (void) Start; 5987eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 59953b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar for (MCSectionData::const_iterator it = SD->begin(), 60053b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar ie = SD->end(); it != ie; ++it) 601432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar WriteFragmentData(*this, Layout, *it, OW); 6020705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 603054be92e1da7015190377d6bade57196f28cf33aDaniel Dunbar assert(OW->getStream().tell() - Start == Layout.getSectionFileSize(SD)); 6040705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 6050705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 606fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbarvoid MCAssembler::Finish() { 607b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar DEBUG_WITH_TYPE("mc-dump", { 608b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar llvm::errs() << "assembler backend - pre-layout\n--\n"; 609b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar dump(); }); 610b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 61161066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Create the layout object. 6128d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbar MCAsmLayout Layout(*this); 61361066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar 614f60c736c64d6c9d683df1cead3631958359c14f1Daniel Dunbar // Assign layout order indices. 615f60c736c64d6c9d683df1cead3631958359c14f1Daniel Dunbar for (unsigned i = 0, e = Layout.getSectionOrder().size(); i != e; ++i) 616f60c736c64d6c9d683df1cead3631958359c14f1Daniel Dunbar Layout.getSectionOrder()[i]->setLayoutOrder(i); 617f60c736c64d6c9d683df1cead3631958359c14f1Daniel Dunbar 61861066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Insert additional align fragments for concrete sections to explicitly pad 61961066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // the previous section to match their alignment requirements. This is for 62061066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // 'gas' compatibility, it shouldn't strictly be necessary. 62161066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // 62261066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // FIXME: This may be Mach-O specific. 62361066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar for (unsigned i = 1, e = Layout.getSectionOrder().size(); i < e; ++i) { 62461066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar MCSectionData *SD = Layout.getSectionOrder()[i]; 62561066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar 62661066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Ignore sections without alignment requirements. 62761066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar unsigned Align = SD->getAlignment(); 62861066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar if (Align <= 1) 62961066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar continue; 63061066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar 63161066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Ignore virtual sections, they don't cause file size modifications. 63261066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar if (getBackend().isVirtualSection(SD->getSection())) 63361066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar continue; 63461066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar 63561066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Otherwise, create a new align fragment at the end of the previous 63661066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // section. 63761066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar MCAlignFragment *AF = new MCAlignFragment(Align, 0, 1, Align, 63861066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar Layout.getSectionOrder()[i - 1]); 63961066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar AF->setOnlyAlignAddress(true); 64061066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar } 64161066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar 64249ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar // Assign section and fragment ordinals, all subsequent backend code is 64349ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar // responsible for updating these in place. 64449ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar unsigned SectionIndex = 0; 64549ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar unsigned FragmentIndex = 0; 64649ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) { 64749ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar // Create dummy fragments to eliminate any empty sections, this simplifies 64849ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar // layout. 64949ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar if (it->getFragmentList().empty()) { 65049ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar unsigned ValueSize = 1; 65149ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar if (getBackend().isVirtualSection(it->getSection())) 65249ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar ValueSize = 1; 65349ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar new MCFillFragment(0, 1, 0, it); 65449ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar } 65549ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar 65649ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar it->setOrdinal(SectionIndex++); 65749ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar 65849ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar for (MCSectionData::iterator it2 = it->begin(), 65949ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar ie2 = it->end(); it2 != ie2; ++it2) 66049ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar it2->setOrdinal(FragmentIndex++); 66149ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar } 66249ed9211905ec586f1d23a7f337d335ae63b4635Daniel Dunbar 66361066dbdf2f035e146c11a40d4cf6531cf2dfd6cDaniel Dunbar // Layout until everything fits. 6648d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbar while (LayoutOnce(Layout)) 665f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar continue; 666f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 667f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar DEBUG_WITH_TYPE("mc-dump", { 6683f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar llvm::errs() << "assembler backend - post-relaxation\n--\n"; 6693f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar dump(); }); 6703f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 6713f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Finalize the layout, including fragment lowering. 6723f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar FinishLayout(Layout); 6733f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 6743f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar DEBUG_WITH_TYPE("mc-dump", { 6753f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar llvm::errs() << "assembler backend - final-layout\n--\n"; 676f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar dump(); }); 677f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 678ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar uint64_t StartOffset = OS.tell(); 6791a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar llvm::OwningPtr<MCObjectWriter> Writer(getBackend().createObjectWriter(OS)); 6801a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar if (!Writer) 68175361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("unable to create object writer!"); 682bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar 683bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar // Allow the object writer a chance to perform post-layout binding (for 684bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar // example, to set the index fields in the symbol data). 6851a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar Writer->ExecutePostLayoutBinding(*this); 686bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar 687b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // Evaluate and apply the fixups, generating relocation entries as necessary. 688b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) { 689b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar for (MCSectionData::iterator it2 = it->begin(), 690b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar ie2 = it->end(); it2 != ie2; ++it2) { 691b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar MCDataFragment *DF = dyn_cast<MCDataFragment>(it2); 692b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar if (!DF) 693b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar continue; 694b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 695b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar for (MCDataFragment::fixup_iterator it3 = DF->fixup_begin(), 696b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar ie3 = DF->fixup_end(); it3 != ie3; ++it3) { 697b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar MCAsmFixup &Fixup = *it3; 698b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 699b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // Evaluate the fixup. 700b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar MCValue Target; 701b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar uint64_t FixedValue; 702b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar if (!EvaluateFixup(Layout, Fixup, DF, Target, FixedValue)) { 703b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // The fixup was unresolved, we need a relocation. Inform the object 704b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // writer of the relocation, and give it an opportunity to adjust the 705b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // fixup value if need be. 706207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Writer->RecordRelocation(*this, Layout, DF, Fixup, Target,FixedValue); 707b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 708b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 70987190c473c216e481e0a70475577e496b3a3449eDaniel Dunbar getBackend().ApplyFixup(Fixup, *DF, FixedValue); 710b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 711b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 712b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 713b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 714bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar // Write the object file. 715207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Writer->WriteObject(*this, Layout); 716f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar OS.flush(); 717ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 718ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar stats::ObjectBytes += OS.tell() - StartOffset; 719f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar} 720f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 7219d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbarbool MCAssembler::FixupNeedsRelaxation(const MCAsmFixup &Fixup, 7229d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbar const MCFragment *DF, 7238d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbar const MCAsmLayout &Layout) const { 724ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar if (getRelaxAll()) 725ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar return true; 726ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar 727f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar // If we cannot resolve the fixup value, it requires relaxation. 728f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar MCValue Target; 729f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar uint64_t Value; 730f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar if (!EvaluateFixup(Layout, Fixup, DF, Target, Value)) 731f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar return true; 732f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 733f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar // Otherwise, relax if the value is too big for a (signed) i8. 73431e8e1d08566c9b169df003d499a7e22856e5408Daniel Dunbar // 73531e8e1d08566c9b169df003d499a7e22856e5408Daniel Dunbar // FIXME: This is target dependent! 736f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar return int64_t(Value) != int64_t(int8_t(Value)); 737f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar} 738f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 739d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbarbool MCAssembler::FragmentNeedsRelaxation(const MCInstFragment *IF, 740d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar const MCAsmLayout &Layout) const { 741d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // If this inst doesn't ever need relaxation, ignore it. This occurs when we 742d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // are intentionally pushing out inst fragments, or because we relaxed a 743d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // previous instruction to one that doesn't need relaxation. 744d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar if (!getBackend().MayNeedRelaxation(IF->getInst(), IF->getFixups())) 745d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar return false; 746d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 747d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar for (MCInstFragment::const_fixup_iterator it = IF->fixup_begin(), 748d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar ie = IF->fixup_end(); it != ie; ++it) 749d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar if (FixupNeedsRelaxation(*it, IF, Layout)) 750d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar return true; 751d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 752d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar return false; 753d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar} 754d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 7558d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbarbool MCAssembler::LayoutOnce(MCAsmLayout &Layout) { 756ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::RelaxationSteps; 757ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 758d13a0caf726e05c9bd939d752ef371d6d467ef28Daniel Dunbar // Layout the sections in order. 759b69fc044db8c193348b6611f46432bb21b3cbe90Daniel Dunbar Layout.LayoutFile(); 760d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 761d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Scan for fragments that need relaxation. 7620cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar bool WasRelaxed = false; 763f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 764f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar MCSectionData &SD = *it; 765b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 766f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar for (MCSectionData::iterator it2 = SD.begin(), 767f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar ie2 = SD.end(); it2 != ie2; ++it2) { 768d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Check if this is an instruction fragment that needs relaxation. 769d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar MCInstFragment *IF = dyn_cast<MCInstFragment>(it2); 770d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar if (!IF || !FragmentNeedsRelaxation(IF, Layout)) 771f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar continue; 7720705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 773ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::RelaxedInstructions; 774ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 775d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // FIXME-PERF: We could immediately lower out instructions if we can tell 776d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // they are fully resolved, to avoid retesting on later passes. 777f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 778d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Relax the fragment. 779d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 780d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar MCInst Relaxed; 781d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar getBackend().RelaxInstruction(IF, Relaxed); 782f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 783d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Encode the new instruction. 784d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // 785d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // FIXME-PERF: If it matters, we could let the target do this. It can 786d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // probably do so more efficiently in many cases. 787d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar SmallVector<MCFixup, 4> Fixups; 788d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar SmallString<256> Code; 789d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar raw_svector_ostream VecOS(Code); 790d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar getEmitter().EncodeInstruction(Relaxed, VecOS, Fixups); 791d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar VecOS.flush(); 792d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 793d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Update the instruction fragment. 7940cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar int SlideAmount = Code.size() - IF->getInstSize(); 795d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->setInst(Relaxed); 796d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->getCode() = Code; 797d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->getFixups().clear(); 798d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 799d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar MCFixup &F = Fixups[i]; 800d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->getFixups().push_back(MCAsmFixup(F.getOffset(), *F.getValue(), 801d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar F.getKind())); 802f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar } 803d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 804ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar // Update the layout, and remember that we relaxed. If we are relaxing 805ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar // everything, we can skip this step since nothing will depend on updating 806ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar // the values. 807ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar if (!getRelaxAll()) 808ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar Layout.UpdateForSlide(IF, SlideAmount); 8090cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar WasRelaxed = true; 810f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar } 811f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar } 812f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 8130cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar return WasRelaxed; 814f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar} 815b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 8163f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbarvoid MCAssembler::FinishLayout(MCAsmLayout &Layout) { 8173f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Lower out any instruction fragments, to simplify the fixup application and 8183f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // output. 8193f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // 8203f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // FIXME-PERF: We don't have to do this, but the assumption is that it is 8213f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // cheap (we will mostly end up eliminating fragments and appending on to data 8223f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // fragments), so the extra complexity downstream isn't worth it. Evaluate 8233f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // this assumption. 8243f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 8253f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCSectionData &SD = *it; 8263f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8273f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar for (MCSectionData::iterator it2 = SD.begin(), 8283f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar ie2 = SD.end(); it2 != ie2; ++it2) { 8293f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCInstFragment *IF = dyn_cast<MCInstFragment>(it2); 8303f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar if (!IF) 8313f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar continue; 8323f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8333f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Create a new data fragment for the instruction. 8343f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // 835337055e62f28f18a9a8c4a090633cae1c2256ae1Daniel Dunbar // FIXME-PERF: Reuse previous data fragment if possible. 8363f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCDataFragment *DF = new MCDataFragment(); 8373f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar SD.getFragmentList().insert(it2, DF); 8383f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8393f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Update the data fragments layout data. 8409799de910e97879bf9f30f359551071a94d61570Daniel Dunbar DF->setParent(IF->getParent()); 841651804c3d63a05f72221a6d133e5b344e6aaa093Daniel Dunbar DF->setAtom(IF->getAtom()); 8425a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar DF->setOrdinal(IF->getOrdinal()); 843aa0d350fe54b0bf13947cdb08d8e76e4ec233d6fDaniel Dunbar Layout.FragmentReplaced(IF, DF); 8443f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8459799de910e97879bf9f30f359551071a94d61570Daniel Dunbar // Copy in the data and the fixups. 8469799de910e97879bf9f30f359551071a94d61570Daniel Dunbar DF->getContents().append(IF->getCode().begin(), IF->getCode().end()); 8479799de910e97879bf9f30f359551071a94d61570Daniel Dunbar for (unsigned i = 0, e = IF->getFixups().size(); i != e; ++i) 8489799de910e97879bf9f30f359551071a94d61570Daniel Dunbar DF->getFixups().push_back(IF->getFixups()[i]); 8493f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8503f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Delete the instruction fragment and update the iterator. 8513f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar SD.getFragmentList().erase(IF); 8523f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar it2 = DF; 8533f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar } 8543f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar } 8553f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar} 8563f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 857b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar// Debugging methods 858b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 859b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarnamespace llvm { 860b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 861b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarraw_ostream &operator<<(raw_ostream &OS, const MCAsmFixup &AF) { 8622be2fd073003c0988723d2894dfb117ad90be11bDaniel Dunbar OS << "<MCAsmFixup" << " Offset:" << AF.Offset << " Value:" << *AF.Value 8632be2fd073003c0988723d2894dfb117ad90be11bDaniel Dunbar << " Kind:" << AF.Kind << ">"; 864b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar return OS; 865b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 866b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 867b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 868b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 869b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCFragment::dump() { 870b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 871b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 872b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCFragment " << (void*) this << " Offset:" << Offset 873b5844ff1c44f0427bcf132eaece945da411e650fDaniel Dunbar << " EffectiveSize:" << EffectiveSize << ">"; 874b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 875b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 876b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCAlignFragment::dump() { 877b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 878b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 879b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCAlignFragment "; 880b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 881456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar if (hasEmitNops()) 882456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar OS << " (emit nops)"; 883456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar if (hasOnlyAlignAddress()) 884456b5012704bcece2c8c28783e6efabb7b998616Daniel Dunbar OS << " (only align section)"; 885b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 886b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Alignment:" << getAlignment() 887b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Value:" << getValue() << " ValueSize:" << getValueSize() 888b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " MaxBytesToEmit:" << getMaxBytesToEmit() << ">"; 889b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 890b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 891b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCDataFragment::dump() { 892b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 893b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 894b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCDataFragment "; 895b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 896b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 897b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Contents:["; 898b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (unsigned i = 0, e = getContents().size(); i != e; ++i) { 899b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (i) OS << ","; 900b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF); 901b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 9022be2fd073003c0988723d2894dfb117ad90be11bDaniel Dunbar OS << "] (" << getContents().size() << " bytes)"; 9030bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar 9040bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar if (!getFixups().empty()) { 9050bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << ",\n "; 9060bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << " Fixups:["; 9070bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar for (fixup_iterator it = fixup_begin(), ie = fixup_end(); it != ie; ++it) { 90845aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar if (it != fixup_begin()) OS << ",\n "; 9090bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << *it; 9100bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar } 9110bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << "]"; 9120bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar } 9130bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar 9140bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << ">"; 915b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 916b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 917b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCFillFragment::dump() { 918b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 919b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 920b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCFillFragment "; 921b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 922b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 923b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Value:" << getValue() << " ValueSize:" << getValueSize() 9243153fec733acd079a9e681d16d39253b9517e02cDaniel Dunbar << " Size:" << getSize() << ">"; 925b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 926b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 9273f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbarvoid MCInstFragment::dump() { 9283f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar raw_ostream &OS = llvm::errs(); 9293f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 9303f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << "<MCInstFragment "; 9313f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar this->MCFragment::dump(); 9323f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << "\n "; 9333f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << " Inst:"; 9343f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar getInst().dump_pretty(OS); 9353f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << ">"; 9363f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar} 9373f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 938b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCOrgFragment::dump() { 939b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 940b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 941b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCOrgFragment "; 942b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 943b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 944b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Offset:" << getOffset() << " Value:" << getValue() << ">"; 945b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 946b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 947b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCSectionData::dump() { 948b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 949b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 950b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCSectionData"; 951b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Alignment:" << getAlignment() << " Address:" << Address 9522661f11e4602ad017fa155f6fdcee0a4f2d1ae86Daniel Dunbar << " Fragments:[\n "; 953b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 954b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (it != begin()) OS << ",\n "; 955b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar it->dump(); 956b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 957b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "]>"; 958b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 959b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 960b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCSymbolData::dump() { 961b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 962b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 963b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCSymbolData Symbol:" << getSymbol() 964b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Fragment:" << getFragment() << " Offset:" << getOffset() 965b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Flags:" << getFlags() << " Index:" << getIndex(); 966b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (isCommon()) 967b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " (common, size:" << getCommonSize() 968b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " align: " << getCommonAlignment() << ")"; 969b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (isExternal()) 970b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " (external)"; 971b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (isPrivateExtern()) 972b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " (private extern)"; 973b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << ">"; 974b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 975b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 976b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCAssembler::dump() { 977b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 978b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 979b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCAssembler\n"; 98045aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar OS << " Sections:[\n "; 981b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 982b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (it != begin()) OS << ",\n "; 983b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar it->dump(); 984b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 985b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "],\n"; 986b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Symbols:["; 987b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 988b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) { 98945aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar if (it != symbol_begin()) OS << ",\n "; 990b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar it->dump(); 991b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 992b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "]>\n"; 993b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 994