llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
//===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-08-25 21:10:45 +00:00
|
|
|
#define DEBUG_TYPE "assembler"
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
#include "llvm/MC/MCAssembler.h"
|
2010-03-11 05:53:33 +00:00
|
|
|
#include "llvm/MC/MCAsmLayout.h"
|
2010-03-19 10:43:23 +00:00
|
|
|
#include "llvm/MC/MCCodeEmitter.h"
|
2009-10-16 01:58:03 +00:00
|
|
|
#include "llvm/MC/MCExpr.h"
|
2010-03-19 09:28:59 +00:00
|
|
|
#include "llvm/MC/MCObjectWriter.h"
|
2009-10-16 01:58:03 +00:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
|
|
|
#include "llvm/MC/MCValue.h"
|
2010-03-19 10:43:26 +00:00
|
|
|
#include "llvm/ADT/OwningPtr.h"
|
2009-08-25 21:10:45 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2010-02-13 09:28:03 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2009-08-21 23:07:38 +00:00
|
|
|
#include "llvm/ADT/Twine.h"
|
2009-08-21 18:29:01 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-02-13 09:28:03 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2010-03-13 22:10:17 +00:00
|
|
|
#include "llvm/Target/TargetRegistry.h"
|
2010-03-12 21:00:49 +00:00
|
|
|
#include "llvm/Target/TargetAsmBackend.h"
|
2010-02-13 09:29:02 +00:00
|
|
|
|
2009-08-24 03:52:50 +00:00
|
|
|
#include <vector>
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2009-08-25 21:10:45 +00:00
|
|
|
STATISTIC(EmittedFragments, "Number of emitted assembler fragments");
|
|
|
|
|
2009-08-28 07:08:35 +00:00
|
|
|
// FIXME FIXME FIXME: There are number of places in this file where we convert
|
|
|
|
// what is a 64-bit assembler value used for computation into a value in the
|
|
|
|
// object file, which may truncate it. We should detect that truncation where
|
|
|
|
// invalid and report errors back.
|
|
|
|
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
/* *** */
|
|
|
|
|
2009-08-21 18:29:01 +00:00
|
|
|
MCFragment::MCFragment() : Kind(FragmentType(~0)) {
|
|
|
|
}
|
|
|
|
|
2009-08-26 02:48:04 +00:00
|
|
|
MCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent)
|
2009-08-21 18:29:01 +00:00
|
|
|
: Kind(_Kind),
|
2009-08-26 02:48:04 +00:00
|
|
|
Parent(_Parent),
|
2009-08-21 18:29:01 +00:00
|
|
|
FileSize(~UINT64_C(0))
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
{
|
2009-08-26 02:48:04 +00:00
|
|
|
if (Parent)
|
|
|
|
Parent->getFragmentList().push_back(this);
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
}
|
|
|
|
|
2009-08-21 18:29:01 +00:00
|
|
|
MCFragment::~MCFragment() {
|
|
|
|
}
|
|
|
|
|
2009-08-26 02:48:04 +00:00
|
|
|
uint64_t MCFragment::getAddress() const {
|
|
|
|
assert(getParent() && "Missing Section!");
|
|
|
|
return getParent()->getAddress() + Offset;
|
|
|
|
}
|
|
|
|
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
/* *** */
|
|
|
|
|
2009-08-27 00:38:04 +00:00
|
|
|
MCSectionData::MCSectionData() : Section(0) {}
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
|
|
|
|
MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A)
|
2009-08-27 00:38:04 +00:00
|
|
|
: Section(&_Section),
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
Alignment(1),
|
2009-08-26 02:48:04 +00:00
|
|
|
Address(~UINT64_C(0)),
|
2009-08-26 04:13:32 +00:00
|
|
|
Size(~UINT64_C(0)),
|
2009-08-26 13:58:10 +00:00
|
|
|
FileSize(~UINT64_C(0)),
|
2010-02-02 21:44:01 +00:00
|
|
|
HasInstructions(false)
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
{
|
|
|
|
if (A)
|
|
|
|
A->getSectionList().push_back(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* *** */
|
|
|
|
|
2009-09-01 04:09:03 +00:00
|
|
|
MCSymbolData::MCSymbolData() : Symbol(0) {}
|
2009-08-22 10:13:24 +00:00
|
|
|
|
2009-08-31 08:08:06 +00:00
|
|
|
MCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment,
|
2009-08-22 10:13:24 +00:00
|
|
|
uint64_t _Offset, MCAssembler *A)
|
2009-09-01 04:09:03 +00:00
|
|
|
: Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset),
|
2009-08-28 07:08:35 +00:00
|
|
|
IsExternal(false), IsPrivateExtern(false),
|
|
|
|
CommonSize(0), CommonAlign(0), Flags(0), Index(0)
|
2009-08-22 10:13:24 +00:00
|
|
|
{
|
|
|
|
if (A)
|
|
|
|
A->getSymbolList().push_back(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* *** */
|
|
|
|
|
2010-03-11 01:34:27 +00:00
|
|
|
MCAssembler::MCAssembler(MCContext &_Context, TargetAsmBackend &_Backend,
|
2010-03-19 10:43:18 +00:00
|
|
|
MCCodeEmitter &_Emitter, raw_ostream &_OS)
|
|
|
|
: Context(_Context), Backend(_Backend), Emitter(_Emitter),
|
|
|
|
OS(_OS), SubsectionsViaSymbols(false)
|
2009-08-26 21:22:22 +00:00
|
|
|
{
|
|
|
|
}
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
|
|
|
|
MCAssembler::~MCAssembler() {
|
|
|
|
}
|
|
|
|
|
2010-03-19 03:18:12 +00:00
|
|
|
static bool isScatteredFixupFullyResolvedSimple(const MCAssembler &Asm,
|
|
|
|
const MCAsmFixup &Fixup,
|
|
|
|
const MCValue Target,
|
|
|
|
const MCSection *BaseSection) {
|
|
|
|
// The effective fixup address is
|
|
|
|
// addr(atom(A)) + offset(A)
|
|
|
|
// - addr(atom(B)) - offset(B)
|
|
|
|
// - addr(<base symbol>) + <fixup offset from base symbol>
|
|
|
|
// and the offsets are not relocatable, so the fixup is fully resolved when
|
|
|
|
// addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0.
|
|
|
|
//
|
|
|
|
// The simple (Darwin, except on x86_64) way of dealing with this was to
|
|
|
|
// assume that any reference to a temporary symbol *must* be a temporary
|
|
|
|
// symbol in the same atom, unless the sections differ. Therefore, any PCrel
|
|
|
|
// relocation to a temporary symbol (in the same section) is fully
|
|
|
|
// resolved. This also works in conjunction with absolutized .set, which
|
|
|
|
// requires the compiler to use .set to absolutize the differences between
|
|
|
|
// symbols which the compiler knows to be assembly time constants, so we don't
|
|
|
|
// need to worry about consider symbol differences fully resolved.
|
|
|
|
|
|
|
|
// Non-relative fixups are only resolved if constant.
|
|
|
|
if (!BaseSection)
|
|
|
|
return Target.isAbsolute();
|
|
|
|
|
|
|
|
// Otherwise, relative fixups are only resolved if not a difference and the
|
|
|
|
// target is a temporary in the same section.
|
|
|
|
if (Target.isAbsolute() || Target.getSymB())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const MCSymbol *A = &Target.getSymA()->getSymbol();
|
|
|
|
if (!A->isTemporary() || !A->isInSection() ||
|
|
|
|
&A->getSection() != BaseSection)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-03-19 03:18:18 +00:00
|
|
|
static bool isScatteredFixupFullyResolved(const MCAssembler &Asm,
|
|
|
|
const MCAsmFixup &Fixup,
|
|
|
|
const MCValue Target,
|
|
|
|
const MCSymbolData *BaseSymbol) {
|
|
|
|
// The effective fixup address is
|
|
|
|
// addr(atom(A)) + offset(A)
|
|
|
|
// - addr(atom(B)) - offset(B)
|
|
|
|
// - addr(BaseSymbol) + <fixup offset from base symbol>
|
|
|
|
// and the offsets are not relocatable, so the fixup is fully resolved when
|
|
|
|
// addr(atom(A)) - addr(atom(B)) - addr(BaseSymbol) == 0.
|
|
|
|
//
|
|
|
|
// Note that "false" is almost always conservatively correct (it means we emit
|
|
|
|
// a relocation which is unnecessary), except when it would force us to emit a
|
|
|
|
// relocation which the target cannot encode.
|
|
|
|
|
|
|
|
const MCSymbolData *A_Base = 0, *B_Base = 0;
|
|
|
|
if (const MCSymbolRefExpr *A = Target.getSymA()) {
|
|
|
|
// Modified symbol references cannot be resolved.
|
|
|
|
if (A->getKind() != MCSymbolRefExpr::VK_None)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
A_Base = Asm.getAtom(&Asm.getSymbolData(A->getSymbol()));
|
|
|
|
if (!A_Base)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const MCSymbolRefExpr *B = Target.getSymB()) {
|
|
|
|
// Modified symbol references cannot be resolved.
|
|
|
|
if (B->getKind() != MCSymbolRefExpr::VK_None)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
B_Base = Asm.getAtom(&Asm.getSymbolData(B->getSymbol()));
|
|
|
|
if (!B_Base)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is no base, A and B have to be the same atom for this fixup to be
|
|
|
|
// fully resolved.
|
|
|
|
if (!BaseSymbol)
|
|
|
|
return A_Base == B_Base;
|
|
|
|
|
|
|
|
// Otherwise, B must be missing and A must be the base.
|
|
|
|
return !B_Base && BaseSymbol == A_Base;
|
|
|
|
}
|
|
|
|
|
2010-03-19 03:18:09 +00:00
|
|
|
bool MCAssembler::isSymbolLinkerVisible(const MCSymbolData *SD) const {
|
|
|
|
// Non-temporary labels should always be visible to the linker.
|
|
|
|
if (!SD->getSymbol().isTemporary())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Absolute temporary labels are never visible.
|
|
|
|
if (!SD->getFragment())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Otherwise, check if the section requires symbols even for temporary labels.
|
|
|
|
return getBackend().doesSectionRequireSymbols(
|
|
|
|
SD->getFragment()->getParent()->getSection());
|
|
|
|
}
|
|
|
|
|
2010-03-19 03:18:15 +00:00
|
|
|
const MCSymbolData *MCAssembler::getAtomForAddress(const MCSectionData *Section,
|
|
|
|
uint64_t Address) const {
|
|
|
|
const MCSymbolData *Best = 0;
|
|
|
|
for (MCAssembler::const_symbol_iterator it = symbol_begin(),
|
|
|
|
ie = symbol_end(); it != ie; ++it) {
|
|
|
|
// Ignore non-linker visible symbols.
|
|
|
|
if (!isSymbolLinkerVisible(it))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Ignore symbols not in the same section.
|
|
|
|
if (!it->getFragment() || it->getFragment()->getParent() != Section)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Otherwise, find the closest symbol preceding this address (ties are
|
|
|
|
// resolved in favor of the last defined symbol).
|
|
|
|
if (it->getAddress() <= Address &&
|
|
|
|
(!Best || it->getAddress() >= Best->getAddress()))
|
|
|
|
Best = it;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Best;
|
|
|
|
}
|
|
|
|
|
|
|
|
const MCSymbolData *MCAssembler::getAtom(const MCSymbolData *SD) const {
|
|
|
|
// Linker visible symbols define atoms.
|
|
|
|
if (isSymbolLinkerVisible(SD))
|
|
|
|
return SD;
|
|
|
|
|
|
|
|
// Absolute and undefined symbols have no defining atom.
|
|
|
|
if (!SD->getFragment())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Otherwise, search by address.
|
|
|
|
return getAtomForAddress(SD->getFragment()->getParent(), SD->getAddress());
|
|
|
|
}
|
|
|
|
|
2010-03-22 21:49:41 +00:00
|
|
|
bool MCAssembler::EvaluateFixup(const MCAsmLayout &Layout,
|
|
|
|
const MCAsmFixup &Fixup, const MCFragment *DF,
|
2010-03-12 21:00:49 +00:00
|
|
|
MCValue &Target, uint64_t &Value) const {
|
|
|
|
if (!Fixup.Value->EvaluateAsRelocatable(Target, &Layout))
|
|
|
|
llvm_report_error("expected relocatable expression");
|
|
|
|
|
|
|
|
// FIXME: How do non-scattered symbols work in ELF? I presume the linker
|
|
|
|
// doesn't support small relocations, but then under what criteria does the
|
|
|
|
// assembler allow symbol differences?
|
|
|
|
|
|
|
|
Value = Target.getConstant();
|
|
|
|
|
2010-03-19 10:43:23 +00:00
|
|
|
bool IsPCRel =
|
|
|
|
Emitter.getFixupKindInfo(Fixup.Kind).Flags & MCFixupKindInfo::FKF_IsPCRel;
|
|
|
|
bool IsResolved = true;
|
2010-03-18 00:59:10 +00:00
|
|
|
if (const MCSymbolRefExpr *A = Target.getSymA()) {
|
|
|
|
if (A->getSymbol().isDefined())
|
|
|
|
Value += getSymbolData(A->getSymbol()).getAddress();
|
2010-03-12 21:00:49 +00:00
|
|
|
else
|
|
|
|
IsResolved = false;
|
|
|
|
}
|
2010-03-18 00:59:10 +00:00
|
|
|
if (const MCSymbolRefExpr *B = Target.getSymB()) {
|
|
|
|
if (B->getSymbol().isDefined())
|
|
|
|
Value -= getSymbolData(B->getSymbol()).getAddress();
|
2010-03-12 21:00:49 +00:00
|
|
|
else
|
|
|
|
IsResolved = false;
|
2010-03-19 03:18:12 +00:00
|
|
|
}
|
2010-03-12 21:00:49 +00:00
|
|
|
|
2010-03-19 03:18:12 +00:00
|
|
|
// If we are using scattered symbols, determine whether this value is actually
|
|
|
|
// resolved; scattering may cause atoms to move.
|
|
|
|
if (IsResolved && getBackend().hasScatteredSymbols()) {
|
|
|
|
if (getBackend().hasReliableSymbolDifference()) {
|
2010-03-19 03:18:18 +00:00
|
|
|
// If this is a PCrel relocation, find the base atom (identified by its
|
|
|
|
// symbol) that the fixup value is relative to.
|
|
|
|
const MCSymbolData *BaseSymbol = 0;
|
|
|
|
if (IsPCRel) {
|
|
|
|
BaseSymbol = getAtomForAddress(
|
|
|
|
DF->getParent(), DF->getAddress() + Fixup.Offset);
|
|
|
|
if (!BaseSymbol)
|
|
|
|
IsResolved = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IsResolved)
|
2010-03-22 21:49:38 +00:00
|
|
|
IsResolved = isScatteredFixupFullyResolved(*this, Fixup, Target,
|
2010-03-19 03:18:18 +00:00
|
|
|
BaseSymbol);
|
2010-03-19 03:18:12 +00:00
|
|
|
} else {
|
|
|
|
const MCSection *BaseSection = 0;
|
|
|
|
if (IsPCRel)
|
|
|
|
BaseSection = &DF->getParent()->getSection();
|
|
|
|
|
2010-03-22 21:49:38 +00:00
|
|
|
IsResolved = isScatteredFixupFullyResolvedSimple(*this, Fixup, Target,
|
2010-03-19 03:18:12 +00:00
|
|
|
BaseSection);
|
|
|
|
}
|
2010-03-12 21:00:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (IsPCRel)
|
2010-03-13 02:38:00 +00:00
|
|
|
Value -= DF->getAddress() + Fixup.Offset;
|
2010-03-12 21:00:49 +00:00
|
|
|
|
|
|
|
return IsResolved;
|
|
|
|
}
|
|
|
|
|
2010-03-22 20:35:35 +00:00
|
|
|
void MCAssembler::LayoutSection(MCSectionData &SD,
|
|
|
|
MCAsmLayout &Layout) {
|
2009-08-26 04:13:32 +00:00
|
|
|
uint64_t Address = SD.getAddress();
|
2009-08-21 18:29:01 +00:00
|
|
|
|
|
|
|
for (MCSectionData::iterator it = SD.begin(), ie = SD.end(); it != ie; ++it) {
|
|
|
|
MCFragment &F = *it;
|
2009-08-21 23:07:38 +00:00
|
|
|
|
2009-08-26 04:13:32 +00:00
|
|
|
F.setOffset(Address - SD.getAddress());
|
2009-08-21 23:07:38 +00:00
|
|
|
|
|
|
|
// Evaluate fragment size.
|
|
|
|
switch (F.getKind()) {
|
|
|
|
case MCFragment::FT_Align: {
|
|
|
|
MCAlignFragment &AF = cast<MCAlignFragment>(F);
|
2009-10-16 01:58:15 +00:00
|
|
|
|
2009-08-28 05:49:21 +00:00
|
|
|
uint64_t Size = OffsetToAlignment(Address, AF.getAlignment());
|
2009-08-26 04:13:32 +00:00
|
|
|
if (Size > AF.getMaxBytesToEmit())
|
2009-08-21 23:07:38 +00:00
|
|
|
AF.setFileSize(0);
|
|
|
|
else
|
2009-08-26 04:13:32 +00:00
|
|
|
AF.setFileSize(Size);
|
2009-08-21 23:07:38 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case MCFragment::FT_Data:
|
2010-03-22 20:35:43 +00:00
|
|
|
F.setFileSize(cast<MCDataFragment>(F).getContents().size());
|
2009-08-21 23:07:38 +00:00
|
|
|
break;
|
|
|
|
|
2010-03-22 20:35:43 +00:00
|
|
|
case MCFragment::FT_Fill: {
|
|
|
|
MCFillFragment &FF = cast<MCFillFragment>(F);
|
|
|
|
F.setFileSize(FF.getValueSize() * FF.getCount());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-03-22 23:16:48 +00:00
|
|
|
case MCFragment::FT_Inst:
|
|
|
|
F.setFileSize(cast<MCInstFragment>(F).getInstSize());
|
|
|
|
break;
|
|
|
|
|
2009-08-21 23:07:38 +00:00
|
|
|
case MCFragment::FT_Org: {
|
|
|
|
MCOrgFragment &OF = cast<MCOrgFragment>(F);
|
|
|
|
|
2010-03-11 05:53:33 +00:00
|
|
|
int64_t TargetLocation;
|
|
|
|
if (!OF.getOffset().EvaluateAsAbsolute(TargetLocation, &Layout))
|
|
|
|
llvm_report_error("expected assembly-time absolute expression");
|
2009-08-21 23:07:38 +00:00
|
|
|
|
|
|
|
// FIXME: We need a way to communicate this error.
|
2010-03-11 05:53:33 +00:00
|
|
|
int64_t Offset = TargetLocation - F.getOffset();
|
|
|
|
if (Offset < 0)
|
|
|
|
llvm_report_error("invalid .org offset '" + Twine(TargetLocation) +
|
|
|
|
"' (at offset '" + Twine(F.getOffset()) + "'");
|
2009-10-16 01:58:15 +00:00
|
|
|
|
2010-03-11 05:53:33 +00:00
|
|
|
F.setFileSize(Offset);
|
2009-08-21 23:07:38 +00:00
|
|
|
break;
|
2009-10-16 01:58:15 +00:00
|
|
|
}
|
2009-08-28 05:49:21 +00:00
|
|
|
|
|
|
|
case MCFragment::FT_ZeroFill: {
|
|
|
|
MCZeroFillFragment &ZFF = cast<MCZeroFillFragment>(F);
|
|
|
|
|
|
|
|
// Align the fragment offset; it is safe to adjust the offset freely since
|
|
|
|
// this is only in virtual sections.
|
2010-03-08 21:10:42 +00:00
|
|
|
Address = RoundUpToAlignment(Address, ZFF.getAlignment());
|
|
|
|
F.setOffset(Address - SD.getAddress());
|
2009-08-28 05:49:21 +00:00
|
|
|
|
|
|
|
// FIXME: This is misnamed.
|
|
|
|
F.setFileSize(ZFF.getSize());
|
|
|
|
break;
|
|
|
|
}
|
2009-08-21 23:07:38 +00:00
|
|
|
}
|
|
|
|
|
2009-08-26 04:13:32 +00:00
|
|
|
Address += F.getFileSize();
|
2009-08-21 18:29:01 +00:00
|
|
|
}
|
|
|
|
|
2009-08-26 04:13:32 +00:00
|
|
|
// Set the section sizes.
|
|
|
|
SD.setSize(Address - SD.getAddress());
|
2010-03-19 09:29:03 +00:00
|
|
|
if (getBackend().isVirtualSection(SD.getSection()))
|
2009-08-28 05:49:21 +00:00
|
|
|
SD.setFileSize(0);
|
|
|
|
else
|
|
|
|
SD.setFileSize(Address - SD.getAddress());
|
2009-08-21 18:29:01 +00:00
|
|
|
}
|
|
|
|
|
2010-03-19 09:28:59 +00:00
|
|
|
/// WriteFragmentData - Write the \arg F data to the output file.
|
2010-03-23 02:36:58 +00:00
|
|
|
static void WriteFragmentData(const MCAssembler &Asm, const MCFragment &F,
|
|
|
|
MCObjectWriter *OW) {
|
2010-03-19 09:28:59 +00:00
|
|
|
uint64_t Start = OW->getStream().tell();
|
2009-08-21 18:29:01 +00:00
|
|
|
(void) Start;
|
2009-10-16 01:58:15 +00:00
|
|
|
|
2009-08-25 21:10:45 +00:00
|
|
|
++EmittedFragments;
|
|
|
|
|
2009-08-21 18:29:01 +00:00
|
|
|
// FIXME: Embed in fragments instead?
|
|
|
|
switch (F.getKind()) {
|
2009-08-21 23:07:38 +00:00
|
|
|
case MCFragment::FT_Align: {
|
|
|
|
MCAlignFragment &AF = cast<MCAlignFragment>(F);
|
|
|
|
uint64_t Count = AF.getFileSize() / AF.getValueSize();
|
|
|
|
|
|
|
|
// FIXME: This error shouldn't actually occur (the front end should emit
|
|
|
|
// multiple .align directives to enforce the semantics it wants), but is
|
|
|
|
// severe enough that we want to report it. How to handle this?
|
|
|
|
if (Count * AF.getValueSize() != AF.getFileSize())
|
2009-10-16 01:58:15 +00:00
|
|
|
llvm_report_error("undefined .align directive, value size '" +
|
|
|
|
Twine(AF.getValueSize()) +
|
2009-08-21 23:07:38 +00:00
|
|
|
"' is not a divisor of padding size '" +
|
|
|
|
Twine(AF.getFileSize()) + "'");
|
|
|
|
|
2010-02-23 18:26:34 +00:00
|
|
|
// See if we are aligning with nops, and if so do that first to try to fill
|
|
|
|
// the Count bytes. Then if that did not fill any bytes or there are any
|
|
|
|
// bytes left to fill use the the Value and ValueSize to fill the rest.
|
2010-03-23 02:36:58 +00:00
|
|
|
// If we are aligning with nops, ask that target to emit the right data.
|
2010-02-23 18:26:34 +00:00
|
|
|
if (AF.getEmitNops()) {
|
2010-03-23 02:36:58 +00:00
|
|
|
if (!Asm.getBackend().WriteNopData(Count, OW))
|
|
|
|
llvm_report_error("unable to write nop sequence of " +
|
|
|
|
Twine(Count) + " bytes");
|
|
|
|
break;
|
2010-02-23 18:26:34 +00:00
|
|
|
}
|
|
|
|
|
2010-03-23 02:36:58 +00:00
|
|
|
// Otherwise, write out in multiples of the value size.
|
2009-08-21 23:07:38 +00:00
|
|
|
for (uint64_t i = 0; i != Count; ++i) {
|
|
|
|
switch (AF.getValueSize()) {
|
|
|
|
default:
|
|
|
|
assert(0 && "Invalid size!");
|
2010-03-19 09:28:55 +00:00
|
|
|
case 1: OW->Write8 (uint8_t (AF.getValue())); break;
|
|
|
|
case 2: OW->Write16(uint16_t(AF.getValue())); break;
|
|
|
|
case 4: OW->Write32(uint32_t(AF.getValue())); break;
|
|
|
|
case 8: OW->Write64(uint64_t(AF.getValue())); break;
|
2009-08-21 23:07:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-08-21 18:29:01 +00:00
|
|
|
|
2010-02-13 09:28:15 +00:00
|
|
|
case MCFragment::FT_Data: {
|
2010-03-22 23:16:48 +00:00
|
|
|
MCDataFragment &DF = cast<MCDataFragment>(F);
|
|
|
|
assert(DF.getFileSize() == DF.getContents().size() && "Invalid size!");
|
|
|
|
OW->WriteBytes(DF.getContents().str());
|
2009-08-21 18:29:01 +00:00
|
|
|
break;
|
2010-02-13 09:28:15 +00:00
|
|
|
}
|
2009-08-21 18:29:01 +00:00
|
|
|
|
|
|
|
case MCFragment::FT_Fill: {
|
|
|
|
MCFillFragment &FF = cast<MCFillFragment>(F);
|
|
|
|
for (uint64_t i = 0, e = FF.getCount(); i != e; ++i) {
|
|
|
|
switch (FF.getValueSize()) {
|
|
|
|
default:
|
|
|
|
assert(0 && "Invalid size!");
|
2010-03-19 09:28:55 +00:00
|
|
|
case 1: OW->Write8 (uint8_t (FF.getValue())); break;
|
|
|
|
case 2: OW->Write16(uint16_t(FF.getValue())); break;
|
|
|
|
case 4: OW->Write32(uint32_t(FF.getValue())); break;
|
|
|
|
case 8: OW->Write64(uint64_t(FF.getValue())); break;
|
2009-08-21 18:29:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-10-16 01:58:15 +00:00
|
|
|
|
2010-03-22 23:16:48 +00:00
|
|
|
case MCFragment::FT_Inst:
|
|
|
|
llvm_unreachable("unexpected inst fragment after lowering");
|
|
|
|
break;
|
|
|
|
|
2009-08-21 23:07:38 +00:00
|
|
|
case MCFragment::FT_Org: {
|
|
|
|
MCOrgFragment &OF = cast<MCOrgFragment>(F);
|
|
|
|
|
|
|
|
for (uint64_t i = 0, e = OF.getFileSize(); i != e; ++i)
|
2010-03-19 09:28:55 +00:00
|
|
|
OW->Write8(uint8_t(OF.getValue()));
|
2009-08-21 23:07:38 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2009-08-28 05:49:21 +00:00
|
|
|
|
|
|
|
case MCFragment::FT_ZeroFill: {
|
|
|
|
assert(0 && "Invalid zero fill fragment in concrete section!");
|
|
|
|
break;
|
|
|
|
}
|
2009-08-21 18:29:01 +00:00
|
|
|
}
|
|
|
|
|
2010-03-19 09:28:59 +00:00
|
|
|
assert(OW->getStream().tell() - Start == F.getFileSize());
|
2009-08-21 18:29:01 +00:00
|
|
|
}
|
|
|
|
|
2010-03-19 09:28:59 +00:00
|
|
|
void MCAssembler::WriteSectionData(const MCSectionData *SD,
|
|
|
|
MCObjectWriter *OW) const {
|
2009-08-28 05:49:21 +00:00
|
|
|
// Ignore virtual sections.
|
2010-03-19 09:29:03 +00:00
|
|
|
if (getBackend().isVirtualSection(SD->getSection())) {
|
2010-03-19 09:28:59 +00:00
|
|
|
assert(SD->getFileSize() == 0);
|
2009-08-28 05:49:21 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-03-19 09:28:59 +00:00
|
|
|
uint64_t Start = OW->getStream().tell();
|
2009-08-21 18:29:01 +00:00
|
|
|
(void) Start;
|
2009-10-16 01:58:15 +00:00
|
|
|
|
2010-03-19 09:28:59 +00:00
|
|
|
for (MCSectionData::const_iterator it = SD->begin(),
|
|
|
|
ie = SD->end(); it != ie; ++it)
|
2010-03-23 02:36:58 +00:00
|
|
|
WriteFragmentData(*this, *it, OW);
|
2009-08-21 18:29:01 +00:00
|
|
|
|
2009-08-26 04:13:32 +00:00
|
|
|
// Add section padding.
|
2010-03-19 09:28:59 +00:00
|
|
|
assert(SD->getFileSize() >= SD->getSize() && "Invalid section sizes!");
|
|
|
|
OW->WriteZeros(SD->getFileSize() - SD->getSize());
|
2009-08-26 04:13:32 +00:00
|
|
|
|
2010-03-19 09:28:59 +00:00
|
|
|
assert(OW->getStream().tell() - Start == SD->getFileSize());
|
2009-08-21 18:29:01 +00:00
|
|
|
}
|
|
|
|
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
void MCAssembler::Finish() {
|
2010-02-13 09:28:03 +00:00
|
|
|
DEBUG_WITH_TYPE("mc-dump", {
|
|
|
|
llvm::errs() << "assembler backend - pre-layout\n--\n";
|
|
|
|
dump(); });
|
|
|
|
|
2010-03-12 22:07:14 +00:00
|
|
|
// Layout until everything fits.
|
2010-03-22 20:35:35 +00:00
|
|
|
MCAsmLayout Layout(*this);
|
|
|
|
while (LayoutOnce(Layout))
|
2010-03-12 22:07:14 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
DEBUG_WITH_TYPE("mc-dump", {
|
2010-03-22 23:16:48 +00:00
|
|
|
llvm::errs() << "assembler backend - post-relaxation\n--\n";
|
|
|
|
dump(); });
|
|
|
|
|
|
|
|
// Finalize the layout, including fragment lowering.
|
|
|
|
FinishLayout(Layout);
|
|
|
|
|
|
|
|
DEBUG_WITH_TYPE("mc-dump", {
|
|
|
|
llvm::errs() << "assembler backend - final-layout\n--\n";
|
2010-03-12 22:07:14 +00:00
|
|
|
dump(); });
|
|
|
|
|
2010-03-19 10:43:26 +00:00
|
|
|
llvm::OwningPtr<MCObjectWriter> Writer(getBackend().createObjectWriter(OS));
|
|
|
|
if (!Writer)
|
|
|
|
llvm_report_error("unable to create object writer!");
|
2010-03-19 07:09:33 +00:00
|
|
|
|
|
|
|
// Allow the object writer a chance to perform post-layout binding (for
|
|
|
|
// example, to set the index fields in the symbol data).
|
2010-03-19 10:43:26 +00:00
|
|
|
Writer->ExecutePostLayoutBinding(*this);
|
2010-03-19 07:09:33 +00:00
|
|
|
|
2010-03-19 07:09:47 +00:00
|
|
|
// Evaluate and apply the fixups, generating relocation entries as necessary.
|
|
|
|
for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
|
|
|
|
for (MCSectionData::iterator it2 = it->begin(),
|
|
|
|
ie2 = it->end(); it2 != ie2; ++it2) {
|
|
|
|
MCDataFragment *DF = dyn_cast<MCDataFragment>(it2);
|
|
|
|
if (!DF)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (MCDataFragment::fixup_iterator it3 = DF->fixup_begin(),
|
|
|
|
ie3 = DF->fixup_end(); it3 != ie3; ++it3) {
|
|
|
|
MCAsmFixup &Fixup = *it3;
|
|
|
|
|
|
|
|
// Evaluate the fixup.
|
|
|
|
MCValue Target;
|
|
|
|
uint64_t FixedValue;
|
|
|
|
if (!EvaluateFixup(Layout, Fixup, DF, Target, FixedValue)) {
|
|
|
|
// The fixup was unresolved, we need a relocation. Inform the object
|
|
|
|
// writer of the relocation, and give it an opportunity to adjust the
|
|
|
|
// fixup value if need be.
|
2010-03-22 20:35:50 +00:00
|
|
|
Writer->RecordRelocation(*this, DF, Fixup, Target, FixedValue);
|
2010-03-19 07:09:47 +00:00
|
|
|
}
|
|
|
|
|
2010-03-19 09:28:12 +00:00
|
|
|
getBackend().ApplyFixup(Fixup, *DF, FixedValue);
|
2010-03-19 07:09:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-19 07:09:33 +00:00
|
|
|
// Write the object file.
|
2010-03-19 10:43:26 +00:00
|
|
|
Writer->WriteObject(*this);
|
2010-03-12 22:07:14 +00:00
|
|
|
OS.flush();
|
|
|
|
}
|
|
|
|
|
2010-03-22 21:49:41 +00:00
|
|
|
bool MCAssembler::FixupNeedsRelaxation(const MCAsmFixup &Fixup,
|
|
|
|
const MCFragment *DF,
|
2010-03-22 20:35:35 +00:00
|
|
|
const MCAsmLayout &Layout) const {
|
2010-03-12 22:07:14 +00:00
|
|
|
// If we cannot resolve the fixup value, it requires relaxation.
|
|
|
|
MCValue Target;
|
|
|
|
uint64_t Value;
|
|
|
|
if (!EvaluateFixup(Layout, Fixup, DF, Target, Value))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise, relax if the value is too big for a (signed) i8.
|
|
|
|
return int64_t(Value) != int64_t(int8_t(Value));
|
|
|
|
}
|
|
|
|
|
2010-03-23 05:09:03 +00:00
|
|
|
bool MCAssembler::FragmentNeedsRelaxation(const MCInstFragment *IF,
|
|
|
|
const MCAsmLayout &Layout) const {
|
|
|
|
// If this inst doesn't ever need relaxation, ignore it. This occurs when we
|
|
|
|
// are intentionally pushing out inst fragments, or because we relaxed a
|
|
|
|
// previous instruction to one that doesn't need relaxation.
|
|
|
|
if (!getBackend().MayNeedRelaxation(IF->getInst(), IF->getFixups()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (MCInstFragment::const_fixup_iterator it = IF->fixup_begin(),
|
|
|
|
ie = IF->fixup_end(); it != ie; ++it)
|
|
|
|
if (FixupNeedsRelaxation(*it, IF, Layout))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-03-22 20:35:35 +00:00
|
|
|
bool MCAssembler::LayoutOnce(MCAsmLayout &Layout) {
|
2009-08-28 05:49:21 +00:00
|
|
|
// Layout the concrete sections and fragments.
|
2009-08-26 02:48:04 +00:00
|
|
|
uint64_t Address = 0;
|
2009-08-28 05:49:04 +00:00
|
|
|
MCSectionData *Prev = 0;
|
|
|
|
for (iterator it = begin(), ie = end(); it != ie; ++it) {
|
2009-08-26 04:13:32 +00:00
|
|
|
MCSectionData &SD = *it;
|
|
|
|
|
2009-08-28 05:49:21 +00:00
|
|
|
// Skip virtual sections.
|
2010-03-19 09:29:03 +00:00
|
|
|
if (getBackend().isVirtualSection(SD.getSection()))
|
2009-08-28 05:49:21 +00:00
|
|
|
continue;
|
|
|
|
|
2009-08-28 05:49:04 +00:00
|
|
|
// Align this section if necessary by adding padding bytes to the previous
|
|
|
|
// section.
|
|
|
|
if (uint64_t Pad = OffsetToAlignment(Address, it->getAlignment())) {
|
|
|
|
assert(Prev && "Missing prev section!");
|
|
|
|
Prev->setFileSize(Prev->getFileSize() + Pad);
|
|
|
|
Address += Pad;
|
|
|
|
}
|
2009-08-26 04:13:32 +00:00
|
|
|
|
|
|
|
// Layout the section fragments and its size.
|
|
|
|
SD.setAddress(Address);
|
2010-03-22 20:35:35 +00:00
|
|
|
LayoutSection(SD, Layout);
|
2009-08-26 04:13:32 +00:00
|
|
|
Address += SD.getFileSize();
|
2009-08-28 05:49:04 +00:00
|
|
|
|
|
|
|
Prev = &SD;
|
2009-08-26 02:48:04 +00:00
|
|
|
}
|
2009-08-21 18:29:01 +00:00
|
|
|
|
2009-08-28 05:49:21 +00:00
|
|
|
// Layout the virtual sections.
|
|
|
|
for (iterator it = begin(), ie = end(); it != ie; ++it) {
|
|
|
|
MCSectionData &SD = *it;
|
|
|
|
|
2010-03-19 09:29:03 +00:00
|
|
|
if (!getBackend().isVirtualSection(SD.getSection()))
|
2009-08-28 05:49:21 +00:00
|
|
|
continue;
|
|
|
|
|
2010-03-08 22:03:42 +00:00
|
|
|
// Align this section if necessary by adding padding bytes to the previous
|
|
|
|
// section.
|
2010-03-09 01:12:20 +00:00
|
|
|
if (uint64_t Pad = OffsetToAlignment(Address, it->getAlignment()))
|
2010-03-08 22:03:42 +00:00
|
|
|
Address += Pad;
|
|
|
|
|
2009-08-28 05:49:21 +00:00
|
|
|
SD.setAddress(Address);
|
2010-03-22 20:35:35 +00:00
|
|
|
LayoutSection(SD, Layout);
|
2009-08-28 05:49:21 +00:00
|
|
|
Address += SD.getSize();
|
|
|
|
}
|
|
|
|
|
2010-03-23 05:09:03 +00:00
|
|
|
// Scan for fragments that need relaxation.
|
2010-03-12 22:07:14 +00:00
|
|
|
for (iterator it = begin(), ie = end(); it != ie; ++it) {
|
|
|
|
MCSectionData &SD = *it;
|
2010-02-13 09:28:03 +00:00
|
|
|
|
2010-03-12 22:07:14 +00:00
|
|
|
for (MCSectionData::iterator it2 = SD.begin(),
|
|
|
|
ie2 = SD.end(); it2 != ie2; ++it2) {
|
2010-03-23 05:09:03 +00:00
|
|
|
// Check if this is an instruction fragment that needs relaxation.
|
|
|
|
MCInstFragment *IF = dyn_cast<MCInstFragment>(it2);
|
|
|
|
if (!IF || !FragmentNeedsRelaxation(IF, Layout))
|
2010-03-12 22:07:14 +00:00
|
|
|
continue;
|
2009-08-21 18:29:01 +00:00
|
|
|
|
2010-03-23 05:09:03 +00:00
|
|
|
// FIXME-PERF: We could immediately lower out instructions if we can tell
|
|
|
|
// they are fully resolved, to avoid retesting on later passes.
|
2010-03-12 22:07:14 +00:00
|
|
|
|
2010-03-23 05:09:03 +00:00
|
|
|
// Relax the fragment.
|
|
|
|
|
|
|
|
MCInst Relaxed;
|
|
|
|
getBackend().RelaxInstruction(IF, Relaxed);
|
2010-03-12 22:07:14 +00:00
|
|
|
|
2010-03-23 05:09:03 +00:00
|
|
|
// Encode the new instruction.
|
|
|
|
//
|
|
|
|
// FIXME-PERF: If it matters, we could let the target do this. It can
|
|
|
|
// probably do so more efficiently in many cases.
|
|
|
|
SmallVector<MCFixup, 4> Fixups;
|
|
|
|
SmallString<256> Code;
|
|
|
|
raw_svector_ostream VecOS(Code);
|
|
|
|
getEmitter().EncodeInstruction(Relaxed, VecOS, Fixups);
|
|
|
|
VecOS.flush();
|
|
|
|
|
|
|
|
// Update the instruction fragment.
|
|
|
|
IF->setInst(Relaxed);
|
|
|
|
IF->getCode() = Code;
|
|
|
|
IF->getFixups().clear();
|
|
|
|
for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
|
|
|
|
MCFixup &F = Fixups[i];
|
|
|
|
IF->getFixups().push_back(MCAsmFixup(F.getOffset(), *F.getValue(),
|
|
|
|
F.getKind()));
|
2010-03-12 22:07:14 +00:00
|
|
|
}
|
2010-03-23 05:09:03 +00:00
|
|
|
|
|
|
|
// Restart layout.
|
|
|
|
//
|
|
|
|
// FIXME-PERF: This is O(N^2), but will be eliminated once we have a
|
|
|
|
// smart MCAsmLayout object.
|
|
|
|
return true;
|
2010-03-12 22:07:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2010-02-13 09:28:03 +00:00
|
|
|
|
2010-03-22 23:16:48 +00:00
|
|
|
void MCAssembler::FinishLayout(MCAsmLayout &Layout) {
|
|
|
|
// Lower out any instruction fragments, to simplify the fixup application and
|
|
|
|
// output.
|
|
|
|
//
|
|
|
|
// FIXME-PERF: We don't have to do this, but the assumption is that it is
|
|
|
|
// cheap (we will mostly end up eliminating fragments and appending on to data
|
|
|
|
// fragments), so the extra complexity downstream isn't worth it. Evaluate
|
|
|
|
// this assumption.
|
|
|
|
for (iterator it = begin(), ie = end(); it != ie; ++it) {
|
|
|
|
MCSectionData &SD = *it;
|
|
|
|
|
|
|
|
for (MCSectionData::iterator it2 = SD.begin(),
|
|
|
|
ie2 = SD.end(); it2 != ie2; ++it2) {
|
|
|
|
MCInstFragment *IF = dyn_cast<MCInstFragment>(it2);
|
|
|
|
if (!IF)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Create a new data fragment for the instruction.
|
|
|
|
//
|
2010-03-23 03:13:05 +00:00
|
|
|
// FIXME-PERF: Reuse previous data fragment if possible.
|
2010-03-22 23:16:48 +00:00
|
|
|
MCDataFragment *DF = new MCDataFragment();
|
|
|
|
SD.getFragmentList().insert(it2, DF);
|
|
|
|
|
|
|
|
// Update the data fragments layout data.
|
2010-03-23 01:39:05 +00:00
|
|
|
DF->setParent(IF->getParent());
|
2010-03-22 23:16:48 +00:00
|
|
|
DF->setOffset(IF->getOffset());
|
|
|
|
DF->setFileSize(IF->getInstSize());
|
|
|
|
|
2010-03-23 01:39:05 +00:00
|
|
|
// Copy in the data and the fixups.
|
|
|
|
DF->getContents().append(IF->getCode().begin(), IF->getCode().end());
|
|
|
|
for (unsigned i = 0, e = IF->getFixups().size(); i != e; ++i)
|
|
|
|
DF->getFixups().push_back(IF->getFixups()[i]);
|
2010-03-22 23:16:48 +00:00
|
|
|
|
|
|
|
// Delete the instruction fragment and update the iterator.
|
|
|
|
SD.getFragmentList().erase(IF);
|
|
|
|
it2 = DF;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-13 09:28:03 +00:00
|
|
|
// Debugging methods
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
|
|
|
raw_ostream &operator<<(raw_ostream &OS, const MCAsmFixup &AF) {
|
2010-02-13 09:28:54 +00:00
|
|
|
OS << "<MCAsmFixup" << " Offset:" << AF.Offset << " Value:" << *AF.Value
|
|
|
|
<< " Kind:" << AF.Kind << ">";
|
2010-02-13 09:28:03 +00:00
|
|
|
return OS;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCFragment " << (void*) this << " Offset:" << Offset
|
|
|
|
<< " FileSize:" << FileSize;
|
|
|
|
|
|
|
|
OS << ">";
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCAlignFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCAlignFragment ";
|
|
|
|
this->MCFragment::dump();
|
|
|
|
OS << "\n ";
|
|
|
|
OS << " Alignment:" << getAlignment()
|
|
|
|
<< " Value:" << getValue() << " ValueSize:" << getValueSize()
|
|
|
|
<< " MaxBytesToEmit:" << getMaxBytesToEmit() << ">";
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCDataFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCDataFragment ";
|
|
|
|
this->MCFragment::dump();
|
|
|
|
OS << "\n ";
|
|
|
|
OS << " Contents:[";
|
|
|
|
for (unsigned i = 0, e = getContents().size(); i != e; ++i) {
|
|
|
|
if (i) OS << ",";
|
|
|
|
OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
|
|
|
|
}
|
2010-02-13 09:28:54 +00:00
|
|
|
OS << "] (" << getContents().size() << " bytes)";
|
2010-02-13 09:28:43 +00:00
|
|
|
|
|
|
|
if (!getFixups().empty()) {
|
|
|
|
OS << ",\n ";
|
|
|
|
OS << " Fixups:[";
|
|
|
|
for (fixup_iterator it = fixup_begin(), ie = fixup_end(); it != ie; ++it) {
|
2010-03-09 01:12:23 +00:00
|
|
|
if (it != fixup_begin()) OS << ",\n ";
|
2010-02-13 09:28:43 +00:00
|
|
|
OS << *it;
|
|
|
|
}
|
|
|
|
OS << "]";
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << ">";
|
2010-02-13 09:28:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MCFillFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCFillFragment ";
|
|
|
|
this->MCFragment::dump();
|
|
|
|
OS << "\n ";
|
|
|
|
OS << " Value:" << getValue() << " ValueSize:" << getValueSize()
|
|
|
|
<< " Count:" << getCount() << ">";
|
|
|
|
}
|
|
|
|
|
2010-03-22 23:16:48 +00:00
|
|
|
void MCInstFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCInstFragment ";
|
|
|
|
this->MCFragment::dump();
|
|
|
|
OS << "\n ";
|
|
|
|
OS << " Inst:";
|
|
|
|
getInst().dump_pretty(OS);
|
|
|
|
OS << ">";
|
|
|
|
}
|
|
|
|
|
2010-02-13 09:28:03 +00:00
|
|
|
void MCOrgFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCOrgFragment ";
|
|
|
|
this->MCFragment::dump();
|
|
|
|
OS << "\n ";
|
|
|
|
OS << " Offset:" << getOffset() << " Value:" << getValue() << ">";
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCZeroFillFragment::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCZeroFillFragment ";
|
|
|
|
this->MCFragment::dump();
|
|
|
|
OS << "\n ";
|
|
|
|
OS << " Size:" << getSize() << " Alignment:" << getAlignment() << ">";
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCSectionData::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCSectionData";
|
|
|
|
OS << " Alignment:" << getAlignment() << " Address:" << Address
|
|
|
|
<< " Size:" << Size << " FileSize:" << FileSize
|
2010-03-09 01:12:23 +00:00
|
|
|
<< " Fragments:[\n ";
|
2010-02-13 09:28:03 +00:00
|
|
|
for (iterator it = begin(), ie = end(); it != ie; ++it) {
|
|
|
|
if (it != begin()) OS << ",\n ";
|
|
|
|
it->dump();
|
|
|
|
}
|
|
|
|
OS << "]>";
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCSymbolData::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCSymbolData Symbol:" << getSymbol()
|
|
|
|
<< " Fragment:" << getFragment() << " Offset:" << getOffset()
|
|
|
|
<< " Flags:" << getFlags() << " Index:" << getIndex();
|
|
|
|
if (isCommon())
|
|
|
|
OS << " (common, size:" << getCommonSize()
|
|
|
|
<< " align: " << getCommonAlignment() << ")";
|
|
|
|
if (isExternal())
|
|
|
|
OS << " (external)";
|
|
|
|
if (isPrivateExtern())
|
|
|
|
OS << " (private extern)";
|
|
|
|
OS << ">";
|
|
|
|
}
|
|
|
|
|
|
|
|
void MCAssembler::dump() {
|
|
|
|
raw_ostream &OS = llvm::errs();
|
|
|
|
|
|
|
|
OS << "<MCAssembler\n";
|
2010-03-09 01:12:23 +00:00
|
|
|
OS << " Sections:[\n ";
|
2010-02-13 09:28:03 +00:00
|
|
|
for (iterator it = begin(), ie = end(); it != ie; ++it) {
|
|
|
|
if (it != begin()) OS << ",\n ";
|
|
|
|
it->dump();
|
|
|
|
}
|
|
|
|
OS << "],\n";
|
|
|
|
OS << " Symbols:[";
|
|
|
|
|
|
|
|
for (symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) {
|
2010-03-09 01:12:23 +00:00
|
|
|
if (it != symbol_begin()) OS << ",\n ";
|
2010-02-13 09:28:03 +00:00
|
|
|
it->dump();
|
|
|
|
}
|
|
|
|
OS << "]>\n";
|
|
|
|
}
|