LLVM example for main

#include "llvm/IR/CallSite.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Module.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/Pass.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.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 MyInstVisitor {
//===--------------------------------------------------------------------===//
// 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 visitCleanupReturnInst(CleanupReturnInst &I) {
DELEGATE(TerminatorInst);
}
RetTy visitCatchReturnInst(CatchReturnInst &I) { DELEGATE(TerminatorInst); }
RetTy visitCatchSwitchInst(CatchSwitchInst &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 visitAddrSpaceCastInst(AddrSpaceCastInst &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); }
RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
RetTy visitCatchPadInst(CatchPadInst &I) { DELEGATE(FuncletPadInst); }

// 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 (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");
}
};
}

using namespace llvm;

int main(int argc, char **argv) {
if (argc < 2) {
errs() << "Expected an argument - IR file name\n";
exit(1);
}

LLVMContext Context;
SMDiagnostic Err;
std::unique_ptr<Module> pM = parseIRFile(argv[1], Err, Context);
if (nullptr == pM) {
Err.print(argv[0], errs());
return 1;
}
Module &M = *pM.get();

errs() << M << '\n';

return 0;
}

　　

g++ inst_visitor.cpp -L/usr/local/lib -g -Wall -Wextra -std=c++14 `llvm-config --cxxflags --ldflags --libs --libfiles --system-libs all` -lLLVMSupport && ./a.out a.ll