LCOV - code coverage report
Current view: top level - include/llvm/IR - InstVisitor.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 91 97 93.8 %
Date: 2017-09-14 15:23:50 Functions: 61 64 95.3 %
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             : /// @brief 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       82879 :   void visit(Iterator Start, Iterator End) {
      91    15005346 :     while (Start != End)
      92    37935012 :       static_cast<SubClass*>(this)->visit(*Start++);
      93       82879 :   }
      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      792678 :   void visit(Function &F) {
     102      875528 :     static_cast<SubClass*>(this)->visitFunction(F);
     103     2543705 :     visit(F.begin(), F.end());
     104      792678 :   }
     105      816616 :   void visit(BasicBlock &BB) {
     106     1484814 :     static_cast<SubClass*>(this)->visitBasicBlock(BB);
     107     3788071 :     visit(BB.begin(), BB.end());
     108      816616 :   }
     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    13212763 :   RetTy visit(Instruction *I)  { return visit(*I); }
     115             : 
     116             :   // visit - Finally, code to visit an instruction...
     117             :   //
     118    46754201 :   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    46754201 :     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           0 :   RetTy visitReturnInst(ReturnInst &I)            { DELEGATE(TerminatorInst);}
     170      236228 :   RetTy visitBranchInst(BranchInst &I)            { DELEGATE(TerminatorInst);}
     171        1147 :   RetTy visitSwitchInst(SwitchInst &I)            { DELEGATE(TerminatorInst);}
     172          14 :   RetTy visitIndirectBrInst(IndirectBrInst &I)    { DELEGATE(TerminatorInst);}
     173           0 :   RetTy visitResumeInst(ResumeInst &I)            { DELEGATE(TerminatorInst);}
     174       10345 :   RetTy visitUnreachableInst(UnreachableInst &I)  { DELEGATE(TerminatorInst);}
     175          38 :   RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(TerminatorInst);}
     176           8 :   RetTy visitCatchReturnInst(CatchReturnInst &I)  { DELEGATE(TerminatorInst); }
     177           0 :   RetTy visitCatchSwitchInst(CatchSwitchInst &I)  { DELEGATE(TerminatorInst);}
     178      306616 :   RetTy visitICmpInst(ICmpInst &I)                { DELEGATE(CmpInst);}
     179        1195 :   RetTy visitFCmpInst(FCmpInst &I)                { DELEGATE(CmpInst);}
     180     1403211 :   RetTy visitAllocaInst(AllocaInst &I)            { DELEGATE(UnaryInstruction);}
     181             :   RetTy visitLoadInst(LoadInst     &I)            { DELEGATE(UnaryInstruction);}
     182        3572 :   RetTy visitStoreInst(StoreInst   &I)            { DELEGATE(Instruction);}
     183        1230 :   RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
     184        2243 :   RetTy visitAtomicRMWInst(AtomicRMWInst &I)      { DELEGATE(Instruction);}
     185          10 :   RetTy visitFenceInst(FenceInst   &I)            { DELEGATE(Instruction);}
     186       14008 :   RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);}
     187       18268 :   RetTy visitPHINode(PHINode       &I)            { DELEGATE(Instruction);}
     188        8810 :   RetTy visitTruncInst(TruncInst &I)              { DELEGATE(CastInst);}
     189       40614 :   RetTy visitZExtInst(ZExtInst &I)                { DELEGATE(CastInst);}
     190        3699 :   RetTy visitSExtInst(SExtInst &I)                { DELEGATE(CastInst);}
     191         379 :   RetTy visitFPTruncInst(FPTruncInst &I)          { DELEGATE(CastInst);}
     192         489 :   RetTy visitFPExtInst(FPExtInst &I)              { DELEGATE(CastInst);}
     193          62 :   RetTy visitFPToUIInst(FPToUIInst &I)            { DELEGATE(CastInst);}
     194          78 :   RetTy visitFPToSIInst(FPToSIInst &I)            { DELEGATE(CastInst);}
     195         145 :   RetTy visitUIToFPInst(UIToFPInst &I)            { DELEGATE(CastInst);}
     196         207 :   RetTy visitSIToFPInst(SIToFPInst &I)            { DELEGATE(CastInst);}
     197       10120 :   RetTy visitPtrToIntInst(PtrToIntInst &I)        { DELEGATE(CastInst);}
     198        4121 :   RetTy visitIntToPtrInst(IntToPtrInst &I)        { DELEGATE(CastInst);}
     199      164948 :   RetTy visitBitCastInst(BitCastInst &I)          { DELEGATE(CastInst);}
     200         196 :   RetTy visitAddrSpaceCastInst(AddrSpaceCastInst &I) { DELEGATE(CastInst);}
     201      186894 :   RetTy visitSelectInst(SelectInst &I)            { DELEGATE(Instruction);}
     202           0 :   RetTy visitVAArgInst(VAArgInst   &I)            { DELEGATE(UnaryInstruction);}
     203        4376 :   RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
     204        9904 :   RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);}
     205        7278 :   RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}
     206           0 :   RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);}
     207           2 :   RetTy visitInsertValueInst(InsertValueInst &I)  { DELEGATE(Instruction); }
     208      175110 :   RetTy visitLandingPadInst(LandingPadInst &I)    { DELEGATE(Instruction); }
     209          63 :   RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
     210          52 :   RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
     211          16 :   RetTy visitCatchPadInst(CatchPadInst &I)     { DELEGATE(FuncletPadInst); }
     212             : 
     213             :   // Handle the special instrinsic instruction classes.
     214       22652 :   RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgInfoIntrinsic);}
     215      277184 :   RetTy visitDbgValueInst(DbgValueInst &I)        { DELEGATE(DbgInfoIntrinsic);}
     216      299796 :   RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); }
     217      401696 :   RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
     218       60117 :   RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
     219       18450 :   RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }
     220       70649 :   RetTy visitMemTransferInst(MemTransferInst &I)  { DELEGATE(MemIntrinsic); }
     221      469972 :   RetTy visitMemIntrinsic(MemIntrinsic &I)        { DELEGATE(IntrinsicInst); }
     222        2844 :   RetTy visitVAStartInst(VAStartInst &I)          { DELEGATE(IntrinsicInst); }
     223        2367 :   RetTy visitVAEndInst(VAEndInst &I)              { DELEGATE(IntrinsicInst); }
     224         118 :   RetTy visitVACopyInst(VACopyInst &I)            { DELEGATE(IntrinsicInst); }
     225     2291722 :   RetTy visitIntrinsicInst(IntrinsicInst &I)      { DELEGATE(CallInst); }
     226             : 
     227             :   // Call and Invoke are slightly different as they delegate first through
     228             :   // a generic CallSite visitor.
     229       17589 :   RetTy visitCallInst(CallInst &I) {
     230      938029 :     return static_cast<SubClass*>(this)->visitCallSite(&I);
     231             :   }
     232       25210 :   RetTy visitInvokeInst(InvokeInst &I) {
     233      199298 :     return static_cast<SubClass*>(this)->visitCallSite(&I);
     234             :   }
     235             : 
     236             :   // Next level propagators: If the user does not overload a specific
     237             :   // instruction type, they can overload one of these to get the whole class
     238             :   // of instructions...
     239             :   //
     240        4076 :   RetTy visitCastInst(CastInst &I)                { DELEGATE(UnaryInstruction);}
     241        7646 :   RetTy visitBinaryOperator(BinaryOperator &I)    { DELEGATE(Instruction);}
     242         464 :   RetTy visitCmpInst(CmpInst &I)                  { DELEGATE(Instruction);}
     243      186797 :   RetTy visitTerminatorInst(TerminatorInst &I)    { DELEGATE(Instruction);}
     244       90398 :   RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
     245             : 
     246             :   // Provide a special visitor for a 'callsite' that visits both calls and
     247             :   // invokes. When unimplemented, properly delegates to either the terminator or
     248             :   // regular instruction visitor.
     249      988176 :   RetTy visitCallSite(CallSite CS) {
     250             :     assert(CS);
     251     1030975 :     Instruction &I = *CS.getInstruction();
     252     1030975 :     if (CS.isCall())
     253      865552 :       DELEGATE(Instruction);
     254             : 
     255             :     assert(CS.isInvoke());
     256      122624 :     DELEGATE(TerminatorInst);
     257             :   }
     258             : 
     259             :   // If the user wants a 'default' case, they can choose to override this
     260             :   // function.  If this function is not overloaded in the user's subclass, then
     261             :   // this instruction just gets ignored.
     262             :   //
     263             :   // Note that you MUST override this function if your return type is not void.
     264             :   //
     265             :   void visitInstruction(Instruction &I) {}  // Ignore unhandled instructions
     266             : 
     267             : private:
     268             :   // Special helper function to delegate to CallInst subclass visitors.
     269     5314881 :   RetTy delegateCallInst(CallInst &I) {
     270     5239918 :     if (const Function *F = I.getCalledFunction()) {
     271     5239918 :       switch (F->getIntrinsicID()) {
     272     2161657 :       default:                     DELEGATE(IntrinsicInst);
     273       11351 :       case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
     274      138603 :       case Intrinsic::dbg_value:   DELEGATE(DbgValueInst);
     275       46743 :       case Intrinsic::memcpy:      DELEGATE(MemCpyInst);
     276       14674 :       case Intrinsic::memmove:     DELEGATE(MemMoveInst);
     277      354296 :       case Intrinsic::memset:      DELEGATE(MemSetInst);
     278        2213 :       case Intrinsic::vastart:     DELEGATE(VAStartInst);
     279        1764 :       case Intrinsic::vaend:       DELEGATE(VAEndInst);
     280          62 :       case Intrinsic::vacopy:      DELEGATE(VACopyInst);
     281             :       case Intrinsic::not_intrinsic: break;
     282             :       }
     283             :     }
     284     2631240 :     DELEGATE(CallInst);
     285             :   }
     286             : 
     287             :   // An overload that will never actually be called, it is used only from dead
     288             :   // code in the dispatching from opcodes to instruction subclasses.
     289             :   RetTy delegateCallInst(Instruction &I) {
     290             :     llvm_unreachable("delegateCallInst called for non-CallInst");
     291             :   }
     292             : };
     293             : 
     294             : #undef DELEGATE
     295             : 
     296             : } // End llvm namespace
     297             : 
     298             : #endif

Generated by: LCOV version 1.13