2ccf7ed277
Use SymbolStringPtr for Symbol names in LinkGraph. This reduces string interning on the boundary between JITLink and ORC, and allows pointer comparisons (rather than string comparisons) between Symbol names. This should improve the performance and readability of code that bridges between JITLink and ORC (e.g. ObjectLinkingLayer and ObjectLinkingLayer::Plugins). To enable use of SymbolStringPtr a std::shared_ptr<SymbolStringPool> is added to LinkGraph and threaded through to its construction sites in LLVM and Bolt. All LinkGraphs that are to have symbol names compared by pointer equality must point to the same SymbolStringPool instance, which in ORC sessions should be the pool attached to the ExecutionSession. --------- Co-authored-by: Lang Hames <lhames@gmail.com>
305 lines
12 KiB
C++
305 lines
12 KiB
C++
//===------- AArch32ErrorTests.cpp - Test AArch32 error handling ----------===//
|
|
//
|
|
// 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/ExecutionEngine/Orc/SymbolStringPool.h"
|
|
#include "llvm/Testing/Support/Error.h"
|
|
#include "gtest/gtest.h"
|
|
#include <llvm/ExecutionEngine/JITLink/aarch32.h>
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::jitlink;
|
|
using namespace llvm::jitlink::aarch32;
|
|
using namespace llvm::support;
|
|
using namespace llvm::support::endian;
|
|
|
|
constexpr unsigned PointerSize = 4;
|
|
auto G = std::make_unique<LinkGraph>(
|
|
"foo", std::make_shared<orc::SymbolStringPool>(),
|
|
Triple("armv7-linux-gnueabi"), PointerSize, endianness::little,
|
|
aarch32::getEdgeKindName);
|
|
auto &Sec =
|
|
G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
|
|
|
|
auto ArmCfg = getArmConfigForCPUArch(ARMBuildAttrs::v7);
|
|
|
|
constexpr uint64_t ArmAlignment = 4;
|
|
constexpr uint64_t ThumbAlignment = 2;
|
|
constexpr uint64_t AlignmentOffset = 0;
|
|
|
|
constexpr orc::ExecutorAddrDiff SymbolOffset = 0;
|
|
constexpr orc::ExecutorAddrDiff SymbolSize = 4;
|
|
|
|
class AArch32Errors : public testing::Test {
|
|
protected:
|
|
const ArmConfig Cfg = getArmConfigForCPUArch(ARMBuildAttrs::v7);
|
|
std::unique_ptr<LinkGraph> G;
|
|
Section *S = nullptr;
|
|
|
|
const uint8_t Zeros[4]{0x00, 0x00, 0x00, 0x00};
|
|
uint8_t MutableZeros[4]{0x00, 0x00, 0x00, 0x00};
|
|
|
|
public:
|
|
static void SetUpTestCase() {}
|
|
|
|
void SetUp() override {
|
|
G = std::make_unique<LinkGraph>(
|
|
"foo", std::make_shared<orc::SymbolStringPool>(),
|
|
Triple("armv7-linux-gnueabi"), PointerSize, endianness::little,
|
|
aarch32::getEdgeKindName);
|
|
S = &G->createSection("__data", orc::MemProt::Read | orc::MemProt::Write);
|
|
}
|
|
|
|
void TearDown() override {}
|
|
|
|
protected:
|
|
template <size_t Size>
|
|
Block &createBlock(const uint8_t (&Content)[Size], uint64_t Addr,
|
|
uint64_t Alignment = 4) {
|
|
ArrayRef<char> CharContent{reinterpret_cast<const char *>(&Content),
|
|
sizeof(Content)};
|
|
return G->createContentBlock(*S, CharContent, orc::ExecutorAddr(Addr),
|
|
Alignment, AlignmentOffset);
|
|
}
|
|
|
|
template <size_t Size>
|
|
Block &createMutableBlock(uint8_t (&Content)[Size], uint64_t Addr,
|
|
uint64_t Alignment = 4) {
|
|
MutableArrayRef<char> CharContent{reinterpret_cast<char *>(&Content),
|
|
sizeof(Content)};
|
|
return G->createMutableContentBlock(
|
|
*S, CharContent, orc::ExecutorAddr(Addr), Alignment, AlignmentOffset);
|
|
}
|
|
|
|
Symbol &createSymbolWithDistance(Block &Origin, uint64_t Dist) {
|
|
uint64_t TargetAddr = Origin.getAddress().getValue() + Dist;
|
|
return G->addAnonymousSymbol(createBlock(Zeros, TargetAddr), 0 /*Offset*/,
|
|
PointerSize, false, false);
|
|
};
|
|
|
|
template <endianness Endian> void write(uint8_t *Mem, HalfWords Data) {
|
|
write16<Endian>(Mem, Data.Hi);
|
|
write16<Endian>(Mem + 2, Data.Lo);
|
|
}
|
|
};
|
|
|
|
TEST_F(AArch32Errors, readAddendDataGeneric) {
|
|
Block &ZerosBlock = createBlock(Zeros, 0x1000);
|
|
constexpr uint64_t ZerosOffset = 0;
|
|
|
|
// Invalid edge kind is the only error we can raise here right now.
|
|
Edge::Kind Invalid = Edge::GenericEdgeKind::Invalid;
|
|
EXPECT_THAT_EXPECTED(readAddend(*G, ZerosBlock, ZerosOffset, Invalid, Cfg),
|
|
FailedWithMessage(testing::HasSubstr(
|
|
"can not read implicit addend for aarch32 edge kind "
|
|
"INVALID RELOCATION")));
|
|
}
|
|
|
|
TEST(AArch32_ELF, readAddendArmErrors) {
|
|
|
|
constexpr orc::ExecutorAddr B1DummyAddr(0x1000);
|
|
|
|
// Permanently undefined instruction in ARM
|
|
// udf #0
|
|
uint8_t ArmWord[] = {0xf0, 0x00, 0xf0, 0xe7};
|
|
ArrayRef<char> ArmContent(reinterpret_cast<const char *>(&ArmWord),
|
|
sizeof(ArmWord));
|
|
auto &BArm = G->createContentBlock(Sec, ArmContent, B1DummyAddr, ArmAlignment,
|
|
AlignmentOffset);
|
|
|
|
for (Edge::Kind K = FirstArmRelocation; K < LastArmRelocation; K += 1) {
|
|
EXPECT_THAT_EXPECTED(readAddend(*G, BArm, SymbolOffset, K, ArmCfg),
|
|
FailedWithMessage(testing::AllOf(
|
|
testing::StartsWith("Invalid opcode"),
|
|
testing::EndsWith(aarch32::getEdgeKindName(K)))));
|
|
}
|
|
}
|
|
|
|
TEST(AArch32_ELF, readAddendThumbErrors) {
|
|
|
|
constexpr orc::ExecutorAddr B2DummyAddr(0x2000);
|
|
|
|
// Permanently undefined instruction in Thumb
|
|
// udf #0
|
|
//
|
|
// 11110:op:imm4:1:op1:imm12
|
|
// op = 1111111 Permanent undefined
|
|
// op1 = 010
|
|
//
|
|
constexpr HalfWords ThumbHalfWords{0xf7f0, 0xa000};
|
|
ArrayRef<char> ThumbContent(reinterpret_cast<const char *>(&ThumbHalfWords),
|
|
sizeof(ThumbHalfWords));
|
|
auto &BThumb = G->createContentBlock(Sec, ThumbContent, B2DummyAddr,
|
|
ThumbAlignment, AlignmentOffset);
|
|
|
|
for (Edge::Kind K = FirstThumbRelocation; K < LastThumbRelocation; K += 1) {
|
|
EXPECT_THAT_EXPECTED(readAddend(*G, BThumb, SymbolOffset, K, ArmCfg),
|
|
FailedWithMessage(testing::AllOf(
|
|
testing::StartsWith("Invalid opcode"),
|
|
testing::EndsWith(aarch32::getEdgeKindName(K)))));
|
|
}
|
|
}
|
|
|
|
TEST_F(AArch32Errors, applyFixupDataGeneric) {
|
|
Block &OriginBlock = createMutableBlock(MutableZeros, 0x1000);
|
|
Block &TargetBlock = createBlock(Zeros, 0x2000);
|
|
|
|
constexpr uint64_t OffsetInTarget = 0;
|
|
Symbol &TargetSymbol = G->addAnonymousSymbol(TargetBlock, OffsetInTarget,
|
|
PointerSize, false, false);
|
|
|
|
constexpr uint64_t OffsetInOrigin = 0;
|
|
Edge::Kind Invalid = Edge::GenericEdgeKind::Invalid;
|
|
Edge InvalidEdge(Invalid, OffsetInOrigin, TargetSymbol, 0 /*Addend*/);
|
|
EXPECT_THAT_ERROR(
|
|
applyFixup(*G, OriginBlock, InvalidEdge, Cfg),
|
|
FailedWithMessage(testing::HasSubstr(
|
|
"encountered unfixable aarch32 edge kind INVALID RELOCATION")));
|
|
}
|
|
|
|
TEST(AArch32_ELF, applyFixupArmErrors) {
|
|
|
|
constexpr orc::ExecutorAddr B3DummyAddr(0x5000);
|
|
|
|
uint8_t ArmWord[] = {0xf0, 0x00, 0xf0, 0xe7};
|
|
MutableArrayRef<char> MutableArmContent(reinterpret_cast<char *>(ArmWord),
|
|
sizeof(ArmWord));
|
|
|
|
auto &BArm = G->createMutableContentBlock(Sec, MutableArmContent, B3DummyAddr,
|
|
ArmAlignment, AlignmentOffset);
|
|
|
|
Symbol &TargetSymbol =
|
|
G->addAnonymousSymbol(BArm, SymbolOffset, SymbolSize, false, false);
|
|
|
|
for (Edge::Kind K = FirstArmRelocation; K < LastArmRelocation; K += 1) {
|
|
Edge E(K, 0, TargetSymbol, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, BArm, E, ArmCfg),
|
|
FailedWithMessage(testing::AllOf(
|
|
testing::StartsWith("Invalid opcode"),
|
|
testing::EndsWith(aarch32::getEdgeKindName(K)))));
|
|
}
|
|
}
|
|
|
|
TEST(AArch32_ELF, applyFixupThumbErrors) {
|
|
|
|
struct MutableHalfWords {
|
|
constexpr MutableHalfWords(HalfWords Preset)
|
|
: Hi(Preset.Hi), Lo(Preset.Lo) {}
|
|
|
|
uint16_t Hi; // First halfword
|
|
uint16_t Lo; // Second halfword
|
|
};
|
|
|
|
constexpr orc::ExecutorAddr B4DummyAddr(0x6000);
|
|
|
|
// Permanently undefined instruction in Thumb
|
|
// udf #0
|
|
//
|
|
// 11110:op:imm4:1:op1:imm12
|
|
// op = 1111111 Permanent undefined
|
|
// op1 = 010
|
|
//
|
|
constexpr HalfWords ThumbHalfWords{0xf7f0, 0xa000};
|
|
MutableHalfWords MutableThumbHalfWords{ThumbHalfWords};
|
|
MutableArrayRef<char> MutableThumbContent(
|
|
reinterpret_cast<char *>(&MutableThumbHalfWords),
|
|
sizeof(MutableThumbHalfWords));
|
|
|
|
auto &BThumb = G->createMutableContentBlock(
|
|
Sec, MutableThumbContent, B4DummyAddr, ThumbAlignment, AlignmentOffset);
|
|
Symbol &TargetSymbol =
|
|
G->addAnonymousSymbol(BThumb, SymbolOffset, SymbolSize, false, false);
|
|
|
|
for (Edge::Kind K = FirstThumbRelocation; K < LastThumbRelocation; K += 1) {
|
|
Edge E(K, 0, TargetSymbol, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, BThumb, E, ArmCfg),
|
|
FailedWithMessage(testing::AllOf(
|
|
testing::StartsWith("Invalid opcode"),
|
|
testing::EndsWith(aarch32::getEdgeKindName(K)))));
|
|
}
|
|
}
|
|
|
|
TEST_F(AArch32Errors, applyFixupThumbCall) {
|
|
// Check range of R_ARM_THM_CALL relocation
|
|
constexpr uint64_t Call1Offset = 0; //< first out-of-range
|
|
constexpr uint64_t Call2Offset = 4; //< last in-range
|
|
|
|
uint8_t TwoCallsMem[8];
|
|
Block &Site = createMutableBlock(TwoCallsMem, 0);
|
|
constexpr HalfWords CallOpcode = FixupInfo<Thumb_Call>::Opcode;
|
|
write<endianness::little>(TwoCallsMem + Call1Offset, CallOpcode);
|
|
write<endianness::little>(TwoCallsMem + Call2Offset, CallOpcode);
|
|
|
|
// Thumb call with J1J2-encoding has range of 25 bit
|
|
ArmConfig ArmCfg;
|
|
ArmCfg.J1J2BranchEncoding = true;
|
|
Symbol &J1J2Target = createSymbolWithDistance(Site, 0x01ull << 24);
|
|
{
|
|
Edge LastInRange(Thumb_Call, Call2Offset, J1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, LastInRange, ArmCfg), Succeeded());
|
|
Edge FirstOutOfRange(Thumb_Call, Call1Offset, J1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, FirstOutOfRange, ArmCfg),
|
|
FailedWithMessage(testing::HasSubstr("out of range")));
|
|
}
|
|
|
|
// Thumb call without J1J2-encoding has range of 22 bit
|
|
ArmCfg.J1J2BranchEncoding = false;
|
|
Symbol &NonJ1J2Target = createSymbolWithDistance(Site, 0x01ull << 21);
|
|
{
|
|
Edge LastInRange(Thumb_Call, Call2Offset, NonJ1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, LastInRange, ArmCfg), Succeeded());
|
|
Edge FirstOutOfRange(Thumb_Call, Call1Offset, NonJ1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, FirstOutOfRange, ArmCfg),
|
|
FailedWithMessage(testing::HasSubstr("out of range")));
|
|
}
|
|
}
|
|
|
|
TEST_F(AArch32Errors, applyFixupThumbJump24) {
|
|
// Check range of R_ARM_THM_JUMP24 relocation
|
|
constexpr uint64_t Jump1Offset = 0; //< first out-of-range
|
|
constexpr uint64_t Jump2Offset = 4; //< last in-range
|
|
|
|
uint8_t TwoJumpsMem[8];
|
|
constexpr HalfWords JumpOpcode = FixupInfo<Thumb_Jump24>::Opcode;
|
|
write<endianness::little>(TwoJumpsMem + Jump1Offset, JumpOpcode);
|
|
write<endianness::little>(TwoJumpsMem + Jump2Offset, JumpOpcode);
|
|
Block &Site = createMutableBlock(TwoJumpsMem, 0);
|
|
|
|
// Thumb Jump24 with J1J2-encoding has range of 25 bit
|
|
ArmCfg.J1J2BranchEncoding = true;
|
|
Symbol &J1J2Target = createSymbolWithDistance(Site, 0x01ull << 24);
|
|
J1J2Target.setTargetFlags(TargetFlags_aarch32::ThumbSymbol);
|
|
{
|
|
Edge LastInRange(Thumb_Jump24, Jump2Offset, J1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, LastInRange, ArmCfg), Succeeded());
|
|
Edge FirstOutOfRange(Thumb_Jump24, Jump1Offset, J1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, FirstOutOfRange, ArmCfg),
|
|
FailedWithMessage(testing::HasSubstr("out of range")));
|
|
}
|
|
|
|
// Thumb Jump24 without J1J2-encoding has range of 22 bit
|
|
ArmCfg.J1J2BranchEncoding = false;
|
|
Symbol &NonJ1J2Target = createSymbolWithDistance(Site, 0x01ull << 21);
|
|
NonJ1J2Target.setTargetFlags(TargetFlags_aarch32::ThumbSymbol);
|
|
{
|
|
Edge LastInRange(Thumb_Jump24, Jump2Offset, NonJ1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, LastInRange, ArmCfg), Succeeded());
|
|
Edge FirstOutOfRange(Thumb_Jump24, Jump1Offset, NonJ1J2Target, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, FirstOutOfRange, ArmCfg),
|
|
FailedWithMessage(testing::HasSubstr("out of range")));
|
|
}
|
|
|
|
// Check that branching to an ARM target with Jump24 fails
|
|
Symbol &ArmTarget = createSymbolWithDistance(Site, 0x1000);
|
|
assert((ArmTarget.getTargetFlags() & TargetFlags_aarch32::ThumbSymbol) == 0);
|
|
Edge Interworking(Thumb_Jump24, Jump2Offset, ArmTarget, 0);
|
|
EXPECT_THAT_ERROR(applyFixup(*G, Site, Interworking, ArmCfg),
|
|
FailedWithMessage(testing::HasSubstr(
|
|
"Branch relocation needs interworking "
|
|
"stub when bridging to ARM")));
|
|
}
|