mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-18 12:29:21 +00:00
value from a visit function * Define a (file local) DELEGATE macro to make the code easier to read/maintain * Define per-opcode delegation functions so that users can override specific instances of BinaryOperator for example. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2290 91177308-0d34-0410-b5e6-96231b3b80d8
191 lines
8.1 KiB
C++
191 lines
8.1 KiB
C++
//===- llvm/Support/InstVisitor.h - Define instruction visitors --*- C++ -*--=//
|
|
//
|
|
// This template class is used to define instruction visitors in a typesafe
|
|
// manner without having to use lots of casts and a big switch statement (in
|
|
// your code that is). The win here is that if instructions are added in the
|
|
// future, they will be added to the InstVisitor<T> class, allowing you to
|
|
// automatically support them (if you handle on of their superclasses).
|
|
//
|
|
// Note that this library is specifically designed as a template to avoid
|
|
// virtual function call overhead. Defining and using an InstVisitor is just as
|
|
// efficient as having your own switch statement over the instruction opcode.
|
|
//
|
|
// InstVisitor Usage:
|
|
// You define InstVisitors from inheriting from the InstVisitor base class
|
|
// and "overriding" functions in your class. I say "overriding" because this
|
|
// class is defined in terms of statically resolved overloading, not virtual
|
|
// functions. As an example, here is a visitor that counts the number of malloc
|
|
// instructions processed:
|
|
//
|
|
// // Declare the class. Note that we derive from InstVisitor instantiated
|
|
// // with _our new subclasses_ type.
|
|
// //
|
|
// struct CountMallocVisitor : public InstVisitor<CountMallocVisitor> {
|
|
// unsigned Count;
|
|
// CountMallocVisitor() : Count(0) {}
|
|
//
|
|
// void visitMallocInst(MallocInst *MI) { ++Count; }
|
|
// };
|
|
//
|
|
// And this class would be used like this:
|
|
// CountMallocVistor CMV;
|
|
// CMV.visit(function);
|
|
// NumMallocs = CMV.Count;
|
|
//
|
|
// Returning a value from the visitation function:
|
|
// The InstVisitor class takes an optional second template argument that
|
|
// specifies what type the instruction visitation functions should return. If
|
|
// you specify this, you *MUST* provide an implementation of visitInstruction
|
|
// though!.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_INSTVISITOR_H
|
|
#define LLVM_SUPPORT_INSTVISITOR_H
|
|
|
|
#include "llvm/Instruction.h"
|
|
|
|
// We operate on opaque instruction classes, so forward declare all instruction
|
|
// types now...
|
|
//
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS;
|
|
#include "llvm/Instruction.def"
|
|
|
|
// Forward declare the intermediate types...
|
|
class TerminatorInst; class UnaryOperator; class BinaryOperator;
|
|
class AllocationInst; class MemAccessInst;
|
|
|
|
|
|
#define DELEGATE(CLASS_TO_VISIT) \
|
|
return ((SubClass*)this)->visit##CLASS_TO_VISIT((CLASS_TO_VISIT*)I)
|
|
|
|
|
|
template<typename SubClass, typename RetTy=void>
|
|
struct InstVisitor {
|
|
virtual ~InstVisitor() {} // We are meant to be derived from
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Interface code - This is the public interface of the InstVisitor that you
|
|
// use to visit instructions...
|
|
//
|
|
|
|
// Generic visit method - Allow visitation to all instructions in a range
|
|
template<class Iterator>
|
|
void visit(Iterator Start, Iterator End) {
|
|
while (Start != End)
|
|
visit(*Start++);
|
|
}
|
|
|
|
// Define visitors for modules, functions and basic blocks...
|
|
//
|
|
void visit(Module *M) {
|
|
((SubClass*)this)->visitModule(M);
|
|
visit(M->begin(), M->end());
|
|
}
|
|
void visit(Function *F) {
|
|
((SubClass*)this)->visitFunction(F);
|
|
visit(F->begin(), F->end());
|
|
}
|
|
void visit(BasicBlock *BB) {
|
|
((SubClass*)this)->visitBasicBlock(BB);
|
|
visit(BB->begin(), BB->end());
|
|
}
|
|
|
|
// visit - Finally, code to visit an instruction...
|
|
//
|
|
RetTy visit(Instruction *I) {
|
|
switch (I->getOpcode()) {
|
|
// Build the switch statement using the Instruction.def file...
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) \
|
|
case Instruction::OPCODE:return ((SubClass*)this)->visit##OPCODE((CLASS*)I);
|
|
#include "llvm/Instruction.def"
|
|
|
|
default: assert(0 && "Unknown instruction type encountered!");
|
|
}
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Visitation functions... these functions provide default fallbacks in case
|
|
// the user does not specify what to do for a particular instruction type.
|
|
// The default behavior is to generalize the instruction type to its subtype
|
|
// and try visiting the subtype. All of this should be inlined perfectly,
|
|
// because there are no virtual functions to get in the way.
|
|
//
|
|
|
|
// When visiting a module, function or basic block directly, these methods get
|
|
// called to indicate when transitioning into a new unit.
|
|
//
|
|
void visitModule (Module *M) {}
|
|
void visitFunction (Function *F) {}
|
|
void visitBasicBlock(BasicBlock *BB) {}
|
|
|
|
|
|
// Define instruction specific visitor functions that can be overridden to
|
|
// handle SPECIFIC instructions. These functions automatically define
|
|
// visitMul to proxy to visitBinaryOperator for instance in case the user does
|
|
// not need this generality.
|
|
//
|
|
// The one problem case we have to handle here though is that the PHINode
|
|
// class and opcode name are the exact same. Because of this, we cannot
|
|
// define visitPHINode (the inst version) to forward to visitPHINode (the
|
|
// generic version) without multiply defined symbols and recursion. To handle
|
|
// this, we do not autoexpand "Other" instructions, we do it manually.
|
|
//
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) \
|
|
RetTy visit##OPCODE(CLASS *I) { DELEGATE(CLASS); }
|
|
#define HANDLE_OTHER_INST(NUM, OPCODE, CLASS) // Ignore "other" instructions
|
|
#include "llvm/Instruction.def"
|
|
|
|
// Implement all "other" instructions, except for PHINode
|
|
RetTy visitCast(CastInst *I) { DELEGATE(CastInst); }
|
|
RetTy visitCall(CallInst *I) { DELEGATE(CallInst); }
|
|
RetTy visitShr(ShiftInst *I) { DELEGATE(ShiftInst); }
|
|
RetTy visitShl(ShiftInst *I) { DELEGATE(ShiftInst); }
|
|
RetTy visitUserOp1(Instruction *I) { DELEGATE(Instruction); }
|
|
RetTy visitUserOp2(Instruction *I) { DELEGATE(Instruction); }
|
|
|
|
|
|
// Specific Instruction type classes... note that all of the casts are
|
|
// neccesary because we use the instruction classes as opaque types...
|
|
//
|
|
RetTy visitReturnInst(ReturnInst *I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitBranchInst(BranchInst *I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitSwitchInst(SwitchInst *I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitInvokeInst(InvokeInst *I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitGenericUnaryInst(GenericUnaryInst *I) { DELEGATE(UnaryOperator); }
|
|
RetTy visitGenericBinaryInst(GenericBinaryInst *I){ DELEGATE(BinaryOperator);}
|
|
RetTy visitSetCondInst(SetCondInst *I) { DELEGATE(BinaryOperator);}
|
|
RetTy visitMallocInst(MallocInst *I) { DELEGATE(AllocationInst);}
|
|
RetTy visitAllocaInst(AllocaInst *I) { DELEGATE(AllocationInst);}
|
|
RetTy visitFreeInst(FreeInst *I) { DELEGATE(Instruction); }
|
|
RetTy visitLoadInst(LoadInst *I) { DELEGATE(MemAccessInst); }
|
|
RetTy visitStoreInst(StoreInst *I) { DELEGATE(MemAccessInst); }
|
|
RetTy visitGetElementPtrInst(GetElementPtrInst *I){ DELEGATE(MemAccessInst); }
|
|
RetTy visitPHINode(PHINode *I) { DELEGATE(Instruction); }
|
|
RetTy visitCastInst(CastInst *I) { DELEGATE(Instruction); }
|
|
RetTy visitCallInst(CallInst *I) { DELEGATE(Instruction); }
|
|
RetTy visitShiftInst(ShiftInst *I) { DELEGATE(Instruction); }
|
|
|
|
// Next level propogators... if the user does not overload a specific
|
|
// instruction type, they can overload one of these to get the whole class
|
|
// of instructions...
|
|
//
|
|
RetTy visitTerminatorInst(TerminatorInst *I) { DELEGATE(Instruction); }
|
|
RetTy visitUnaryOperator (UnaryOperator *I) { DELEGATE(Instruction); }
|
|
RetTy visitBinaryOperator(BinaryOperator *I) { DELEGATE(Instruction); }
|
|
RetTy visitAllocationInst(AllocationInst *I) { DELEGATE(Instruction); }
|
|
RetTy visitMemAccessInst (MemAccessInst *I) { DELEGATE(Instruction); }
|
|
|
|
// If the user wants a 'default' case, they can choose to override this
|
|
// function. If this function is not overloaded in the users subclass, then
|
|
// this instruction just gets ignored.
|
|
//
|
|
// Note that you MUST override this function if your return type is not void.
|
|
//
|
|
void visitInstruction(Instruction *I) {} // Ignore unhandled instructions
|
|
};
|
|
|
|
#undef DELEGATE
|
|
|
|
#endif
|