mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 03:33:20 +01:00
ebc93587cb
For RISC-V it is desirable to have relaxation happen in the linker once addresses are known, and as such the size between two instructions/byte sequences in a section could change. For most assembler expressions, this is fine, as the absolute address results in the expression being converted to a fixup, and finally relocations. However, for expressions such as .quad .L2-.L1, the assembler folds this down to a constant once fragments are laid out, under the assumption that the difference can no longer change, although in the case of linker relaxation the differences can change at link time, so the constant is incorrect. One place where this commonly appears is in debug information, where the size of a function expression is in a form similar to the above. This patch extends the assembler to allow an AsmBackend to declare that it does not want the assembler to fold down this expression, and instead generate a pair of relocations that allow the linker to carry out the calculation. In this case, the expression is not folded, but when it comes to emitting a fixup, the generic FK_Data_* fixups are converted into a pair, one for the addition half, one for the subtraction, and this is passed to the relocation generating methods as usual. I have named these FK_Data_Add_* and FK_Data_Sub_* to indicate which half these are for. For RISC-V, which supports this via e.g. the R_RISCV_ADD64, R_RISCV_SUB64 pair of relocations, these are also set to always emit relocations relative to local symbols rather than section offsets. This is to deal with the fact that if relocations were calculated on e.g. .text+8 and .text+4, the result 12 would be stored rather than 4 as both addends are added in the linker. Differential Revision: https://reviews.llvm.org/D45181 Patch by Simon Cook. llvm-svn: 333079
131 lines
4.4 KiB
C++
131 lines
4.4 KiB
C++
//===- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/MC/MCAsmBackend.h"
|
|
#include "llvm/ADT/None.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/MC/MCCodePadder.h"
|
|
#include "llvm/MC/MCELFObjectWriter.h"
|
|
#include "llvm/MC/MCFixupKindInfo.h"
|
|
#include "llvm/MC/MCMachObjectWriter.h"
|
|
#include "llvm/MC/MCObjectWriter.h"
|
|
#include "llvm/MC/MCWasmObjectWriter.h"
|
|
#include "llvm/MC/MCWinCOFFObjectWriter.h"
|
|
#include <cassert>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
|
|
using namespace llvm;
|
|
|
|
MCAsmBackend::MCAsmBackend(support::endianness Endian)
|
|
: CodePadder(new MCCodePadder()), Endian(Endian) {}
|
|
|
|
MCAsmBackend::~MCAsmBackend() = default;
|
|
|
|
std::unique_ptr<MCObjectWriter>
|
|
MCAsmBackend::createObjectWriter(raw_pwrite_stream &OS) const {
|
|
auto TW = createObjectTargetWriter();
|
|
switch (TW->getFormat()) {
|
|
case Triple::ELF:
|
|
return createELFObjectWriter(cast<MCELFObjectTargetWriter>(std::move(TW)), OS,
|
|
Endian == support::little);
|
|
case Triple::MachO:
|
|
return createMachObjectWriter(cast<MCMachObjectTargetWriter>(std::move(TW)),
|
|
OS, Endian == support::little);
|
|
case Triple::COFF:
|
|
return createWinCOFFObjectWriter(
|
|
cast<MCWinCOFFObjectTargetWriter>(std::move(TW)), OS);
|
|
case Triple::Wasm:
|
|
return createWasmObjectWriter(cast<MCWasmObjectTargetWriter>(std::move(TW)),
|
|
OS);
|
|
default:
|
|
llvm_unreachable("unexpected object format");
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<MCObjectWriter>
|
|
MCAsmBackend::createDwoObjectWriter(raw_pwrite_stream &OS,
|
|
raw_pwrite_stream &DwoOS) const {
|
|
auto TW = createObjectTargetWriter();
|
|
if (TW->getFormat() != Triple::ELF)
|
|
report_fatal_error("dwo only supported with ELF");
|
|
return createELFDwoObjectWriter(cast<MCELFObjectTargetWriter>(std::move(TW)),
|
|
OS, DwoOS, Endian == support::little);
|
|
}
|
|
|
|
Optional<MCFixupKind> MCAsmBackend::getFixupKind(StringRef Name) const {
|
|
return None;
|
|
}
|
|
|
|
const MCFixupKindInfo &MCAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
|
|
static const MCFixupKindInfo Builtins[] = {
|
|
{"FK_Data_1", 0, 8, 0},
|
|
{"FK_Data_2", 0, 16, 0},
|
|
{"FK_Data_4", 0, 32, 0},
|
|
{"FK_Data_8", 0, 64, 0},
|
|
{"FK_PCRel_1", 0, 8, MCFixupKindInfo::FKF_IsPCRel},
|
|
{"FK_PCRel_2", 0, 16, MCFixupKindInfo::FKF_IsPCRel},
|
|
{"FK_PCRel_4", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
|
|
{"FK_PCRel_8", 0, 64, MCFixupKindInfo::FKF_IsPCRel},
|
|
{"FK_GPRel_1", 0, 8, 0},
|
|
{"FK_GPRel_2", 0, 16, 0},
|
|
{"FK_GPRel_4", 0, 32, 0},
|
|
{"FK_GPRel_8", 0, 64, 0},
|
|
{"FK_DTPRel_4", 0, 32, 0},
|
|
{"FK_DTPRel_8", 0, 64, 0},
|
|
{"FK_TPRel_4", 0, 32, 0},
|
|
{"FK_TPRel_8", 0, 64, 0},
|
|
{"FK_SecRel_1", 0, 8, 0},
|
|
{"FK_SecRel_2", 0, 16, 0},
|
|
{"FK_SecRel_4", 0, 32, 0},
|
|
{"FK_SecRel_8", 0, 64, 0},
|
|
{"FK_Data_Add_1", 0, 8, 0},
|
|
{"FK_Data_Add_2", 0, 16, 0},
|
|
{"FK_Data_Add_4", 0, 32, 0},
|
|
{"FK_Data_Add_8", 0, 64, 0},
|
|
{"FK_Data_Sub_1", 0, 8, 0},
|
|
{"FK_Data_Sub_2", 0, 16, 0},
|
|
{"FK_Data_Sub_4", 0, 32, 0},
|
|
{"FK_Data_Sub_8", 0, 64, 0}};
|
|
|
|
assert((size_t)Kind <= array_lengthof(Builtins) && "Unknown fixup kind");
|
|
return Builtins[Kind];
|
|
}
|
|
|
|
bool MCAsmBackend::fixupNeedsRelaxationAdvanced(
|
|
const MCFixup &Fixup, bool Resolved, uint64_t Value,
|
|
const MCRelaxableFragment *DF, const MCAsmLayout &Layout,
|
|
const bool WasForced) const {
|
|
if (!Resolved)
|
|
return true;
|
|
return fixupNeedsRelaxation(Fixup, Value, DF, Layout);
|
|
}
|
|
|
|
void MCAsmBackend::handleCodePaddingBasicBlockStart(
|
|
MCObjectStreamer *OS, const MCCodePaddingContext &Context) {
|
|
CodePadder->handleBasicBlockStart(OS, Context);
|
|
}
|
|
|
|
void MCAsmBackend::handleCodePaddingBasicBlockEnd(
|
|
const MCCodePaddingContext &Context) {
|
|
CodePadder->handleBasicBlockEnd(Context);
|
|
}
|
|
|
|
void MCAsmBackend::handleCodePaddingInstructionBegin(const MCInst &Inst) {
|
|
CodePadder->handleInstructionBegin(Inst);
|
|
}
|
|
|
|
void MCAsmBackend::handleCodePaddingInstructionEnd(const MCInst &Inst) {
|
|
CodePadder->handleInstructionEnd(Inst);
|
|
}
|
|
|
|
bool MCAsmBackend::relaxFragment(MCPaddingFragment *PF, MCAsmLayout &Layout) {
|
|
return CodePadder->relaxFragment(PF, Layout);
|
|
}
|