LCOV - code coverage report
Current view: top level - include/llvm/IR - InstVisitor.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 79 88 89.8 %
Date: 2018-06-17 00:07:59 Functions: 64 67 95.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- InstVisitor.h - Instruction visitor templates ------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : 
      11             : #ifndef LLVM_IR_INSTVISITOR_H
      12             : #define LLVM_IR_INSTVISITOR_H
      13             : 
      14             : #include "llvm/IR/CallSite.h"
      15             : #include "llvm/IR/Function.h"
      16             : #include "llvm/IR/Instructions.h"
      17             : #include "llvm/IR/IntrinsicInst.h"
      18             : #include "llvm/IR/Intrinsics.h"
      19             : #include "llvm/IR/Module.h"
      20             : #include "llvm/Support/ErrorHandling.h"
      21             : 
      22             : namespace llvm {
      23             : 
      24             : // We operate on opaque instruction classes, so forward declare all instruction
      25             : // types now...
      26             : //
      27             : #define HANDLE_INST(NUM, OPCODE, CLASS)   class CLASS;
      28             : #include "llvm/IR/Instruction.def"
      29             : 
      30             : #define DELEGATE(CLASS_TO_VISIT) \
      31             :   return static_cast<SubClass*>(this)-> \
      32             :                visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I))
      33             : 
      34             : 
      35             : /// Base class for instruction visitors
      36             : ///
      37             : /// Instruction visitors are used when you want to perform different actions
      38             : /// for different kinds of instructions without having to use lots of casts
      39             : /// and a big switch statement (in your code, that is).
      40             : ///
      41             : /// To define your own visitor, inherit from this class, specifying your
      42             : /// new type for the 'SubClass' template parameter, and "override" visitXXX
      43             : /// functions in your class. I say "override" because this class is defined
      44             : /// in terms of statically resolved overloading, not virtual functions.
      45             : ///
      46             : /// For example, here is a visitor that counts the number of malloc
      47             : /// instructions processed:
      48             : ///
      49             : ///  /// Declare the class.  Note that we derive from InstVisitor instantiated
      50             : ///  /// with _our new subclasses_ type.
      51             : ///  ///
      52             : ///  struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> {
      53             : ///    unsigned Count;
      54             : ///    CountAllocaVisitor() : Count(0) {}
      55             : ///
      56             : ///    void visitAllocaInst(AllocaInst &AI) { ++Count; }
      57             : ///  };
      58             : ///
      59             : ///  And this class would be used like this:
      60             : ///    CountAllocaVisitor CAV;
      61             : ///    CAV.visit(function);
      62             : ///    NumAllocas = CAV.Count;
      63             : ///
      64             : /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
      65             : /// Function, and Module, which recursively process all contained instructions.
      66             : ///
      67             : /// Note that if you don't implement visitXXX for some instruction type,
      68             : /// the visitXXX method for instruction superclass will be invoked. So
      69             : /// if instructions are added in the future, they will be automatically
      70             : /// supported, if you handle one of their superclasses.
      71             : ///
      72             : /// The optional second template argument specifies the type that instruction
      73             : /// visitation functions should return. If you specify this, you *MUST* provide
      74             : /// an implementation of visitInstruction though!.
      75             : ///
      76             : /// Note that this class is specifically designed as a template to avoid
      77             : /// virtual function call overhead.  Defining and using an InstVisitor is just
      78             : /// as efficient as having your own switch statement over the instruction
      79             : /// opcode.
      80             : template<typename SubClass, typename RetTy=void>
      81             : class InstVisitor {
      82             :   //===--------------------------------------------------------------------===//
      83             :   // Interface code - This is the public interface of the InstVisitor that you
      84             :   // use to visit instructions...
      85             :   //
      86             : 
      87             : public:
      88             :   // Generic visit method - Allow visitation to all instructions in a range
      89             :   template<class Iterator>
      90       91541 :   void visit(Iterator Start, Iterator End) {
      91    18207569 :     while (Start != End)
      92    14841057 :       static_cast<SubClass*>(this)->visit(*Start++);
      93       91541 :   }
      94             : 
      95             :   // Define visitors for functions and basic blocks...
      96             :   //
      97             :   void visit(Module &M) {
      98             :     static_cast<SubClass*>(this)->visitModule(M);
      99             :     visit(M.begin(), M.end());
     100             :   }
     101     1045237 :   void visit(Function &F) {
     102     1045237 :     static_cast<SubClass*>(this)->visitFunction(F);
     103       91541 :     visit(F.begin(), F.end());
     104     1045237 :   }
     105     1126984 :   void visit(BasicBlock &BB) {
     106     1126984 :     static_cast<SubClass*>(this)->visitBasicBlock(BB);
     107             :     visit(BB.begin(), BB.end());
     108     1126984 :   }
     109             : 
     110             :   // Forwarding functions so that the user can visit with pointers AND refs.
     111             :   void visit(Module       *M)  { visit(*M); }
     112             :   void visit(Function     *F)  { visit(*F); }
     113             :   void visit(BasicBlock   *BB) { visit(*BB); }
     114    13934182 :   RetTy visit(Instruction *I)  { return visit(*I); }
     115             : 
     116             :   // visit - Finally, code to visit an instruction...
     117             :   //
     118    51033211 :   RetTy visit(Instruction &I) {
     119             :     static_assert(std::is_base_of<InstVisitor, SubClass>::value,
     120             :                   "Must pass the derived type to this template!");
     121             : 
     122    46349148 :     switch (I.getOpcode()) {
     123           0 :     default: llvm_unreachable("Unknown instruction type encountered!");
     124             :       // Build the switch statement using the Instruction.def file...
     125             : #define HANDLE_INST(NUM, OPCODE, CLASS) \
     126             :     case Instruction::OPCODE: return \
     127             :            static_cast<SubClass*>(this)-> \
     128             :                       visit##OPCODE(static_cast<CLASS&>(I));
     129             : #include "llvm/IR/Instruction.def"
     130             :     }
     131             :   }
     132             : 
     133             :   //===--------------------------------------------------------------------===//
     134             :   // Visitation functions... these functions provide default fallbacks in case
     135             :   // the user does not specify what to do for a particular instruction type.
     136             :   // The default behavior is to generalize the instruction type to its subtype
     137             :   // and try visiting the subtype.  All of this should be inlined perfectly,
     138             :   // because there are no virtual functions to get in the way.
     139             :   //
     140             : 
     141             :   // When visiting a module, function or basic block directly, these methods get
     142             :   // called to indicate when transitioning into a new unit.
     143             :   //
     144             :   void visitModule    (Module &M) {}
     145             :   void visitFunction  (Function &F) {}
     146             :   void visitBasicBlock(BasicBlock &BB) {}
     147             : 
     148             :   // Define instruction specific visitor functions that can be overridden to
     149             :   // handle SPECIFIC instructions.  These functions automatically define
     150             :   // visitMul to proxy to visitBinaryOperator for instance in case the user does
     151             :   // not need this generality.
     152             :   //
     153             :   // These functions can also implement fan-out, when a single opcode and
     154             :   // instruction have multiple more specific Instruction subclasses. The Call
     155             :   // instruction currently supports this. We implement that by redirecting that
     156             :   // instruction to a special delegation helper.
     157             : #define HANDLE_INST(NUM, OPCODE, CLASS) \
     158             :     RetTy visit##OPCODE(CLASS &I) { \
     159             :       if (NUM == Instruction::Call) \
     160             :         return delegateCallInst(I); \
     161             :       else \
     162             :         DELEGATE(CLASS); \
     163             :     }
     164             : #include "llvm/IR/Instruction.def"
     165             : 
     166             :   // Specific Instruction type classes... note that all of the casts are
     167             :   // necessary because we use the instruction classes as opaque types...
     168             :   //
     169             :   RetTy visitReturnInst(ReturnInst &I)            { DELEGATE(TerminatorInst);}
     170      241139 :   RetTy visitBranchInst(BranchInst &I)            { DELEGATE(TerminatorInst);}
     171        1225 :   RetTy visitSwitchInst(SwitchInst &I)            { DELEGATE(TerminatorInst);}
     172          14 :   RetTy visitIndirectBrInst(IndirectBrInst &I)    { DELEGATE(TerminatorInst);}
     173             :   RetTy visitResumeInst(ResumeInst &I)            { DELEGATE(TerminatorInst);}
     174       11982 :   RetTy visitUnreachableInst(UnreachableInst &I)  { DELEGATE(TerminatorInst);}
     175          34 :   RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(TerminatorInst);}
     176           8 :   RetTy visitCatchReturnInst(CatchReturnInst &I)  { DELEGATE(TerminatorInst); }
     177             :   RetTy visitCatchSwitchInst(CatchSwitchInst &I)  { DELEGATE(TerminatorInst);}
     178      334046 :   RetTy visitICmpInst(ICmpInst &I)                { DELEGATE(CmpInst);}
     179        1319 :   RetTy visitFCmpInst(FCmpInst &I)                { DELEGATE(CmpInst);}
     180     1335075 :   RetTy visitAllocaInst(AllocaInst &I)            { DELEGATE(UnaryInstruction);}
     181             :   RetTy visitLoadInst(LoadInst     &I)            { DELEGATE(UnaryInstruction);}
     182        1918 :   RetTy visitStoreInst(StoreInst   &I)            { DELEGATE(Instruction);}
     183         470 :   RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
     184         507 :   RetTy visitAtomicRMWInst(AtomicRMWInst &I)      { DELEGATE(Instruction);}
     185          10 :   RetTy visitFenceInst(FenceInst   &I)            { DELEGATE(Instruction);}
     186        7060 :   RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);}
     187        9167 :   RetTy visitPHINode(PHINode       &I)            { DELEGATE(Instruction);}
     188        9659 :   RetTy visitTruncInst(TruncInst &I)              { DELEGATE(CastInst);}
     189       40423 :   RetTy visitZExtInst(ZExtInst &I)                { DELEGATE(CastInst);}
     190        3409 :   RetTy visitSExtInst(SExtInst &I)                { DELEGATE(CastInst);}
     191         383 :   RetTy visitFPTruncInst(FPTruncInst &I)          { DELEGATE(CastInst);}
     192         491 :   RetTy visitFPExtInst(FPExtInst &I)              { DELEGATE(CastInst);}
     193          62 :   RetTy visitFPToUIInst(FPToUIInst &I)            { DELEGATE(CastInst);}
     194          74 :   RetTy visitFPToSIInst(FPToSIInst &I)            { DELEGATE(CastInst);}
     195         118 :   RetTy visitUIToFPInst(UIToFPInst &I)            { DELEGATE(CastInst);}
     196         189 :   RetTy visitSIToFPInst(SIToFPInst &I)            { DELEGATE(CastInst);}
     197       10639 :   RetTy visitPtrToIntInst(PtrToIntInst &I)        { DELEGATE(CastInst);}
     198        4272 :   RetTy visitIntToPtrInst(IntToPtrInst &I)        { DELEGATE(CastInst);}
     199      172638 :   RetTy visitBitCastInst(BitCastInst &I)          { DELEGATE(CastInst);}
     200         148 :   RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I) { DELEGATE(CastInst);}
     201      193376 :   RetTy visitSelectInst(SelectInst &I)            { DELEGATE(Instruction);}
     202           0 :   RetTy visitVAArgInst(VAArgInst   &I)            { DELEGATE(UnaryInstruction);}
     203           8 :   RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
     204           0 :   RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
     205           0 :   RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
     206             :   RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
     207           1 :   RetTy visitInsertValueInst(InsertValueInst &I)  { DELEGATE(Instruction); }
     208       99424 :   RetTy visitLandingPadInst(LandingPadInst &I)    { DELEGATE(Instruction); }
     209           6 :   RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
     210           0 :   RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
     211           0 :   RetTy visitCatchPadInst(CatchPadInst &I)     { DELEGATE(FuncletPadInst); }
     212             : 
     213             :   // Handle the special instrinsic instruction classes.
     214             :   RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgInfoIntrinsic);}
     215             :   RetTy visitDbgValueInst(DbgValueInst &I)        { DELEGATE(DbgInfoIntrinsic);}
     216             :   RetTy visitDbgLabelInst(DbgLabelInst &I)        { DELEGATE(DbgInfoIntrinsic);}
     217          43 :   RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); }
     218         883 :   RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
     219        6602 :   RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
     220          20 :   RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }
     221         973 :   RetTy visitMemTransferInst(MemTransferInst &I)  { DELEGATE(MemIntrinsic); }
     222          92 :   RetTy visitMemIntrinsic(MemIntrinsic &I)        { DELEGATE(IntrinsicInst); }
     223          32 :   RetTy visitVAStartInst(VAStartInst &I)          { DELEGATE(IntrinsicInst); }
     224           5 :   RetTy visitVAEndInst(VAEndInst &I)              { DELEGATE(IntrinsicInst); }
     225           0 :   RetTy visitVACopyInst(VACopyInst &I)            { DELEGATE(IntrinsicInst); }
     226     1769092 :   RetTy visitIntrinsicInst(IntrinsicInst &I)      { DELEGATE(CallInst); }
     227             : 
     228             :   // Call and Invoke are slightly different as they delegate first through
     229             :   // a generic CallSite visitor.
     230       18865 :   RetTy visitCallInst(CallInst &I) {
     231      964656 :     return static_cast<SubClass*>(this)->visitCallSite(&I);
     232             :   }
     233       26558 :   RetTy visitInvokeInst(InvokeInst &I) {
     234      160897 :     return static_cast<SubClass*>(this)->visitCallSite(&I);
     235             :   }
     236             : 
     237             :   // Next level propagators: If the user does not overload a specific
     238             :   // instruction type, they can overload one of these to get the whole class
     239             :   // of instructions...
     240             :   //
     241             :   RetTy visitCastInst(CastInst &I)                { DELEGATE(UnaryInstruction);}
     242           0 :   RetTy visitBinaryOperator(BinaryOperator &I)    { DELEGATE(Instruction);}
     243         263 :   RetTy visitCmpInst(CmpInst &I)                  { DELEGATE(Instruction);}
     244      165334 :   RetTy visitTerminatorInst(TerminatorInst &I)    { DELEGATE(Instruction);}
     245        2029 :   RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
     246             : 
     247             :   // Provide a special visitor for a 'callsite' that visits both calls and
     248             :   // invokes. When unimplemented, properly delegates to either the terminator or
     249             :   // regular instruction visitor.
     250     1054774 :   RetTy visitCallSite(CallSite CS) {
     251             :     assert(CS);
     252             :     Instruction &I = *CS.getInstruction();
     253     1100197 :     if (CS.isCall())
     254      922940 :       DELEGATE(Instruction);
     255             : 
     256             :     assert(CS.isInvoke());
     257      131834 :     DELEGATE(TerminatorInst);
     258             :   }
     259             : 
     260             :   // If the user wants a 'default' case, they can choose to override this
     261             :   // function.  If this function is not overloaded in the user's subclass, then
     262             :   // this instruction just gets ignored.
     263             :   //
     264             :   // Note that you MUST override this function if your return type is not void.
     265             :   //
     266             :   void visitInstruction(Instruction &I) {}  // Ignore unhandled instructions
     267             : 
     268             : private:
     269             :   // Special helper function to delegate to CallInst subclass visitors.
     270     5278276 :   RetTy delegateCallInst(CallInst &I) {
     271             :     if (const Function *F = I.getCalledFunction()) {
     272     5174691 :       switch (F->getIntrinsicID()) {
     273      963188 :       default:                     DELEGATE(IntrinsicInst);
     274          25 :       case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
     275          17 :       case Intrinsic::dbg_value:   DELEGATE(DbgValueInst);
     276           0 :       case Intrinsic::dbg_label:   DELEGATE(DbgLabelInst);
     277       15561 :       case Intrinsic::memcpy:      DELEGATE(MemCpyInst);
     278        4104 :       case Intrinsic::memmove:     DELEGATE(MemMoveInst);
     279      171211 :       case Intrinsic::memset:      DELEGATE(MemSetInst);
     280         711 :       case Intrinsic::vastart:     DELEGATE(VAStartInst);
     281         205 :       case Intrinsic::vaend:       DELEGATE(VAEndInst);
     282           1 :       case Intrinsic::vacopy:      DELEGATE(VACopyInst);
     283             :       case Intrinsic::not_intrinsic: break;
     284             :       }
     285             :     }
     286     2518004 :     DELEGATE(CallInst);
     287             :   }
     288             : 
     289             :   // An overload that will never actually be called, it is used only from dead
     290             :   // code in the dispatching from opcodes to instruction subclasses.
     291             :   RetTy delegateCallInst(Instruction &I) {
     292             :     llvm_unreachable("delegateCallInst called for non-CallInst");
     293             :   }
     294             : };
     295             : 
     296             : #undef DELEGATE
     297             : 
     298             : } // End llvm namespace
     299             : 
     300             : #endif

Generated by: LCOV version 1.13