MCAssembler.cpp revision 31e8e1d08566c9b169df003d499a7e22856e5408
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 500cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbarvoid MCAsmLayout::UpdateForSlide(MCFragment *F, int SlideAmount) { 510cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // We shouldn't have to do anything special to support negative slides, and it 520cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // is a perfectly valid thing to do as long as other parts of the system are 530cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // can guarantee convergence. 540cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar assert(SlideAmount >= 0 && "Negative slides not yet supported"); 550cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 560cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Update the layout by simply recomputing the layout for the entire 570cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // file. This is trivially correct, but very slow. 580cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // 590cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // FIXME-PERF: This is O(N^2), but will be eliminated once we get smarter. 600cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 610cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Layout the concrete sections and fragments. 620cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar MCAssembler &Asm = getAssembler(); 630cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar uint64_t Address = 0; 640cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it) { 650cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Skip virtual sections. 660cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar if (Asm.getBackend().isVirtualSection(it->getSection())) 670cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar continue; 680cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 690cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Layout the section fragments and its size. 700cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar Address = Asm.LayoutSection(*it, *this, Address); 710cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar } 720cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 730cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Layout the virtual sections. 740cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it) { 750cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar if (!Asm.getBackend().isVirtualSection(it->getSection())) 760cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar continue; 770cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 780cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar // Layout the section fragments and its size. 790cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar Address = Asm.LayoutSection(*it, *this, Address); 800cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar } 810cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar} 820cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar 83207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbaruint64_t MCAsmLayout::getFragmentAddress(const MCFragment *F) const { 847c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar assert(F->getParent() && "Missing section()!"); 85432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar return getSectionAddress(F->getParent()) + getFragmentOffset(F); 86432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 87432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 88432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbaruint64_t MCAsmLayout::getFragmentEffectiveSize(const MCFragment *F) const { 89432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(F->EffectiveSize != ~UINT64_C(0) && "Address not set!"); 90432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar return F->EffectiveSize; 91432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 92432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 93432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbarvoid MCAsmLayout::setFragmentEffectiveSize(MCFragment *F, uint64_t Value) { 94432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar F->EffectiveSize = Value; 95432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 96432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 97432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbaruint64_t MCAsmLayout::getFragmentOffset(const MCFragment *F) const { 98432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(F->Offset != ~UINT64_C(0) && "Address not set!"); 99432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar return F->Offset; 100432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar} 101432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar 102432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbarvoid MCAsmLayout::setFragmentOffset(MCFragment *F, uint64_t Value) { 103432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar F->Offset = Value; 104207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 105207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 106207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbaruint64_t MCAsmLayout::getSymbolAddress(const MCSymbolData *SD) const { 1077c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar assert(SD->getFragment() && "Invalid getAddress() on undefined symbol!"); 1087c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar return getFragmentAddress(SD->getFragment()) + SD->getOffset(); 109207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 110207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 111207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbaruint64_t MCAsmLayout::getSectionAddress(const MCSectionData *SD) const { 1127c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar assert(SD->Address != ~UINT64_C(0) && "Address not set!"); 1137c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar return SD->Address; 114207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 115207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 116207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbarvoid MCAsmLayout::setSectionAddress(MCSectionData *SD, uint64_t Value) { 1177c3d45a03e64ac1b5b2ecdb7153989fd7cebfd2cDaniel Dunbar SD->Address = Value; 118207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar} 119207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 1205d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbaruint64_t MCAsmLayout::getSectionSize(const MCSectionData *SD) const { 1215d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar assert(SD->Size != ~UINT64_C(0) && "File size not set!"); 1225d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar return SD->Size; 1235d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar} 1245d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbarvoid MCAsmLayout::setSectionSize(MCSectionData *SD, uint64_t Value) { 1255d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar SD->Size = Value; 1265d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar} 1275d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar 1285d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbaruint64_t MCAsmLayout::getSectionFileSize(const MCSectionData *SD) const { 1295d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar assert(SD->FileSize != ~UINT64_C(0) && "File size not set!"); 1305d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar return SD->FileSize; 1315d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar} 1325d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbarvoid MCAsmLayout::setSectionFileSize(MCSectionData *SD, uint64_t Value) { 1335d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar SD->FileSize = Value; 1345d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar} 1355d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar 1365d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar /// @} 1375d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar 138207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar/* *** */ 139207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 1400705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel DunbarMCFragment::MCFragment() : Kind(FragmentType(~0)) { 1410705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 1420705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 1435e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel DunbarMCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent) 1440705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar : Kind(_Kind), 1455e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar Parent(_Parent), 146432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize(~UINT64_C(0)) 147fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar{ 1485e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar if (Parent) 1495e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar Parent->getFragmentList().push_back(this); 150fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar} 151fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 1520705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel DunbarMCFragment::~MCFragment() { 1530705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 1540705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 155fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar/* *** */ 156fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 15781e400092f55c2eba157172bfc0dd0df8317638dDaniel DunbarMCSectionData::MCSectionData() : Section(0) {} 158fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 159fb4a6b397665df011348ade24a8e38d2219f095aDaniel DunbarMCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A) 16081e400092f55c2eba157172bfc0dd0df8317638dDaniel Dunbar : Section(&_Section), 161fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar Alignment(1), 1625e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar Address(~UINT64_C(0)), 1636742e34385bff89b897ef0fc930c4bca9e75ac4aDaniel Dunbar Size(~UINT64_C(0)), 1643f6a960f9c9ad27f2ac573020df414e8b8cdda04Daniel Dunbar FileSize(~UINT64_C(0)), 165e1ec617c6abf0b9dc1eecbbfe483bda3bb2b7795Daniel Dunbar HasInstructions(false) 166fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar{ 167fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar if (A) 168fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar A->getSectionList().push_back(this); 169fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar} 170fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 171fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar/* *** */ 172fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 173efbb5330b8d383a393c83d2da5d631c98b0bb3fdDaniel DunbarMCSymbolData::MCSymbolData() : Symbol(0) {} 174f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar 175cb579b3338fe8d9e4424b138f597a4696cb89de3Daniel DunbarMCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment, 176f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar uint64_t _Offset, MCAssembler *A) 177efbb5330b8d383a393c83d2da5d631c98b0bb3fdDaniel Dunbar : Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset), 1788f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar IsExternal(false), IsPrivateExtern(false), 1798f4d146c340c9423271ebd7bb3fd32b880000bc9Daniel Dunbar CommonSize(0), CommonAlign(0), Flags(0), Index(0) 180f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar{ 181f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar if (A) 182f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar A->getSymbolList().push_back(this); 183f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar} 184f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar 185f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar/* *** */ 186f3d2ef0c9712381a105118336975adcfbf733db0Daniel Dunbar 1871f3e445184e5ca2aa4295c2a77f2a4e0b957fea1Daniel DunbarMCAssembler::MCAssembler(MCContext &_Context, TargetAsmBackend &_Backend, 188cf871e5abff63a53f9e97ff9e37fb7297d0cb847Daniel Dunbar MCCodeEmitter &_Emitter, raw_ostream &_OS) 189cf871e5abff63a53f9e97ff9e37fb7297d0cb847Daniel Dunbar : Context(_Context), Backend(_Backend), Emitter(_Emitter), 190ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar OS(_OS), RelaxAll(false), SubsectionsViaSymbols(false) 1916009db486e7fba448ccb28dff676c012efade8f0Daniel Dunbar{ 1926009db486e7fba448ccb28dff676c012efade8f0Daniel Dunbar} 193fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 194fb4a6b397665df011348ade24a8e38d2219f095aDaniel DunbarMCAssembler::~MCAssembler() { 195fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar} 196fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbar 197939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbarstatic bool isScatteredFixupFullyResolvedSimple(const MCAssembler &Asm, 198939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCAsmFixup &Fixup, 199939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCValue Target, 200939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCSection *BaseSection) { 201939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // The effective fixup address is 202939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // addr(atom(A)) + offset(A) 203939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // - addr(atom(B)) - offset(B) 204939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // - addr(<base symbol>) + <fixup offset from base symbol> 205939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // and the offsets are not relocatable, so the fixup is fully resolved when 206939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0. 207939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // 208939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // The simple (Darwin, except on x86_64) way of dealing with this was to 209939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // assume that any reference to a temporary symbol *must* be a temporary 210939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // symbol in the same atom, unless the sections differ. Therefore, any PCrel 211939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // relocation to a temporary symbol (in the same section) is fully 212939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // resolved. This also works in conjunction with absolutized .set, which 213939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // requires the compiler to use .set to absolutize the differences between 214939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // symbols which the compiler knows to be assembly time constants, so we don't 21531e8e1d08566c9b169df003d499a7e22856e5408Daniel Dunbar // need to worry about considering symbol differences fully resolved. 216939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 217939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // Non-relative fixups are only resolved if constant. 218939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (!BaseSection) 219939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return Target.isAbsolute(); 220939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 221939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // Otherwise, relative fixups are only resolved if not a difference and the 222939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // target is a temporary in the same section. 223939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (Target.isAbsolute() || Target.getSymB()) 224939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return false; 225939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 226939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCSymbol *A = &Target.getSymA()->getSymbol(); 227939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (!A->isTemporary() || !A->isInSection() || 228939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar &A->getSection() != BaseSection) 229939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return false; 230939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 231939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar return true; 232939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar} 233939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 234034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbarstatic bool isScatteredFixupFullyResolved(const MCAssembler &Asm, 235207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar const MCAsmLayout &Layout, 236034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCAsmFixup &Fixup, 237034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCValue Target, 238034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCSymbolData *BaseSymbol) { 239034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // The effective fixup address is 240034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // addr(atom(A)) + offset(A) 241034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // - addr(atom(B)) - offset(B) 242034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // - addr(BaseSymbol) + <fixup offset from base symbol> 243034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // and the offsets are not relocatable, so the fixup is fully resolved when 244034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0. 245034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // 246034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Note that "false" is almost always conservatively correct (it means we emit 247034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // a relocation which is unnecessary), except when it would force us to emit a 248034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // relocation which the target cannot encode. 249034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 250034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCSymbolData *A_Base = 0, *B_Base = 0; 251034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (const MCSymbolRefExpr *A = Target.getSymA()) { 252034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Modified symbol references cannot be resolved. 253034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (A->getKind() != MCSymbolRefExpr::VK_None) 254034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 255034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 256207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar A_Base = Asm.getAtom(Layout, &Asm.getSymbolData(A->getSymbol())); 257034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!A_Base) 258034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 259034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar } 260034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 261034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (const MCSymbolRefExpr *B = Target.getSymB()) { 262034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Modified symbol references cannot be resolved. 263034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (B->getKind() != MCSymbolRefExpr::VK_None) 264034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 265034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 266207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar B_Base = Asm.getAtom(Layout, &Asm.getSymbolData(B->getSymbol())); 267034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!B_Base) 268034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return false; 269034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar } 270034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 271034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // If there is no base, A and B have to be the same atom for this fixup to be 272034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // fully resolved. 273034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!BaseSymbol) 274034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return A_Base == B_Base; 275034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 276034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // Otherwise, B must be missing and A must be the base. 277034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar return !B_Base && BaseSymbol == A_Base; 278034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar} 279034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 280238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbarbool MCAssembler::isSymbolLinkerVisible(const MCSymbolData *SD) const { 281238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar // Non-temporary labels should always be visible to the linker. 282238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar if (!SD->getSymbol().isTemporary()) 283238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar return true; 284238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar 285238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar // Absolute temporary labels are never visible. 286238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar if (!SD->getFragment()) 287238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar return false; 288238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar 289238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar // Otherwise, check if the section requires symbols even for temporary labels. 290238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar return getBackend().doesSectionRequireSymbols( 291238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar SD->getFragment()->getParent()->getSection()); 292238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar} 293238698566311e9dba4092dfa6c0bfe253279702eDaniel Dunbar 294207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar// FIXME-PERF: This routine is really slow. 295207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbarconst MCSymbolData *MCAssembler::getAtomForAddress(const MCAsmLayout &Layout, 296207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar const MCSectionData *Section, 2978ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar uint64_t Address) const { 2988ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar const MCSymbolData *Best = 0; 299207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar uint64_t BestAddress = 0; 300207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar 3018ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar for (MCAssembler::const_symbol_iterator it = symbol_begin(), 3028ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar ie = symbol_end(); it != ie; ++it) { 3038ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Ignore non-linker visible symbols. 3048ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar if (!isSymbolLinkerVisible(it)) 3058ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar continue; 3068ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3078ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Ignore symbols not in the same section. 3088ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar if (!it->getFragment() || it->getFragment()->getParent() != Section) 3098ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar continue; 3108ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3118ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Otherwise, find the closest symbol preceding this address (ties are 3128ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // resolved in favor of the last defined symbol). 313207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar uint64_t SymbolAddress = Layout.getSymbolAddress(it); 314207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar if (SymbolAddress <= Address && (!Best || SymbolAddress >= BestAddress)) { 3158ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar Best = it; 316207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar BestAddress = SymbolAddress; 317207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar } 3188ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar } 3198ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3208ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar return Best; 3218ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar} 3228ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 323207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar// FIXME-PERF: This routine is really slow. 324207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbarconst MCSymbolData *MCAssembler::getAtom(const MCAsmLayout &Layout, 325207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar const MCSymbolData *SD) const { 3268ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Linker visible symbols define atoms. 3278ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar if (isSymbolLinkerVisible(SD)) 3288ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar return SD; 3298ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3308ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Absolute and undefined symbols have no defining atom. 3318ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar if (!SD->getFragment()) 3328ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar return 0; 3338ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3348ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar // Otherwise, search by address. 335207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar return getAtomForAddress(Layout, SD->getFragment()->getParent(), 336207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Layout.getSymbolAddress(SD)); 3378ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar} 3388ad0dccbf2f0c5ecf9fdad93ac0207f6eaabaa1bDaniel Dunbar 3399d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbarbool MCAssembler::EvaluateFixup(const MCAsmLayout &Layout, 3409d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbar const MCAsmFixup &Fixup, const MCFragment *DF, 341df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar MCValue &Target, uint64_t &Value) const { 342ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::EvaluateFixup; 343ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 344df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar if (!Fixup.Value->EvaluateAsRelocatable(Target, &Layout)) 34575361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("expected relocatable expression"); 346df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 347df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar // FIXME: How do non-scattered symbols work in ELF? I presume the linker 348df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar // doesn't support small relocations, but then under what criteria does the 349df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar // assembler allow symbol differences? 350df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 351df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar Value = Target.getConstant(); 352df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 353b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar bool IsPCRel = 354b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar Emitter.getFixupKindInfo(Fixup.Kind).Flags & MCFixupKindInfo::FKF_IsPCRel; 355b36052f0e4f59525b34bb4b56648c9121a8beda8Daniel Dunbar bool IsResolved = true; 3569a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (const MCSymbolRefExpr *A = Target.getSymA()) { 3579a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (A->getSymbol().isDefined()) 358207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Value += Layout.getSymbolAddress(&getSymbolData(A->getSymbol())); 359df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar else 360df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar IsResolved = false; 361df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar } 3629a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (const MCSymbolRefExpr *B = Target.getSymB()) { 3639a1d20042f6a6ec648a3588f9b13264a4570aab0Daniel Dunbar if (B->getSymbol().isDefined()) 364207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Value -= Layout.getSymbolAddress(&getSymbolData(B->getSymbol())); 365df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar else 366df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar IsResolved = false; 367939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar } 368df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 369939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // If we are using scattered symbols, determine whether this value is actually 370939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar // resolved; scattering may cause atoms to move. 371939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (IsResolved && getBackend().hasScatteredSymbols()) { 372939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (getBackend().hasReliableSymbolDifference()) { 373034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // If this is a PCrel relocation, find the base atom (identified by its 374034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar // symbol) that the fixup value is relative to. 375034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar const MCSymbolData *BaseSymbol = 0; 376034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (IsPCRel) { 377034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar BaseSymbol = getAtomForAddress( 378207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Layout, DF->getParent(), Layout.getFragmentAddress(DF)+Fixup.Offset); 379034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (!BaseSymbol) 380034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar IsResolved = false; 381034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar } 382034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar 383034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar if (IsResolved) 384207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar IsResolved = isScatteredFixupFullyResolved(*this, Layout, Fixup, Target, 385034843ac8bca36d14ef9d83b50596354b5f3420fDaniel Dunbar BaseSymbol); 386939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar } else { 387939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar const MCSection *BaseSection = 0; 388939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar if (IsPCRel) 389939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar BaseSection = &DF->getParent()->getSection(); 390939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar 391c6f598209a6ffc1e5273d867c7fd545359c4f209Daniel Dunbar IsResolved = isScatteredFixupFullyResolvedSimple(*this, Fixup, Target, 392939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar BaseSection); 393939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6Daniel Dunbar } 394df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar } 395df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 396df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar if (IsPCRel) 397207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Value -= Layout.getFragmentAddress(DF) + Fixup.Offset; 398df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 399df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar return IsResolved; 400df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar} 401df3c8f29691a1e3f9ac4afbf05be52dbc898dae9Daniel Dunbar 402f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbaruint64_t MCAssembler::LayoutSection(MCSectionData &SD, 403f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar MCAsmLayout &Layout, 404f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar uint64_t StartAddress) { 405f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar bool IsVirtual = getBackend().isVirtualSection(SD.getSection()); 406f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar 407ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar ++stats::SectionLayouts; 408ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar 409f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // Align this section if necessary by adding padding bytes to the previous 410f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // section. It is safe to adjust this out-of-band, because no symbol or 411f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // fragment is allowed to point past the end of the section at any time. 412f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar if (uint64_t Pad = OffsetToAlignment(StartAddress, SD.getAlignment())) { 413f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // Unless this section is virtual (where we are allowed to adjust the offset 414f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // freely), the padding goes in the previous section. 415f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar if (!IsVirtual) { 416f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // Find the previous non-virtual section. 417f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar iterator it = &SD; 418f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar assert(it != begin() && "Invalid initial section address!"); 419f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar for (--it; getBackend().isVirtualSection(it->getSection()); --it) ; 420f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar Layout.setSectionFileSize(&*it, Layout.getSectionFileSize(&*it) + Pad); 421f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar } 422f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar 423f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar StartAddress += Pad; 424f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar } 425f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar 426f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // Set the aligned section address. 427be644a38c09bd0fa03bb07f48f2c1dec32052de8Daniel Dunbar Layout.setSectionAddress(&SD, StartAddress); 4280705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 429be644a38c09bd0fa03bb07f48f2c1dec32052de8Daniel Dunbar uint64_t Address = StartAddress; 4300705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar for (MCSectionData::iterator it = SD.begin(), ie = SD.end(); it != ie; ++it) { 4310705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar MCFragment &F = *it; 432d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 433ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar ++stats::FragmentLayouts; 434ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar 435432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar uint64_t FragmentOffset = Address - StartAddress; 436432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Layout.setFragmentOffset(&F, FragmentOffset); 437d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 438d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // Evaluate fragment size. 439432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar uint64_t EffectiveSize = 0; 440d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar switch (F.getKind()) { 441d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Align: { 442d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar MCAlignFragment &AF = cast<MCAlignFragment>(F); 4437eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 444432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = OffsetToAlignment(Address, AF.getAlignment()); 445432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar if (EffectiveSize > AF.getMaxBytesToEmit()) 446432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = 0; 447d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 448d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 449d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 450d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Data: 451432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = cast<MCDataFragment>(F).getContents().size(); 452d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 453d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 4542a6e3f5be21fdcb1fa81533ec81ba879df815607Daniel Dunbar case MCFragment::FT_Fill: { 4552a6e3f5be21fdcb1fa81533ec81ba879df815607Daniel Dunbar MCFillFragment &FF = cast<MCFillFragment>(F); 456432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = FF.getValueSize() * FF.getCount(); 4572a6e3f5be21fdcb1fa81533ec81ba879df815607Daniel Dunbar break; 4582a6e3f5be21fdcb1fa81533ec81ba879df815607Daniel Dunbar } 4592a6e3f5be21fdcb1fa81533ec81ba879df815607Daniel Dunbar 4603f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar case MCFragment::FT_Inst: 461432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = cast<MCInstFragment>(F).getInstSize(); 4623f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar break; 4633f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 464d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Org: { 465d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar MCOrgFragment &OF = cast<MCOrgFragment>(F); 466d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 46718ff2cced7e08ac76d8d5bcff8160a5f9a109cbbDaniel Dunbar int64_t TargetLocation; 46818ff2cced7e08ac76d8d5bcff8160a5f9a109cbbDaniel Dunbar if (!OF.getOffset().EvaluateAsAbsolute(TargetLocation, &Layout)) 46975361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("expected assembly-time absolute expression"); 470d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 471d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // FIXME: We need a way to communicate this error. 472432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar int64_t Offset = TargetLocation - FragmentOffset; 47318ff2cced7e08ac76d8d5bcff8160a5f9a109cbbDaniel Dunbar if (Offset < 0) 47475361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("invalid .org offset '" + Twine(TargetLocation) + 475432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar "' (at offset '" + Twine(FragmentOffset) + "'"); 4767eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 477432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = Offset; 478d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 4797eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar } 480d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 481d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar case MCFragment::FT_ZeroFill: { 482d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar MCZeroFillFragment &ZFF = cast<MCZeroFillFragment>(F); 483d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 484d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // Align the fragment offset; it is safe to adjust the offset freely since 485d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // this is only in virtual sections. 486432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar // 487432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar // FIXME: We shouldn't be doing this here. 48837fad5ce4d81fd459fafe1517d6cd17e7ab49958Daniel Dunbar Address = RoundUpToAlignment(Address, ZFF.getAlignment()); 489432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Layout.setFragmentOffset(&F, Address - StartAddress); 490d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 491432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar EffectiveSize = ZFF.getSize(); 492d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar break; 493d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar } 494d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 495d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 496432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Layout.setFragmentEffectiveSize(&F, EffectiveSize); 497432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Address += EffectiveSize; 4980705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 4990705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 5006742e34385bff89b897ef0fc930c4bca9e75ac4aDaniel Dunbar // Set the section sizes. 5015d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar Layout.setSectionSize(&SD, Address - StartAddress); 502f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar if (IsVirtual) 5035d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar Layout.setSectionFileSize(&SD, 0); 504d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar else 5055d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar Layout.setSectionFileSize(&SD, Address - StartAddress); 506f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar 507f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar return Address; 5080705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 5090705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 51053b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar/// WriteFragmentData - Write the \arg F data to the output file. 511432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbarstatic void WriteFragmentData(const MCAssembler &Asm, const MCAsmLayout &Layout, 512432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar const MCFragment &F, MCObjectWriter *OW) { 51353b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar uint64_t Start = OW->getStream().tell(); 5140705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar (void) Start; 5157eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 516ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::EmittedFragments; 5170adcd35f78b89bf70eb634b7f9ac2103516ca2b2Daniel Dunbar 5180705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar // FIXME: Embed in fragments instead? 519432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar uint64_t FragmentSize = Layout.getFragmentEffectiveSize(&F); 5200705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar switch (F.getKind()) { 521d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Align: { 522d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar MCAlignFragment &AF = cast<MCAlignFragment>(F); 523432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar uint64_t Count = FragmentSize / AF.getValueSize(); 524d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 525d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // FIXME: This error shouldn't actually occur (the front end should emit 526d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // multiple .align directives to enforce the semantics it wants), but is 527d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar // severe enough that we want to report it. How to handle this? 528432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar if (Count * AF.getValueSize() != FragmentSize) 52975361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("undefined .align directive, value size '" + 5307eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar Twine(AF.getValueSize()) + 531d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar "' is not a divisor of padding size '" + 532432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Twine(FragmentSize) + "'"); 533d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 5346e72048add2a6464e038121c6c275da37528aa0aKevin Enderby // See if we are aligning with nops, and if so do that first to try to fill 5356e72048add2a6464e038121c6c275da37528aa0aKevin Enderby // the Count bytes. Then if that did not fill any bytes or there are any 5366e72048add2a6464e038121c6c275da37528aa0aKevin Enderby // bytes left to fill use the the Value and ValueSize to fill the rest. 5378f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar // If we are aligning with nops, ask that target to emit the right data. 5386e72048add2a6464e038121c6c275da37528aa0aKevin Enderby if (AF.getEmitNops()) { 5398f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar if (!Asm.getBackend().WriteNopData(Count, OW)) 54075361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("unable to write nop sequence of " + 5418f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar Twine(Count) + " bytes"); 5428f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar break; 5436e72048add2a6464e038121c6c275da37528aa0aKevin Enderby } 5446e72048add2a6464e038121c6c275da37528aa0aKevin Enderby 5458f9b80e5df12779a56d763ebf20864dad2bc72daDaniel Dunbar // Otherwise, write out in multiples of the value size. 546d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar for (uint64_t i = 0; i != Count; ++i) { 547d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar switch (AF.getValueSize()) { 548d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar default: 549d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar assert(0 && "Invalid size!"); 550bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 1: OW->Write8 (uint8_t (AF.getValue())); break; 551bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 2: OW->Write16(uint16_t(AF.getValue())); break; 552bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 4: OW->Write32(uint32_t(AF.getValue())); break; 553bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 8: OW->Write64(uint64_t(AF.getValue())); break; 554d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 555d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 556d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 557d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 5580705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 5593a30b827a5c9bf0ed8f31177b6e447083ce9afecDaniel Dunbar case MCFragment::FT_Data: { 5603f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCDataFragment &DF = cast<MCDataFragment>(F); 561432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(FragmentSize == DF.getContents().size() && "Invalid size!"); 5623f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OW->WriteBytes(DF.getContents().str()); 5630705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar break; 5643a30b827a5c9bf0ed8f31177b6e447083ce9afecDaniel Dunbar } 5650705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 5660705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar case MCFragment::FT_Fill: { 5670705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar MCFillFragment &FF = cast<MCFillFragment>(F); 5680705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar for (uint64_t i = 0, e = FF.getCount(); i != e; ++i) { 5690705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar switch (FF.getValueSize()) { 5700705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar default: 5710705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar assert(0 && "Invalid size!"); 572bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 1: OW->Write8 (uint8_t (FF.getValue())); break; 573bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 2: OW->Write16(uint16_t(FF.getValue())); break; 574bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 4: OW->Write32(uint32_t(FF.getValue())); break; 575bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar case 8: OW->Write64(uint64_t(FF.getValue())); break; 5760705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5770705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5780705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar break; 5790705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5807eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 5813f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar case MCFragment::FT_Inst: 5823f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar llvm_unreachable("unexpected inst fragment after lowering"); 5833f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar break; 5843f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 585d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar case MCFragment::FT_Org: { 586d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar MCOrgFragment &OF = cast<MCOrgFragment>(F); 587d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 588432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar for (uint64_t i = 0, e = FragmentSize; i != e; ++i) 589bdd9281f356d326155dc2ca5585a708e09e90600Daniel Dunbar OW->Write8(uint8_t(OF.getValue())); 590d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar 591d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar break; 592d6f761e0eb610936a6b8495360b62696dcd85164Daniel Dunbar } 593d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 594d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar case MCFragment::FT_ZeroFill: { 595d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar assert(0 && "Invalid zero fill fragment in concrete section!"); 596d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar break; 597d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar } 5980705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar } 5990705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 600432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar assert(OW->getStream().tell() - Start == FragmentSize); 6010705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 6020705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 60353b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbarvoid MCAssembler::WriteSectionData(const MCSectionData *SD, 604432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar const MCAsmLayout &Layout, 60553b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar MCObjectWriter *OW) const { 6065d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar uint64_t SectionSize = Layout.getSectionSize(SD); 6075d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar uint64_t SectionFileSize = Layout.getSectionFileSize(SD); 6085d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar 609d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // Ignore virtual sections. 610cc5b84c6fba79a798e86ea604e54ca9429273a13Daniel Dunbar if (getBackend().isVirtualSection(SD->getSection())) { 6115d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar assert(SectionFileSize == 0 && "Invalid size for section!"); 612d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar return; 613d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar } 614d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 61553b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar uint64_t Start = OW->getStream().tell(); 6160705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar (void) Start; 6177eb85194f2b07bc7ba3f274fc00dc389b77b63bfDaniel Dunbar 61853b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar for (MCSectionData::const_iterator it = SD->begin(), 61953b2338a1d061ad15a858ff0d641431f4d4ac101Daniel Dunbar ie = SD->end(); it != ie; ++it) 620432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar WriteFragmentData(*this, Layout, *it, OW); 6210705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 6226742e34385bff89b897ef0fc930c4bca9e75ac4aDaniel Dunbar // Add section padding. 6235d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar assert(SectionFileSize >= SectionSize && "Invalid section sizes!"); 6245d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar OW->WriteZeros(SectionFileSize - SectionSize); 6256742e34385bff89b897ef0fc930c4bca9e75ac4aDaniel Dunbar 6265d428511ca9607d52a09d3483d0738f483e09934Daniel Dunbar assert(OW->getStream().tell() - Start == SectionFileSize); 6270705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar} 6280705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 629fb4a6b397665df011348ade24a8e38d2219f095aDaniel Dunbarvoid MCAssembler::Finish() { 630b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar DEBUG_WITH_TYPE("mc-dump", { 631b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar llvm::errs() << "assembler backend - pre-layout\n--\n"; 632b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar dump(); }); 633b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 6345a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar // Assign section and fragment ordinals, all subsequent backend code is 6355a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar // responsible for updating these in place. 6365a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar unsigned SectionIndex = 0; 6375a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar unsigned FragmentIndex = 0; 6385a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) { 6395a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar it->setOrdinal(SectionIndex++); 6405a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar 6415a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar for (MCSectionData::iterator it2 = it->begin(), 6425a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar ie2 = it->end(); it2 != ie2; ++it2) 6435a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar it2->setOrdinal(FragmentIndex++); 6445a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar } 6455a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar 646f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar // Layout until everything fits. 6478d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbar MCAsmLayout Layout(*this); 6488d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbar while (LayoutOnce(Layout)) 649f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar continue; 650f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 651f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar DEBUG_WITH_TYPE("mc-dump", { 6523f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar llvm::errs() << "assembler backend - post-relaxation\n--\n"; 6533f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar dump(); }); 6543f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 6553f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Finalize the layout, including fragment lowering. 6563f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar FinishLayout(Layout); 6573f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 6583f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar DEBUG_WITH_TYPE("mc-dump", { 6593f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar llvm::errs() << "assembler backend - final-layout\n--\n"; 660f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar dump(); }); 661f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 662ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar uint64_t StartOffset = OS.tell(); 6631a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar llvm::OwningPtr<MCObjectWriter> Writer(getBackend().createObjectWriter(OS)); 6641a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar if (!Writer) 66575361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("unable to create object writer!"); 666bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar 667bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar // Allow the object writer a chance to perform post-layout binding (for 668bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar // example, to set the index fields in the symbol data). 6691a9158c301b58d8119664f416461d5a5549170c4Daniel Dunbar Writer->ExecutePostLayoutBinding(*this); 670bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar 671b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // Evaluate and apply the fixups, generating relocation entries as necessary. 672b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) { 673b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar for (MCSectionData::iterator it2 = it->begin(), 674b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar ie2 = it->end(); it2 != ie2; ++it2) { 675b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar MCDataFragment *DF = dyn_cast<MCDataFragment>(it2); 676b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar if (!DF) 677b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar continue; 678b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 679b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar for (MCDataFragment::fixup_iterator it3 = DF->fixup_begin(), 680b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar ie3 = DF->fixup_end(); it3 != ie3; ++it3) { 681b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar MCAsmFixup &Fixup = *it3; 682b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 683b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // Evaluate the fixup. 684b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar MCValue Target; 685b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar uint64_t FixedValue; 686b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar if (!EvaluateFixup(Layout, Fixup, DF, Target, FixedValue)) { 687b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // The fixup was unresolved, we need a relocation. Inform the object 688b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // writer of the relocation, and give it an opportunity to adjust the 689b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar // fixup value if need be. 690207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Writer->RecordRelocation(*this, Layout, DF, Fixup, Target,FixedValue); 691b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 692b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 69387190c473c216e481e0a70475577e496b3a3449eDaniel Dunbar getBackend().ApplyFixup(Fixup, *DF, FixedValue); 694b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 695b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 696b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar } 697b1e98945e4b107eb3f2ac1b54706c49864842dc4Daniel Dunbar 698bacba997782f624d3c43591a913b8f1e3d733a52Daniel Dunbar // Write the object file. 699207e06ea0446c51cb1d89f6400ec7becc46487f8Daniel Dunbar Writer->WriteObject(*this, Layout); 700f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar OS.flush(); 701ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 702ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar stats::ObjectBytes += OS.tell() - StartOffset; 703f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar} 704f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 7059d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbarbool MCAssembler::FixupNeedsRelaxation(const MCAsmFixup &Fixup, 7069d39e616cc0f43e91e509e5c8129c7d46327fd0dDaniel Dunbar const MCFragment *DF, 7078d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbar const MCAsmLayout &Layout) const { 708ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar if (getRelaxAll()) 709ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar return true; 710ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar 711f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar // If we cannot resolve the fixup value, it requires relaxation. 712f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar MCValue Target; 713f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar uint64_t Value; 714f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar if (!EvaluateFixup(Layout, Fixup, DF, Target, Value)) 715f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar return true; 716f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 717f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar // Otherwise, relax if the value is too big for a (signed) i8. 71831e8e1d08566c9b169df003d499a7e22856e5408Daniel Dunbar // 71931e8e1d08566c9b169df003d499a7e22856e5408Daniel Dunbar // FIXME: This is target dependent! 720f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar return int64_t(Value) != int64_t(int8_t(Value)); 721f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar} 722f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 723d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbarbool MCAssembler::FragmentNeedsRelaxation(const MCInstFragment *IF, 724d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar const MCAsmLayout &Layout) const { 725d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // If this inst doesn't ever need relaxation, ignore it. This occurs when we 726d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // are intentionally pushing out inst fragments, or because we relaxed a 727d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // previous instruction to one that doesn't need relaxation. 728d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar if (!getBackend().MayNeedRelaxation(IF->getInst(), IF->getFixups())) 729d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar return false; 730d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 731d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar for (MCInstFragment::const_fixup_iterator it = IF->fixup_begin(), 732d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar ie = IF->fixup_end(); it != ie; ++it) 733d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar if (FixupNeedsRelaxation(*it, IF, Layout)) 734d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar return true; 735d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 736d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar return false; 737d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar} 738d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 7398d39eb47d6a15d36be7ac0d0154a6897e42f5adcDaniel Dunbarbool MCAssembler::LayoutOnce(MCAsmLayout &Layout) { 740ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::RelaxationSteps; 741ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 742d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // Layout the concrete sections and fragments. 7435e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar uint64_t Address = 0; 744edc670f3f2ba629b6803a1a7ed4aa47061afd276Daniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 745d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // Skip virtual sections. 746f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar if (getBackend().isVirtualSection(it->getSection())) 747d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar continue; 748d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 7496742e34385bff89b897ef0fc930c4bca9e75ac4aDaniel Dunbar // Layout the section fragments and its size. 750f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar Address = LayoutSection(*it, Layout, Address); 7515e835967dd5dda294d0ef3392f4c1d4a2260f532Daniel Dunbar } 7520705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 753d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar // Layout the virtual sections. 754d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 755f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar if (!getBackend().isVirtualSection(it->getSection())) 756d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar continue; 757d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 758f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar // Layout the section fragments and its size. 759f476b00f51c98d12dda1f3a7c8455f8d74812c6dDaniel Dunbar Address = LayoutSection(*it, Layout, Address); 760d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar } 761d5a8e98ef627a35284c9b5989664514f8f163968Daniel Dunbar 762d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Scan for fragments that need relaxation. 7630cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar bool WasRelaxed = false; 764f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 765f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar MCSectionData &SD = *it; 766b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 767f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar for (MCSectionData::iterator it2 = SD.begin(), 768f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar ie2 = SD.end(); it2 != ie2; ++it2) { 769d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Check if this is an instruction fragment that needs relaxation. 770d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar MCInstFragment *IF = dyn_cast<MCInstFragment>(it2); 771d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar if (!IF || !FragmentNeedsRelaxation(IF, Layout)) 772f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar continue; 7730705fbf52fcaade0c6b9d5d33bec163ee4c2daf4Daniel Dunbar 774ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar ++stats::RelaxedInstructions; 775ff54784683591b2cdbdc18690aeac12c8d87f97bDaniel Dunbar 776d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // FIXME-PERF: We could immediately lower out instructions if we can tell 777d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // they are fully resolved, to avoid retesting on later passes. 778f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 779d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Relax the fragment. 780d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 781d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar MCInst Relaxed; 782d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar getBackend().RelaxInstruction(IF, Relaxed); 783f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 784d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Encode the new instruction. 785d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // 786d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // FIXME-PERF: If it matters, we could let the target do this. It can 787d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // probably do so more efficiently in many cases. 788d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar SmallVector<MCFixup, 4> Fixups; 789d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar SmallString<256> Code; 790d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar raw_svector_ostream VecOS(Code); 791d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar getEmitter().EncodeInstruction(Relaxed, VecOS, Fixups); 792d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar VecOS.flush(); 793d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 794d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar // Update the instruction fragment. 7950cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar int SlideAmount = Code.size() - IF->getInstSize(); 796d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->setInst(Relaxed); 797d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->getCode() = Code; 798d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->getFixups().clear(); 799d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 800d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar MCFixup &F = Fixups[i]; 801d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar IF->getFixups().push_back(MCAsmFixup(F.getOffset(), *F.getValue(), 802d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar F.getKind())); 803f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar } 804d8036fb0deb7daff7959b0a5407c8a45acb5e603Daniel Dunbar 805ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar // Update the layout, and remember that we relaxed. If we are relaxing 806ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar // everything, we can skip this step since nothing will depend on updating 807ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar // the values. 808ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar if (!getRelaxAll()) 809ac2884a717daf3ad2aa8425320795d661e8a980bDaniel Dunbar Layout.UpdateForSlide(IF, SlideAmount); 8100cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar WasRelaxed = true; 811f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar } 812f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar } 813f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar 8140cc8bd48619b943379f5c2cc11a19fb189342925Daniel Dunbar return WasRelaxed; 815f08fde41f34d739c157b1d75dadbb864e7957cabDaniel Dunbar} 816b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 8173f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbarvoid MCAssembler::FinishLayout(MCAsmLayout &Layout) { 8183f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Lower out any instruction fragments, to simplify the fixup application and 8193f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // output. 8203f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // 8213f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // FIXME-PERF: We don't have to do this, but the assumption is that it is 8223f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // cheap (we will mostly end up eliminating fragments and appending on to data 8233f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // fragments), so the extra complexity downstream isn't worth it. Evaluate 8243f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // this assumption. 8253f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 8263f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCSectionData &SD = *it; 8273f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8283f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar for (MCSectionData::iterator it2 = SD.begin(), 8293f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar ie2 = SD.end(); it2 != ie2; ++it2) { 8303f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCInstFragment *IF = dyn_cast<MCInstFragment>(it2); 8313f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar if (!IF) 8323f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar continue; 8333f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8343f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Create a new data fragment for the instruction. 8353f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // 836337055e62f28f18a9a8c4a090633cae1c2256ae1Daniel Dunbar // FIXME-PERF: Reuse previous data fragment if possible. 8373f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar MCDataFragment *DF = new MCDataFragment(); 8383f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar SD.getFragmentList().insert(it2, DF); 8393f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8403f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Update the data fragments layout data. 841432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar // 842432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar // FIXME: Add MCAsmLayout utility for this. 8439799de910e97879bf9f30f359551071a94d61570Daniel Dunbar DF->setParent(IF->getParent()); 8445a6e97a7e4e25265cd491f10cc9b0676ff5c0746Daniel Dunbar DF->setOrdinal(IF->getOrdinal()); 845432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Layout.setFragmentOffset(DF, Layout.getFragmentOffset(IF)); 846432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar Layout.setFragmentEffectiveSize(DF, Layout.getFragmentEffectiveSize(IF)); 8473f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8489799de910e97879bf9f30f359551071a94d61570Daniel Dunbar // Copy in the data and the fixups. 8499799de910e97879bf9f30f359551071a94d61570Daniel Dunbar DF->getContents().append(IF->getCode().begin(), IF->getCode().end()); 8509799de910e97879bf9f30f359551071a94d61570Daniel Dunbar for (unsigned i = 0, e = IF->getFixups().size(); i != e; ++i) 8519799de910e97879bf9f30f359551071a94d61570Daniel Dunbar DF->getFixups().push_back(IF->getFixups()[i]); 8523f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 8533f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar // Delete the instruction fragment and update the iterator. 8543f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar SD.getFragmentList().erase(IF); 8553f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar it2 = DF; 8563f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar } 8573f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar } 8583f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar} 8593f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 860b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar// Debugging methods 861b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 862b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarnamespace llvm { 863b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 864b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarraw_ostream &operator<<(raw_ostream &OS, const MCAsmFixup &AF) { 8652be2fd073003c0988723d2894dfb117ad90be11bDaniel Dunbar OS << "<MCAsmFixup" << " Offset:" << AF.Offset << " Value:" << *AF.Value 8662be2fd073003c0988723d2894dfb117ad90be11bDaniel Dunbar << " Kind:" << AF.Kind << ">"; 867b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar return OS; 868b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 869b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 870b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 871b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 872b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCFragment::dump() { 873b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 874b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 875b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCFragment " << (void*) this << " Offset:" << Offset 876432cd5fd9b4c97f1e4a53fcf45e16f7dd6bc085eDaniel Dunbar << " EffectiveSize:" << EffectiveSize; 877b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 878b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << ">"; 879b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 880b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 881b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCAlignFragment::dump() { 882b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 883b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 884b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCAlignFragment "; 885b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 886b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 887b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Alignment:" << getAlignment() 888b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Value:" << getValue() << " ValueSize:" << getValueSize() 889b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " MaxBytesToEmit:" << getMaxBytesToEmit() << ">"; 890b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 891b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 892b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCDataFragment::dump() { 893b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 894b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 895b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCDataFragment "; 896b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 897b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 898b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Contents:["; 899b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (unsigned i = 0, e = getContents().size(); i != e; ++i) { 900b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (i) OS << ","; 901b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF); 902b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 9032be2fd073003c0988723d2894dfb117ad90be11bDaniel Dunbar OS << "] (" << getContents().size() << " bytes)"; 9040bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar 9050bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar if (!getFixups().empty()) { 9060bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << ",\n "; 9070bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << " Fixups:["; 9080bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar for (fixup_iterator it = fixup_begin(), ie = fixup_end(); it != ie; ++it) { 90945aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar if (it != fixup_begin()) OS << ",\n "; 9100bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << *it; 9110bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar } 9120bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << "]"; 9130bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar } 9140bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar 9150bcf074867d4d366f7988a219c7a53265fcb4f23Daniel Dunbar OS << ">"; 916b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 917b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 918b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCFillFragment::dump() { 919b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 920b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 921b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCFillFragment "; 922b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 923b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 924b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Value:" << getValue() << " ValueSize:" << getValueSize() 925b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Count:" << getCount() << ">"; 926b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 927b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 9283f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbarvoid MCInstFragment::dump() { 9293f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar raw_ostream &OS = llvm::errs(); 9303f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 9313f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << "<MCInstFragment "; 9323f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar this->MCFragment::dump(); 9333f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << "\n "; 9343f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << " Inst:"; 9353f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar getInst().dump_pretty(OS); 9363f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar OS << ">"; 9373f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar} 9383f4dcd92daef80f87919507b6baf2a97d4bfaa2eDaniel Dunbar 939b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCOrgFragment::dump() { 940b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 941b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 942b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCOrgFragment "; 943b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 944b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 945b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Offset:" << getOffset() << " Value:" << getValue() << ">"; 946b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 947b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 948b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCZeroFillFragment::dump() { 949b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 950b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 951b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCZeroFillFragment "; 952b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar this->MCFragment::dump(); 953b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "\n "; 954b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Size:" << getSize() << " Alignment:" << getAlignment() << ">"; 955b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 956b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 957b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCSectionData::dump() { 958b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 959b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 960b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCSectionData"; 961b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Alignment:" << getAlignment() << " Address:" << Address 962b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Size:" << Size << " FileSize:" << FileSize 96345aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar << " Fragments:[\n "; 964b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 965b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (it != begin()) OS << ",\n "; 966b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar it->dump(); 967b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 968b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "]>"; 969b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 970b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 971b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCSymbolData::dump() { 972b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 973b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 974b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCSymbolData Symbol:" << getSymbol() 975b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Fragment:" << getFragment() << " Offset:" << getOffset() 976b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " Flags:" << getFlags() << " Index:" << getIndex(); 977b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (isCommon()) 978b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " (common, size:" << getCommonSize() 979b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar << " align: " << getCommonAlignment() << ")"; 980b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (isExternal()) 981b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " (external)"; 982b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (isPrivateExtern()) 983b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " (private extern)"; 984b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << ">"; 985b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 986b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 987b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbarvoid MCAssembler::dump() { 988b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar raw_ostream &OS = llvm::errs(); 989b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 990b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "<MCAssembler\n"; 99145aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar OS << " Sections:[\n "; 992b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (iterator it = begin(), ie = end(); it != ie; ++it) { 993b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar if (it != begin()) OS << ",\n "; 994b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar it->dump(); 995b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 996b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "],\n"; 997b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << " Symbols:["; 998b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar 999b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar for (symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) { 100045aefff64c64d5bd7804f39d994883b98ce4415aDaniel Dunbar if (it != symbol_begin()) OS << ",\n "; 1001b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar it->dump(); 1002b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar } 1003b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar OS << "]>\n"; 1004b7c3a4b195597848e7c2559937914ae1087f3131Daniel Dunbar} 1005