cc290a9e91
Currently, the LLVM will print an error like
Unsupported relocation: try to compile with -O2 or above,
or check your static variable usage
if user defines more than one static variables in a single
ELF section (e.g., .bss or .data).
There is ongoing effort to support static and global
variables in libbpf and kernel. This patch removed the
assertion so user programs with static variables won't
fail compilation.
The static variable in-section offset is written to
the "imm" field of the corresponding to-be-relocated
bpf instruction. Below is an example to show how the
application (e.g., libbpf) can relate variable to relocations.
-bash-4.4$ cat g1.c
static volatile long a = 2;
static volatile int b = 3;
int test() { return a + b; }
-bash-4.4$ clang -target bpf -O2 -c g1.c
-bash-4.4$ llvm-readelf -r g1.o
Relocation section '.rel.text' at offset 0x158 contains 2 entries:
Offset Info Type Symbol's Value Symbol's Name
0000000000000000 0000000400000001 R_BPF_64_64 0000000000000000 .data
0000000000000018 0000000400000001 R_BPF_64_64 0000000000000000 .data
-bash-4.4$ llvm-readelf -s g1.o
Symbol table '.symtab' contains 6 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000000000 0 FILE LOCAL DEFAULT ABS g1.c
2: 0000000000000000 8 OBJECT LOCAL DEFAULT 4 a
3: 0000000000000008 4 OBJECT LOCAL DEFAULT 4 b
4: 0000000000000000 0 SECTION LOCAL DEFAULT 4
5: 0000000000000000 64 FUNC GLOBAL DEFAULT 2 test
-bash-4.4$ llvm-objdump -d g1.o
g1.o: file format ELF64-BPF
Disassembly of section .text:
0000000000000000 test:
0: 18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll
2: 79 11 00 00 00 00 00 00 r1 = *(u64 *)(r1 + 0)
3: 18 02 00 00 08 00 00 00 00 00 00 00 00 00 00 00 r2 = 8 ll
5: 61 20 00 00 00 00 00 00 r0 = *(u32 *)(r2 + 0)
6: 0f 10 00 00 00 00 00 00 r0 += r1
7: 95 00 00 00 00 00 00 00 exit
-bash-4.4$
. from symbol table, static variable "a" is in section #4, offset 0.
. from symbol table, static variable "b" is in section #4, offset 8.
. the first relocation is against symbol #4:
4: 0000000000000000 0 SECTION LOCAL DEFAULT 4
and in-section offset 0 (see llvm-objdump result)
. the second relocation is against symbol #4:
4: 0000000000000000 0 SECTION LOCAL DEFAULT 4
and in-section offset 8 (see llvm-objdump result)
. therefore, the first relocation is for variable "a", and
the second relocation is for variable "b".
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Yonghong Song <yhs@fb.com>
llvm-svn: 354954
120 lines
4.4 KiB
C++
120 lines
4.4 KiB
C++
//===-- BPFAsmBackend.cpp - BPF Assembler Backend -------------------------===//
|
|
//
|
|
// 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 "MCTargetDesc/BPFMCTargetDesc.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/MC/MCAsmBackend.h"
|
|
#include "llvm/MC/MCAssembler.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCFixup.h"
|
|
#include "llvm/MC/MCObjectWriter.h"
|
|
#include "llvm/Support/EndianStream.h"
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
class BPFAsmBackend : public MCAsmBackend {
|
|
public:
|
|
BPFAsmBackend(support::endianness Endian) : MCAsmBackend(Endian) {}
|
|
~BPFAsmBackend() override = default;
|
|
|
|
void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
|
|
const MCValue &Target, MutableArrayRef<char> Data,
|
|
uint64_t Value, bool IsResolved,
|
|
const MCSubtargetInfo *STI) const override;
|
|
|
|
std::unique_ptr<MCObjectTargetWriter>
|
|
createObjectTargetWriter() const override;
|
|
|
|
// No instruction requires relaxation
|
|
bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
|
|
const MCRelaxableFragment *DF,
|
|
const MCAsmLayout &Layout) const override {
|
|
return false;
|
|
}
|
|
|
|
unsigned getNumFixupKinds() const override { return 1; }
|
|
|
|
bool mayNeedRelaxation(const MCInst &Inst,
|
|
const MCSubtargetInfo &STI) const override {
|
|
return false;
|
|
}
|
|
|
|
void relaxInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
|
|
MCInst &Res) const override {}
|
|
|
|
bool writeNopData(raw_ostream &OS, uint64_t Count) const override;
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
bool BPFAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count) const {
|
|
if ((Count % 8) != 0)
|
|
return false;
|
|
|
|
for (uint64_t i = 0; i < Count; i += 8)
|
|
support::endian::write<uint64_t>(OS, 0x15000000, Endian);
|
|
|
|
return true;
|
|
}
|
|
|
|
void BPFAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
|
|
const MCValue &Target,
|
|
MutableArrayRef<char> Data, uint64_t Value,
|
|
bool IsResolved,
|
|
const MCSubtargetInfo *STI) const {
|
|
if (Fixup.getKind() == FK_SecRel_4 || Fixup.getKind() == FK_SecRel_8) {
|
|
// The Value is 0 for global variables, and the in-section offset
|
|
// for static variables. Write to the immediate field of the inst.
|
|
assert(Value <= UINT32_MAX);
|
|
support::endian::write<uint32_t>(&Data[Fixup.getOffset() + 4],
|
|
static_cast<uint32_t>(Value),
|
|
Endian);
|
|
} else if (Fixup.getKind() == FK_Data_4) {
|
|
support::endian::write<uint32_t>(&Data[Fixup.getOffset()], Value, Endian);
|
|
} else if (Fixup.getKind() == FK_Data_8) {
|
|
support::endian::write<uint64_t>(&Data[Fixup.getOffset()], Value, Endian);
|
|
} else if (Fixup.getKind() == FK_PCRel_4) {
|
|
Value = (uint32_t)((Value - 8) / 8);
|
|
if (Endian == support::little) {
|
|
Data[Fixup.getOffset() + 1] = 0x10;
|
|
support::endian::write32le(&Data[Fixup.getOffset() + 4], Value);
|
|
} else {
|
|
Data[Fixup.getOffset() + 1] = 0x1;
|
|
support::endian::write32be(&Data[Fixup.getOffset() + 4], Value);
|
|
}
|
|
} else {
|
|
assert(Fixup.getKind() == FK_PCRel_2);
|
|
Value = (uint16_t)((Value - 8) / 8);
|
|
support::endian::write<uint16_t>(&Data[Fixup.getOffset() + 2], Value,
|
|
Endian);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<MCObjectTargetWriter>
|
|
BPFAsmBackend::createObjectTargetWriter() const {
|
|
return createBPFELFObjectWriter(0);
|
|
}
|
|
|
|
MCAsmBackend *llvm::createBPFAsmBackend(const Target &T,
|
|
const MCSubtargetInfo &STI,
|
|
const MCRegisterInfo &MRI,
|
|
const MCTargetOptions &) {
|
|
return new BPFAsmBackend(support::little);
|
|
}
|
|
|
|
MCAsmBackend *llvm::createBPFbeAsmBackend(const Target &T,
|
|
const MCSubtargetInfo &STI,
|
|
const MCRegisterInfo &MRI,
|
|
const MCTargetOptions &) {
|
|
return new BPFAsmBackend(support::big);
|
|
}
|