mirror of
https://github.com/intel/llvm.git
synced 2026-01-13 02:38:07 +08:00
da315a3528
Refactor MCInstReference class and move it from PAuth gadget scanner to Core. MCInstReference is a class representing a reference to a constant instruction inside a parent entity - either inside a basic block (which has a reference to its parent function) or directly inside a function (when CFG information is not available). This patch reapplies #138655 with a fix for iterator usage and multiple minor issues fixed during the second round of review.
87 lines
2.7 KiB
C++
87 lines
2.7 KiB
C++
//===- 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;
|
|
}
|