2010-11-15 09:49:58 +01:00
|
|
|
//===-- PPCAsmBackend.cpp - PPC Assembler Backend -------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-07-25 21:53:23 +02:00
|
|
|
#include "MCTargetDesc/PPCMCTargetDesc.h"
|
|
|
|
#include "MCTargetDesc/PPCFixupKinds.h"
|
2012-03-17 19:46:09 +01:00
|
|
|
#include "llvm/MC/MCAsmBackend.h"
|
2011-08-02 17:51:38 +02:00
|
|
|
#include "llvm/MC/MCELFObjectWriter.h"
|
2012-03-26 08:58:25 +02:00
|
|
|
#include "llvm/MC/MCFixupKindInfo.h"
|
2010-12-16 17:08:33 +01:00
|
|
|
#include "llvm/MC/MCMachObjectWriter.h"
|
2010-11-15 09:49:58 +01:00
|
|
|
#include "llvm/MC/MCObjectWriter.h"
|
2012-12-03 17:50:05 +01:00
|
|
|
#include "llvm/MC/MCSectionMachO.h"
|
2011-06-25 01:44:37 +02:00
|
|
|
#include "llvm/MC/MCValue.h"
|
2010-11-27 05:38:36 +01:00
|
|
|
#include "llvm/Object/MachOFormat.h"
|
2011-08-02 17:51:38 +02:00
|
|
|
#include "llvm/Support/ELF.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2011-08-24 20:08:43 +02:00
|
|
|
#include "llvm/Support/TargetRegistry.h"
|
2010-11-15 09:49:58 +01:00
|
|
|
using namespace llvm;
|
|
|
|
|
2013-05-15 17:01:46 +02:00
|
|
|
static uint64_t adjustFixupValue(unsigned Kind, uint64_t Value) {
|
2011-08-02 17:51:38 +02:00
|
|
|
switch (Kind) {
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unknown fixup kind!");
|
|
|
|
case FK_Data_1:
|
|
|
|
case FK_Data_2:
|
|
|
|
case FK_Data_4:
|
2012-10-25 14:27:42 +02:00
|
|
|
case FK_Data_8:
|
2012-12-12 20:29:35 +01:00
|
|
|
case PPC::fixup_ppc_nofixup:
|
2011-08-02 17:51:38 +02:00
|
|
|
return Value;
|
|
|
|
case PPC::fixup_ppc_brcond14:
|
2013-06-24 13:03:33 +02:00
|
|
|
case PPC::fixup_ppc_brcond14abs:
|
2012-10-25 14:27:42 +02:00
|
|
|
return Value & 0xfffc;
|
2011-08-02 17:51:38 +02:00
|
|
|
case PPC::fixup_ppc_br24:
|
2013-06-24 13:03:33 +02:00
|
|
|
case PPC::fixup_ppc_br24abs:
|
2011-08-02 17:51:38 +02:00
|
|
|
return Value & 0x3fffffc;
|
2013-05-17 14:37:21 +02:00
|
|
|
case PPC::fixup_ppc_half16:
|
2011-08-02 17:51:38 +02:00
|
|
|
return Value & 0xffff;
|
2013-05-17 14:37:21 +02:00
|
|
|
case PPC::fixup_ppc_half16ds:
|
PowerPC: Simplify handling of fixups.
MCTargetDesc/PPCMCCodeEmitter.cpp current has code like:
if (isSVR4ABI() && is64BitMode())
Fixups.push_back(MCFixup::Create(0, MO.getExpr(),
(MCFixupKind)PPC::fixup_ppc_toc16));
else
Fixups.push_back(MCFixup::Create(0, MO.getExpr(),
(MCFixupKind)PPC::fixup_ppc_lo16));
This is a problem for the asm parser, since it requires knowledge of
the ABI / 64-bit mode to be set up. However, more fundamentally,
at this point we shouldn't make such distinctions anyway; in an assembler
file, it always ought to be possible to e.g. generate TOC relocations even
when the main ABI is one that doesn't use TOC.
Fortunately, this is actually completely unnecessary; that code was added
to decide whether to generate TOC relocations, but that information is in
fact already encoded in the VariantKind of the underlying symbol.
This commit therefore merges those fixup types into one, and then decides
which relocation to use based on the VariantKind.
No changes in generated code.
llvm-svn: 178007
2013-03-26 11:56:47 +01:00
|
|
|
return Value & 0xfffc;
|
2011-08-02 17:51:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-15 17:01:46 +02:00
|
|
|
static unsigned getFixupKindNumBytes(unsigned Kind) {
|
|
|
|
switch (Kind) {
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unknown fixup kind!");
|
|
|
|
case FK_Data_1:
|
|
|
|
return 1;
|
|
|
|
case FK_Data_2:
|
2013-05-17 14:37:21 +02:00
|
|
|
case PPC::fixup_ppc_half16:
|
|
|
|
case PPC::fixup_ppc_half16ds:
|
2013-05-15 17:01:46 +02:00
|
|
|
return 2;
|
|
|
|
case FK_Data_4:
|
|
|
|
case PPC::fixup_ppc_brcond14:
|
2013-06-24 13:03:33 +02:00
|
|
|
case PPC::fixup_ppc_brcond14abs:
|
2013-05-15 17:01:46 +02:00
|
|
|
case PPC::fixup_ppc_br24:
|
2013-06-24 13:03:33 +02:00
|
|
|
case PPC::fixup_ppc_br24abs:
|
2013-05-15 17:01:46 +02:00
|
|
|
return 4;
|
|
|
|
case FK_Data_8:
|
|
|
|
return 8;
|
|
|
|
case PPC::fixup_ppc_nofixup:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-15 09:49:58 +01:00
|
|
|
namespace {
|
2010-12-16 17:09:19 +01:00
|
|
|
class PPCMachObjectWriter : public MCMachObjectTargetWriter {
|
2010-12-16 18:21:02 +01:00
|
|
|
public:
|
|
|
|
PPCMachObjectWriter(bool Is64Bit, uint32_t CPUType,
|
|
|
|
uint32_t CPUSubtype)
|
|
|
|
: MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype) {}
|
2011-06-25 01:44:37 +02:00
|
|
|
|
|
|
|
void RecordRelocation(MachObjectWriter *Writer,
|
|
|
|
const MCAssembler &Asm, const MCAsmLayout &Layout,
|
|
|
|
const MCFragment *Fragment, const MCFixup &Fixup,
|
2012-11-24 16:23:49 +01:00
|
|
|
MCValue Target, uint64_t &FixedValue) {
|
|
|
|
llvm_unreachable("Relocation emission for MachO/PPC unimplemented!");
|
|
|
|
}
|
2010-12-16 17:09:19 +01:00
|
|
|
};
|
|
|
|
|
2011-07-26 01:24:55 +02:00
|
|
|
class PPCAsmBackend : public MCAsmBackend {
|
2010-12-16 17:08:43 +01:00
|
|
|
const Target &TheTarget;
|
|
|
|
public:
|
2011-07-26 01:24:55 +02:00
|
|
|
PPCAsmBackend(const Target &T) : MCAsmBackend(), TheTarget(T) {}
|
2010-12-16 04:20:06 +01:00
|
|
|
|
2010-12-16 17:08:43 +01:00
|
|
|
unsigned getNumFixupKinds() const { return PPC::NumTargetFixupKinds; }
|
|
|
|
|
|
|
|
const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const {
|
|
|
|
const static MCFixupKindInfo Infos[PPC::NumTargetFixupKinds] = {
|
|
|
|
// name offset bits flags
|
|
|
|
{ "fixup_ppc_br24", 6, 24, MCFixupKindInfo::FKF_IsPCRel },
|
|
|
|
{ "fixup_ppc_brcond14", 16, 14, MCFixupKindInfo::FKF_IsPCRel },
|
2013-06-24 13:03:33 +02:00
|
|
|
{ "fixup_ppc_br24abs", 6, 24, 0 },
|
|
|
|
{ "fixup_ppc_brcond14abs", 16, 14, 0 },
|
2013-05-17 14:37:21 +02:00
|
|
|
{ "fixup_ppc_half16", 0, 16, 0 },
|
|
|
|
{ "fixup_ppc_half16ds", 0, 14, 0 },
|
2012-12-12 20:29:35 +01:00
|
|
|
{ "fixup_ppc_nofixup", 0, 0, 0 }
|
2010-12-16 17:08:43 +01:00
|
|
|
};
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2010-12-16 17:08:43 +01:00
|
|
|
if (Kind < FirstTargetFixupKind)
|
2011-07-26 01:24:55 +02:00
|
|
|
return MCAsmBackend::getFixupKindInfo(Kind);
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2010-12-16 17:08:43 +01:00
|
|
|
assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
|
|
|
|
"Invalid kind!");
|
|
|
|
return Infos[Kind - FirstTargetFixupKind];
|
|
|
|
}
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2012-11-24 14:18:17 +01:00
|
|
|
void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
|
|
|
|
uint64_t Value) const {
|
|
|
|
Value = adjustFixupValue(Fixup.getKind(), Value);
|
|
|
|
if (!Value) return; // Doesn't change encoding.
|
|
|
|
|
|
|
|
unsigned Offset = Fixup.getOffset();
|
2013-05-15 17:01:46 +02:00
|
|
|
unsigned NumBytes = getFixupKindNumBytes(Fixup.getKind());
|
2012-11-24 14:18:17 +01:00
|
|
|
|
|
|
|
// For each byte of the fragment that the fixup touches, mask in the bits
|
|
|
|
// from the fixup value. The Value has been "split up" into the appropriate
|
|
|
|
// bitfields above.
|
2013-05-15 17:01:46 +02:00
|
|
|
for (unsigned i = 0; i != NumBytes; ++i)
|
|
|
|
Data[Offset + i] |= uint8_t((Value >> ((NumBytes - i - 1)*8)) & 0xff);
|
2012-11-24 14:18:17 +01:00
|
|
|
}
|
|
|
|
|
2012-01-18 19:52:16 +01:00
|
|
|
bool mayNeedRelaxation(const MCInst &Inst) const {
|
2010-12-16 17:08:43 +01:00
|
|
|
// FIXME.
|
|
|
|
return false;
|
|
|
|
}
|
2011-12-06 01:47:03 +01:00
|
|
|
|
|
|
|
bool fixupNeedsRelaxation(const MCFixup &Fixup,
|
|
|
|
uint64_t Value,
|
2013-01-08 01:22:56 +01:00
|
|
|
const MCRelaxableFragment *DF,
|
2011-12-06 01:47:03 +01:00
|
|
|
const MCAsmLayout &Layout) const {
|
|
|
|
// FIXME.
|
2012-02-07 03:50:20 +01:00
|
|
|
llvm_unreachable("relaxInstruction() unimplemented");
|
2011-12-06 01:47:03 +01:00
|
|
|
}
|
|
|
|
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2012-01-18 19:52:16 +01:00
|
|
|
void relaxInstruction(const MCInst &Inst, MCInst &Res) const {
|
2010-12-16 17:08:43 +01:00
|
|
|
// FIXME.
|
2012-02-07 03:50:20 +01:00
|
|
|
llvm_unreachable("relaxInstruction() unimplemented");
|
2010-12-16 17:08:43 +01:00
|
|
|
}
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2012-01-18 19:52:16 +01:00
|
|
|
bool writeNopData(uint64_t Count, MCObjectWriter *OW) const {
|
2013-07-04 20:28:46 +02:00
|
|
|
// Can't emit NOP with size not multiple of 32-bits
|
|
|
|
if (Count % 4 != 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
uint64_t NumNops = Count / 4;
|
|
|
|
for (uint64_t i = 0; i != NumNops; ++i)
|
|
|
|
OW->Write32(0x60000000);
|
|
|
|
|
2010-12-16 17:08:43 +01:00
|
|
|
return true;
|
2012-01-18 19:52:20 +01:00
|
|
|
}
|
|
|
|
|
2010-12-16 17:08:43 +01:00
|
|
|
unsigned getPointerSize() const {
|
|
|
|
StringRef Name = TheTarget.getName();
|
2013-07-26 03:35:43 +02:00
|
|
|
if (Name == "ppc64" || Name == "ppc64le") return 8;
|
2010-12-16 17:08:43 +01:00
|
|
|
assert(Name == "ppc32" && "Unknown target name!");
|
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
};
|
2010-11-15 09:49:58 +01:00
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
|
|
|
// FIXME: This should be in a separate file.
|
|
|
|
namespace {
|
|
|
|
class DarwinPPCAsmBackend : public PPCAsmBackend {
|
|
|
|
public:
|
2010-12-17 03:06:08 +01:00
|
|
|
DarwinPPCAsmBackend(const Target &T) : PPCAsmBackend(T) { }
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2010-11-15 09:49:58 +01:00
|
|
|
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
|
|
|
|
bool is64 = getPointerSize() == 8;
|
2010-12-16 18:21:02 +01:00
|
|
|
return createMachObjectWriter(new PPCMachObjectWriter(
|
|
|
|
/*Is64Bit=*/is64,
|
|
|
|
(is64 ? object::mach::CTM_PowerPC64 :
|
|
|
|
object::mach::CTM_PowerPC),
|
|
|
|
object::mach::CSPPC_ALL),
|
|
|
|
OS, /*IsLittleEndian=*/false);
|
2010-11-15 09:49:58 +01:00
|
|
|
}
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2010-11-15 09:49:58 +01:00
|
|
|
virtual bool doesSectionRequireSymbols(const MCSection &Section) const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
2011-08-02 17:51:38 +02:00
|
|
|
|
|
|
|
class ELFPPCAsmBackend : public PPCAsmBackend {
|
2011-12-21 18:00:36 +01:00
|
|
|
uint8_t OSABI;
|
2011-08-02 17:51:38 +02:00
|
|
|
public:
|
2011-12-21 18:00:36 +01:00
|
|
|
ELFPPCAsmBackend(const Target &T, uint8_t OSABI) :
|
|
|
|
PPCAsmBackend(T), OSABI(OSABI) { }
|
2012-01-18 19:52:20 +01:00
|
|
|
|
|
|
|
|
2011-08-02 17:51:38 +02:00
|
|
|
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
|
|
|
|
bool is64 = getPointerSize() == 8;
|
2011-12-22 19:38:06 +01:00
|
|
|
return createPPCELFObjectWriter(OS, is64, OSABI);
|
2011-08-02 17:51:38 +02:00
|
|
|
}
|
2012-01-18 19:52:20 +01:00
|
|
|
|
2011-08-02 17:51:38 +02:00
|
|
|
virtual bool doesSectionRequireSymbols(const MCSection &Section) const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-11-15 09:49:58 +01:00
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-09-18 18:08:49 +02:00
|
|
|
MCAsmBackend *llvm::createPPCAsmBackend(const Target &T, StringRef TT, StringRef CPU) {
|
2011-04-19 23:14:45 +02:00
|
|
|
if (Triple(TT).isOSDarwin())
|
2010-11-15 09:49:58 +01:00
|
|
|
return new DarwinPPCAsmBackend(T);
|
2011-04-19 23:14:45 +02:00
|
|
|
|
2011-12-21 18:00:36 +01:00
|
|
|
uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(Triple(TT).getOS());
|
|
|
|
return new ELFPPCAsmBackend(T, OSABI);
|
2010-11-15 09:49:58 +01:00
|
|
|
}
|