mirror of
https://github.com/revng/revng
synced 2026-06-21 14:07:57 +00:00
Alessandro Di Federico
b4b0b7bce9
The `FunctionCallIdentification` pass now has an API to get the fallthrough basic block of a function call basic block and to check whether a certain basic block/address is the fallthrough of a function call.
100 lines
2.8 KiB
C++
100 lines
2.8 KiB
C++
#ifndef _FUNCTIONCALLIDENTIFICATION_H
|
|
#define _FUNCTIONCALLIDENTIFICATION_H
|
|
|
|
//
|
|
// This file is distributed under the MIT License. See LICENSE.md for details.
|
|
//
|
|
|
|
// LLVM includes
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/IR/BasicBlock.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
// Local includes
|
|
#include "generatedcodebasicinfo.h"
|
|
#include "ir-helpers.h"
|
|
|
|
/// \brief Identify function call instructions
|
|
///
|
|
/// This pass parses the generated IR looking for terminator instructions which
|
|
/// look like function calls, i.e., they store the next program counter (the
|
|
/// return address) to a CSV (the link register) or in memory (the stack).
|
|
///
|
|
/// The pass also injects a call to the "funcion_call" function before
|
|
/// terminator instructions identified. The first argument represents the callee
|
|
/// basic block, the second the return basic block and the third the return
|
|
/// address.
|
|
class FunctionCallIdentification : public llvm::FunctionPass {
|
|
public:
|
|
static char ID;
|
|
|
|
public:
|
|
FunctionCallIdentification() : llvm::FunctionPass(ID) { }
|
|
|
|
void getAnalysisUsage(llvm::AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
AU.addRequired<GeneratedCodeBasicInfo>();
|
|
}
|
|
|
|
bool runOnFunction(llvm::Function &F) override;
|
|
|
|
/// \brief Return true if \p T is a function call in the input assembly
|
|
bool isCall(llvm::TerminatorInst *T) const {
|
|
assert(T != nullptr);
|
|
llvm::Instruction *Previous = getPrevious(T);
|
|
while (Previous != nullptr && isMarker(Previous)) {
|
|
auto *Call = llvm::cast<llvm::CallInst>(Previous);
|
|
if (Call->getCalledFunction() == FunctionCall)
|
|
return true;
|
|
|
|
Previous = getPrevious(Previous);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool isCall(llvm::BasicBlock *BB) const {
|
|
return isCall(BB->getTerminator());
|
|
}
|
|
|
|
llvm::BasicBlock *getFallthrough(llvm::BasicBlock *BB) const {
|
|
return getFallthrough(BB->getTerminator());
|
|
}
|
|
|
|
llvm::BasicBlock *getFallthrough(llvm::TerminatorInst *T) const {
|
|
assert(T != nullptr);
|
|
llvm::Instruction *Previous = getPrevious(T);
|
|
while (Previous != nullptr && isMarker(Previous)) {
|
|
auto *Call = llvm::cast<llvm::CallInst>(Previous);
|
|
if (Call->getCalledFunction() == FunctionCall) {
|
|
auto *Fallthrough = llvm::cast<llvm::BlockAddress>(Call->getOperand(1));
|
|
return Fallthrough->getBasicBlock();
|
|
}
|
|
|
|
Previous = getPrevious(Previous);
|
|
}
|
|
|
|
abort();
|
|
}
|
|
|
|
bool isFallthrough(uint64_t Address) const {
|
|
return FallthroughAddresses.count(Address) != 0;
|
|
}
|
|
|
|
bool isFallthrough(llvm::BasicBlock *BB) const {
|
|
return isFallthrough(getBasicBlockPC(BB));
|
|
}
|
|
|
|
bool isFallthrough(llvm::TerminatorInst *I) const {
|
|
return isFallthrough(I->getParent());
|
|
}
|
|
|
|
private:
|
|
llvm::Function *FunctionCall;
|
|
std::set<uint64_t> FallthroughAddresses;
|
|
};
|
|
|
|
#endif // _FUNCTIONCALLIDENTIFICATION_H
|