1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
//===----------- BPFPreserveDIType.cpp - Preserve DebugInfo Types ---------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Preserve Debuginfo types encoded in __builtin_btf_type_id() metadata.
//
//===----------------------------------------------------------------------===//
#include "BPF.h"
#include "BPFCORE.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
#include "llvm/Pass.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#define DEBUG_TYPE "bpf-preserve-di-type"
namespace llvm {
constexpr StringRef BPFCoreSharedInfo::TypeIdAttr;
} // namespace llvm
using namespace llvm;
namespace {
class BPFPreserveDIType final : public ModulePass {
StringRef getPassName() const override {
return "BPF Preserve DebugInfo Type";
}
bool runOnModule(Module &M) override;
public:
static char ID;
BPFPreserveDIType() : ModulePass(ID) {}
private:
bool doTransformation(Module &M);
};
} // End anonymous namespace
char BPFPreserveDIType::ID = 0;
INITIALIZE_PASS(BPFPreserveDIType, DEBUG_TYPE, "preserve debuginfo type", false,
false)
ModulePass *llvm::createBPFPreserveDIType() { return new BPFPreserveDIType(); }
bool BPFPreserveDIType::runOnModule(Module &M) {
LLVM_DEBUG(dbgs() << "********** preserve debuginfo type **********\n");
// Bail out if no debug info.
if (M.debug_compile_units().empty())
return false;
return doTransformation(M);
}
bool BPFPreserveDIType::doTransformation(Module &M) {
std::vector<CallInst *> PreserveDITypeCalls;
for (auto &F : M) {
for (auto &BB : F) {
for (auto &I : BB) {
auto *Call = dyn_cast<CallInst>(&I);
if (!Call)
continue;
const auto *GV = dyn_cast<GlobalValue>(Call->getCalledOperand());
if (!GV)
continue;
if (GV->getName().startswith("llvm.bpf.btf.type.id")) {
if (!Call->getMetadata(LLVMContext::MD_preserve_access_index))
report_fatal_error(
"Missing metadata for llvm.bpf.btf.type.id intrinsic");
PreserveDITypeCalls.push_back(Call);
}
}
}
}
if (PreserveDITypeCalls.empty())
return false;
std::string BaseName = "llvm.btf_type_id.";
int Count = 0;
for (auto Call : PreserveDITypeCalls) {
const ConstantInt *Flag = dyn_cast<ConstantInt>(Call->getArgOperand(2));
assert(Flag);
uint64_t FlagValue = Flag->getValue().getZExtValue();
if (FlagValue >= BPFCoreSharedInfo::MAX_BTF_TYPE_ID_FLAG)
report_fatal_error("Incorrect flag for llvm.bpf.btf.type.id intrinsic");
uint32_t Reloc;
if (FlagValue == BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL_RELOC)
Reloc = BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL;
else
Reloc = BPFCoreSharedInfo::BTF_TYPE_ID_REMOTE;
BasicBlock *BB = Call->getParent();
IntegerType *VarType = Type::getInt32Ty(BB->getContext());
std::string GVName = BaseName + std::to_string(Count) + "$" +
std::to_string(Reloc);
GlobalVariable *GV =
new GlobalVariable(M, VarType, false, GlobalVariable::ExternalLinkage,
NULL, GVName);
GV->addAttribute(BPFCoreSharedInfo::TypeIdAttr);
MDNode *MD = Call->getMetadata(LLVMContext::MD_preserve_access_index);
GV->setMetadata(LLVMContext::MD_preserve_access_index, MD);
// Load the global variable which represents the type info.
auto *LDInst = new LoadInst(Type::getInt32Ty(BB->getContext()), GV, "",
Call);
Call->replaceAllUsesWith(LDInst);
Call->eraseFromParent();
Count++;
}
return true;
}
|
