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;
}