mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-12 13:30:51 +00:00
0b8c9a80f2
into their new header subdirectory: include/llvm/IR. This matches the directory structure of lib, and begins to correct a long standing point of file layout clutter in LLVM. There are still more header files to move here, but I wanted to handle them in separate commits to make tracking what files make sense at each layer easier. The only really questionable files here are the target intrinsic tablegen files. But that's a battle I'd rather not fight today. I've updated both CMake and Makefile build systems (I think, and my tests think, but I may have missed something). I've also re-sorted the includes throughout the project. I'll be committing updates to Clang, DragonEgg, and Polly momentarily. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171366 91177308-0d34-0410-b5e6-96231b3b80d8
289 lines
13 KiB
C++
289 lines
13 KiB
C++
//===- llvm/InstVisitor.h - Instruction visitor templates -------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#ifndef LLVM_INSTVISITOR_H
|
|
#define LLVM_INSTVISITOR_H
|
|
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/IR/Intrinsics.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/CallSite.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
namespace llvm {
|
|
|
|
// We operate on opaque instruction classes, so forward declare all instruction
|
|
// types now...
|
|
//
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS;
|
|
#include "llvm/IR/Instruction.def"
|
|
|
|
#define DELEGATE(CLASS_TO_VISIT) \
|
|
return static_cast<SubClass*>(this)-> \
|
|
visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
|
|
|
|
|
|
/// @brief Base class for instruction visitors
|
|
///
|
|
/// Instruction visitors are used when you want to perform different actions
|
|
/// for different kinds of instructions without having to use lots of casts
|
|
/// and a big switch statement (in your code, that is).
|
|
///
|
|
/// To define your own visitor, inherit from this class, specifying your
|
|
/// new type for the 'SubClass' template parameter, and "override" visitXXX
|
|
/// functions in your class. I say "override" because this class is defined
|
|
/// in terms of statically resolved overloading, not virtual functions.
|
|
///
|
|
/// For 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 CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
|
|
/// unsigned Count;
|
|
/// CountAllocaVisitor() : Count(0) {}
|
|
///
|
|
/// void visitAllocaInst(AllocaInst &AI) { ++Count; }
|
|
/// };
|
|
///
|
|
/// And this class would be used like this:
|
|
/// CountAllocaVisitor CAV;
|
|
/// CAV.visit(function);
|
|
/// NumAllocas = CAV.Count;
|
|
///
|
|
/// The defined has 'visit' methods for Instruction, and also for BasicBlock,
|
|
/// Function, and Module, which recursively process all contained instructions.
|
|
///
|
|
/// Note that if you don't implement visitXXX for some instruction type,
|
|
/// the visitXXX method for instruction superclass will be invoked. So
|
|
/// if instructions are added in the future, they will be automatically
|
|
/// supported, if you handle one of their superclasses.
|
|
///
|
|
/// The optional second template argument specifies the type that instruction
|
|
/// visitation functions should return. If you specify this, you *MUST* provide
|
|
/// an implementation of visitInstruction though!.
|
|
///
|
|
/// Note that this class 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.
|
|
template<typename SubClass, typename RetTy=void>
|
|
class InstVisitor {
|
|
//===--------------------------------------------------------------------===//
|
|
// Interface code - This is the public interface of the InstVisitor that you
|
|
// use to visit instructions...
|
|
//
|
|
|
|
public:
|
|
// Generic visit method - Allow visitation to all instructions in a range
|
|
template<class Iterator>
|
|
void visit(Iterator Start, Iterator End) {
|
|
while (Start != End)
|
|
static_cast<SubClass*>(this)->visit(*Start++);
|
|
}
|
|
|
|
// Define visitors for functions and basic blocks...
|
|
//
|
|
void visit(Module &M) {
|
|
static_cast<SubClass*>(this)->visitModule(M);
|
|
visit(M.begin(), M.end());
|
|
}
|
|
void visit(Function &F) {
|
|
static_cast<SubClass*>(this)->visitFunction(F);
|
|
visit(F.begin(), F.end());
|
|
}
|
|
void visit(BasicBlock &BB) {
|
|
static_cast<SubClass*>(this)->visitBasicBlock(BB);
|
|
visit(BB.begin(), BB.end());
|
|
}
|
|
|
|
// Forwarding functions so that the user can visit with pointers AND refs.
|
|
void visit(Module *M) { visit(*M); }
|
|
void visit(Function *F) { visit(*F); }
|
|
void visit(BasicBlock *BB) { visit(*BB); }
|
|
RetTy visit(Instruction *I) { return visit(*I); }
|
|
|
|
// visit - Finally, code to visit an instruction...
|
|
//
|
|
RetTy visit(Instruction &I) {
|
|
switch (I.getOpcode()) {
|
|
default: llvm_unreachable("Unknown instruction type encountered!");
|
|
// Build the switch statement using the Instruction.def file...
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) \
|
|
case Instruction::OPCODE: return \
|
|
static_cast<SubClass*>(this)-> \
|
|
visit##OPCODE(static_cast<CLASS&>(I));
|
|
#include "llvm/IR/Instruction.def"
|
|
}
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// 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.
|
|
//
|
|
// These functions can also implement fan-out, when a single opcode and
|
|
// instruction have multiple more specific Instruction subclasses. The Call
|
|
// instruction currently supports this. We implement that by redirecting that
|
|
// instruction to a special delegation helper.
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) \
|
|
RetTy visit##OPCODE(CLASS &I) { \
|
|
if (NUM == Instruction::Call) \
|
|
return delegateCallInst(I); \
|
|
else \
|
|
DELEGATE(CLASS); \
|
|
}
|
|
#include "llvm/IR/Instruction.def"
|
|
|
|
// Specific Instruction type classes... note that all of the casts are
|
|
// necessary 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 visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);}
|
|
RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);}
|
|
RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);}
|
|
RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);}
|
|
RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);}
|
|
RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);}
|
|
RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);}
|
|
RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);}
|
|
RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);}
|
|
RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
|
|
RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); }
|
|
RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); }
|
|
|
|
// Handle the special instrinsic instruction classes.
|
|
RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgInfoIntrinsic);}
|
|
RetTy visitDbgValueInst(DbgValueInst &I) { DELEGATE(DbgInfoIntrinsic);}
|
|
RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); }
|
|
RetTy visitMemSetInst(MemSetInst &I) { DELEGATE(MemIntrinsic); }
|
|
RetTy visitMemCpyInst(MemCpyInst &I) { DELEGATE(MemTransferInst); }
|
|
RetTy visitMemMoveInst(MemMoveInst &I) { DELEGATE(MemTransferInst); }
|
|
RetTy visitMemTransferInst(MemTransferInst &I) { DELEGATE(MemIntrinsic); }
|
|
RetTy visitMemIntrinsic(MemIntrinsic &I) { DELEGATE(IntrinsicInst); }
|
|
RetTy visitVAStartInst(VAStartInst &I) { DELEGATE(IntrinsicInst); }
|
|
RetTy visitVAEndInst(VAEndInst &I) { DELEGATE(IntrinsicInst); }
|
|
RetTy visitVACopyInst(VACopyInst &I) { DELEGATE(IntrinsicInst); }
|
|
RetTy visitIntrinsicInst(IntrinsicInst &I) { DELEGATE(CallInst); }
|
|
|
|
// Call and Invoke are slightly different as they delegate first through
|
|
// a generic CallSite visitor.
|
|
RetTy visitCallInst(CallInst &I) {
|
|
return static_cast<SubClass*>(this)->visitCallSite(&I);
|
|
}
|
|
RetTy visitInvokeInst(InvokeInst &I) {
|
|
return static_cast<SubClass*>(this)->visitCallSite(&I);
|
|
}
|
|
|
|
// Next level propagators: If the user does not overload a specific
|
|
// instruction type, they can overload one of these to get the whole class
|
|
// of instructions...
|
|
//
|
|
RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);}
|
|
RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);}
|
|
RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction);}
|
|
RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
|
|
|
|
// Provide a special visitor for a 'callsite' that visits both calls and
|
|
// invokes. When unimplemented, properly delegates to either the terminator or
|
|
// regular instruction visitor.
|
|
RetTy visitCallSite(CallSite CS) {
|
|
assert(CS);
|
|
Instruction &I = *CS.getInstruction();
|
|
if (CS.isCall())
|
|
DELEGATE(Instruction);
|
|
|
|
assert(CS.isInvoke());
|
|
DELEGATE(TerminatorInst);
|
|
}
|
|
|
|
// If the user wants a 'default' case, they can choose to override this
|
|
// function. If this function is not overloaded in the user's 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
|
|
|
|
private:
|
|
// Special helper function to delegate to CallInst subclass visitors.
|
|
RetTy delegateCallInst(CallInst &I) {
|
|
if (const Function *F = I.getCalledFunction()) {
|
|
switch ((Intrinsic::ID)F->getIntrinsicID()) {
|
|
default: DELEGATE(IntrinsicInst);
|
|
case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
|
|
case Intrinsic::dbg_value: DELEGATE(DbgValueInst);
|
|
case Intrinsic::memcpy: DELEGATE(MemCpyInst);
|
|
case Intrinsic::memmove: DELEGATE(MemMoveInst);
|
|
case Intrinsic::memset: DELEGATE(MemSetInst);
|
|
case Intrinsic::vastart: DELEGATE(VAStartInst);
|
|
case Intrinsic::vaend: DELEGATE(VAEndInst);
|
|
case Intrinsic::vacopy: DELEGATE(VACopyInst);
|
|
case Intrinsic::not_intrinsic: break;
|
|
}
|
|
}
|
|
DELEGATE(CallInst);
|
|
}
|
|
|
|
// An overload that will never actually be called, it is used only from dead
|
|
// code in the dispatching from opcodes to instruction subclasses.
|
|
RetTy delegateCallInst(Instruction &I) {
|
|
llvm_unreachable("delegateCallInst called for non-CallInst");
|
|
}
|
|
};
|
|
|
|
#undef DELEGATE
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|