9e8f7acd2b
Span-dependent instructions on RISC-V interact in a complex manner with linker relaxation. The span-dependent assembler algorithm implemented in LLVM has to start with the smallest version of an instruction and then only make it larger, so we compress instructions before emitting them to the streamer. When the instruction is streamed, the information that the instruction (or rather, the fixup on the instruction) is linker relaxable must be accurate, even though the assembler relaxation process may transform a not-linker-relaxable instruction/fixup into one that that is linker relaxable, for instance `c.jal` becoming `qc.e.jal`, or `bne` getting turned into `beq; jal` (the `jal` is linker relaxable). In order for this to work, the following things have to happen: - Any instruction/fixup which might be relaxed to a linker-relaxable instruction/fixup, gets marked as `RelaxCandidate = true` in RISCVMCCodeEmitter. - In RISCVAsmBackend, when emitting the `R_RISCV_RELAX` relocation, we have to check that the relocation/fixup kind is one that may need a relax relocation, as well as that it is marked as linker relaxable (the latter will not be set if relaxation is disabled). - Linker Relaxable instructions streamed to a Relaxable fragment need to mark the fragment and its section as linker relaxable. I also added more debug output for Sections/Fixups which are marked Linker Relaxable. This results in more relocations, when these PC-relative fixups cross an instruction with a fixup that is resolved as not linker-relaxable but caused the fragment to be marked linker relaxable at streaming time (i.e. `c.j`). Fixes: #150071
104 lines
3.4 KiB
C++
104 lines
3.4 KiB
C++
//===- lib/MC/MCSection.cpp - Machine Code Section Representation ---------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/MC/MCSection.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Config/llvm-config.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCSymbol.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <utility>
|
|
|
|
using namespace llvm;
|
|
|
|
MCSection::MCSection(StringRef Name, bool IsText, bool IsBss, MCSymbol *Begin)
|
|
: Begin(Begin), HasInstructions(false), IsRegistered(false), IsText(IsText),
|
|
IsBss(IsBss), Name(Name) {
|
|
DummyFragment.setParent(this);
|
|
}
|
|
|
|
MCSymbol *MCSection::getEndSymbol(MCContext &Ctx) {
|
|
if (!End)
|
|
End = Ctx.createTempSymbol("sec_end");
|
|
return End;
|
|
}
|
|
|
|
bool MCSection::hasEnded() const { return End && End->isInSection(); }
|
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
|
LLVM_DUMP_METHOD void MCSection::dump(
|
|
DenseMap<const MCFragment *, SmallVector<const MCSymbol *, 0>> *FragToSyms)
|
|
const {
|
|
raw_ostream &OS = errs();
|
|
|
|
OS << "MCSection Name:" << getName();
|
|
if (isLinkerRelaxable())
|
|
OS << " FirstLinkerRelaxable:" << firstLinkerRelaxable();
|
|
for (auto &F : *this) {
|
|
OS << '\n';
|
|
F.dump();
|
|
if (!FragToSyms)
|
|
continue;
|
|
auto It = FragToSyms->find(&F);
|
|
if (It == FragToSyms->end())
|
|
continue;
|
|
for (auto *Sym : It->second) {
|
|
OS << "\n Symbol @" << Sym->getOffset() << ' ' << Sym->getName();
|
|
if (Sym->isTemporary())
|
|
OS << " Temporary";
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void MCFragment::setVarContents(ArrayRef<char> Contents) {
|
|
auto &S = getParent()->ContentStorage;
|
|
if (VarContentStart + Contents.size() > VarContentEnd) {
|
|
VarContentStart = S.size();
|
|
S.resize_for_overwrite(S.size() + Contents.size());
|
|
}
|
|
VarContentEnd = VarContentStart + Contents.size();
|
|
llvm::copy(Contents, S.begin() + VarContentStart);
|
|
}
|
|
|
|
void MCFragment::addFixup(MCFixup Fixup) { appendFixups({Fixup}); }
|
|
|
|
void MCFragment::appendFixups(ArrayRef<MCFixup> Fixups) {
|
|
auto &S = getParent()->FixupStorage;
|
|
if (LLVM_UNLIKELY(FixupEnd != S.size())) {
|
|
// Move the elements to the end. Reserve space to avoid invalidating
|
|
// S.begin()+I for `append`.
|
|
auto Size = FixupEnd - FixupStart;
|
|
auto I = std::exchange(FixupStart, S.size());
|
|
S.reserve(S.size() + Size);
|
|
S.append(S.begin() + I, S.begin() + I + Size);
|
|
}
|
|
S.append(Fixups.begin(), Fixups.end());
|
|
FixupEnd = S.size();
|
|
}
|
|
|
|
void MCFragment::setVarFixups(ArrayRef<MCFixup> Fixups) {
|
|
assert(Fixups.size() < 256 &&
|
|
"variable-size tail cannot have more than 256 fixups");
|
|
auto &S = getParent()->FixupStorage;
|
|
if (Fixups.size() > VarFixupSize) {
|
|
VarFixupStart = S.size();
|
|
S.resize_for_overwrite(S.size() + Fixups.size());
|
|
}
|
|
VarFixupSize = Fixups.size();
|
|
// Source fixup offsets are relative to the variable part's start. Add the
|
|
// fixed part size to make them relative to the fixed part's start.
|
|
std::transform(Fixups.begin(), Fixups.end(), S.begin() + VarFixupStart,
|
|
[Fixed = getFixedSize()](MCFixup F) {
|
|
F.setOffset(Fixed + F.getOffset());
|
|
return F;
|
|
});
|
|
}
|