llvm-6502/include/llvm/Support/InstVisitor.h

//===- 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)
      ((SubClass*)this)->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!");
             abort();
    }
  }

  //===--------------------------------------------------------------------===//
  // 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