blob: f505bf73c64eb9c0b8c211d9978cbf740e4d6300 (
plain)
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
|
//===- bolt/Core/MCInstUtils.cpp ------------------------------------------===//
//
// 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 "bolt/Core/MCInstUtils.h"
#include "bolt/Core/BinaryBasicBlock.h"
#include "bolt/Core/BinaryFunction.h"
#include <type_traits>
using namespace llvm;
using namespace llvm::bolt;
// It is assumed in a few places that BinaryBasicBlock stores its instructions
// in a contiguous vector.
using BasicBlockStorageIsVector =
std::is_same<BinaryBasicBlock::const_iterator,
std::vector<MCInst>::const_iterator>;
static_assert(BasicBlockStorageIsVector::value);
MCInstReference MCInstReference::get(const MCInst &Inst,
const BinaryFunction &BF) {
if (BF.hasCFG()) {
for (BinaryBasicBlock &BB : BF) {
for (MCInst &MI : BB)
if (&MI == &Inst)
return MCInstReference(BB, Inst);
}
llvm_unreachable("Inst is not contained in BF");
}
for (auto I = BF.instrs().begin(), E = BF.instrs().end(); I != E; ++I) {
if (&I->second == &Inst)
return MCInstReference(BF, I);
}
llvm_unreachable("Inst is not contained in BF");
}
uint64_t MCInstReference::computeAddress(const MCCodeEmitter *Emitter) const {
assert(!empty() && "Taking instruction address by empty reference");
const BinaryContext &BC = getFunction()->getBinaryContext();
if (auto *Ref = tryGetRefInBB()) {
const uint64_t AddressOfBB =
getFunction()->getAddress() + Ref->BB->getOffset();
const MCInst *FirstInstInBB = &*Ref->BB->begin();
const MCInst *ThisInst = &getMCInst();
// Usage of plain 'const MCInst *' as iterators assumes the instructions
// are stored in a vector, see BasicBlockStorageIsVector.
const uint64_t OffsetInBB =
BC.computeCodeSize(FirstInstInBB, ThisInst, Emitter);
return AddressOfBB + OffsetInBB;
}
auto &Ref = getRefInBF();
const uint64_t OffsetInBF = Ref.It->first;
return getFunction()->getAddress() + OffsetInBF;
}
raw_ostream &MCInstReference::print(raw_ostream &OS) const {
if (const RefInBB *Ref = tryGetRefInBB()) {
OS << "MCInstBBRef<";
if (Ref->BB == nullptr)
OS << "BB:(null)";
else
OS << "BB:" << Ref->BB->getName() << ":" << Ref->Index;
OS << ">";
return OS;
}
const RefInBF &Ref = getRefInBF();
OS << "MCInstBFRef<";
if (Ref.BF == nullptr)
OS << "BF:(null)";
else
OS << "BF:" << Ref.BF->getPrintName() << ":" << Ref.It->first;
OS << ">";
return OS;
}
|
