184bcf93e0fd225de2217d1b712c01586a633a6d8Chandler Carruth//===- llvm/InstVisitor.h - Instruction visitor templates -------*- C++ -*-===// 263b3afa98460ce38a1c48d3c44ef6edfdaf37b77Misha Brukman// 36fbcc26f1460eaee4e0eb8b426fc1ff0c7af11beJohn Criswell// The LLVM Compiler Infrastructure 46fbcc26f1460eaee4e0eb8b426fc1ff0c7af11beJohn Criswell// 57ed47a13356daed2a34cd2209a31f92552e3bdd8Chris Lattner// This file is distributed under the University of Illinois Open Source 67ed47a13356daed2a34cd2209a31f92552e3bdd8Chris Lattner// License. See LICENSE.TXT for details. 763b3afa98460ce38a1c48d3c44ef6edfdaf37b77Misha Brukman// 86fbcc26f1460eaee4e0eb8b426fc1ff0c7af11beJohn Criswell//===----------------------------------------------------------------------===// 9ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus 10b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 1184bcf93e0fd225de2217d1b712c01586a633a6d8Chandler Carruth#ifndef LLVM_INSTVISITOR_H 1284bcf93e0fd225de2217d1b712c01586a633a6d8Chandler Carruth#define LLVM_INSTVISITOR_H 13b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 140b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 150b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/IntrinsicInst.h" 170b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Intrinsics.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 197384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth#include "llvm/Support/CallSite.h" 20c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 21be583b914d8156b99d3da264d5adca37fee8dbc9John Criswell 22d0fde30ce850b78371fd1386338350591f9ff494Brian Gaekenamespace llvm { 23d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 24b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner// We operate on opaque instruction classes, so forward declare all instruction 25b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner// types now... 26b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner// 27b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) class CLASS; 280b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instruction.def" 29b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 300e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner#define DELEGATE(CLASS_TO_VISIT) \ 31fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner return static_cast<SubClass*>(this)-> \ 32fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner visit##CLASS_TO_VISIT(static_cast<CLASS_TO_VISIT&>(I)) 330e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner 340e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner 35ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// @brief Base class for instruction visitors 36ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 37bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson/// Instruction visitors are used when you want to perform different actions 38bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson/// for different kinds of instructions without having to use lots of casts 39bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson/// and a big switch statement (in your code, that is). 40ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 41ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// To define your own visitor, inherit from this class, specifying your 42ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// new type for the 'SubClass' template parameter, and "override" visitXXX 43bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson/// functions in your class. I say "override" because this class is defined 44fe2cce63aa26d0916fa7be32c6bf7fa8fb059ee7Misha Brukman/// in terms of statically resolved overloading, not virtual functions. 45fe2cce63aa26d0916fa7be32c6bf7fa8fb059ee7Misha Brukman/// 46fe2cce63aa26d0916fa7be32c6bf7fa8fb059ee7Misha Brukman/// For example, here is a visitor that counts the number of malloc 47ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// instructions processed: 48ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 49ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// /// Declare the class. Note that we derive from InstVisitor instantiated 50ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// /// with _our new subclasses_ type. 51ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// /// 52a276c603b82a11b0bf0b59f0517a69e4b63adeabVictor Hernandez/// struct CountAllocaVisitor : public InstVisitor<CountAllocaVisitor> { 53ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// unsigned Count; 54a276c603b82a11b0bf0b59f0517a69e4b63adeabVictor Hernandez/// CountAllocaVisitor() : Count(0) {} 55ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 56a276c603b82a11b0bf0b59f0517a69e4b63adeabVictor Hernandez/// void visitAllocaInst(AllocaInst &AI) { ++Count; } 57ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// }; 58ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 59ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// And this class would be used like this: 60a276c603b82a11b0bf0b59f0517a69e4b63adeabVictor Hernandez/// CountAllocaVisitor CAV; 61a276c603b82a11b0bf0b59f0517a69e4b63adeabVictor Hernandez/// CAV.visit(function); 62a276c603b82a11b0bf0b59f0517a69e4b63adeabVictor Hernandez/// NumAllocas = CAV.Count; 63ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 64ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// The defined has 'visit' methods for Instruction, and also for BasicBlock, 65bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson/// Function, and Module, which recursively process all contained instructions. 66ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 67ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// Note that if you don't implement visitXXX for some instruction type, 68ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// the visitXXX method for instruction superclass will be invoked. So 69ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// if instructions are added in the future, they will be automatically 70bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson/// supported, if you handle one of their superclasses. 71ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 72fe2cce63aa26d0916fa7be32c6bf7fa8fb059ee7Misha Brukman/// The optional second template argument specifies the type that instruction 73fe2cce63aa26d0916fa7be32c6bf7fa8fb059ee7Misha Brukman/// visitation functions should return. If you specify this, you *MUST* provide 74ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// an implementation of visitInstruction though!. 75ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// 76ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// Note that this class is specifically designed as a template to avoid 77ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// virtual function call overhead. Defining and using an InstVisitor is just 78ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// as efficient as having your own switch statement over the instruction 79ef27d899fd6518b7e8da1eec9f76d7beb631b3d8Vladimir Prus/// opcode. 80536fe85d6d7915915e7b8c4e6eefc2bce701505dChris Lattnertemplate<typename SubClass, typename RetTy=void> 81e26057a376f04e20da6c7217d19eaa184767cb1dReid Spencerclass InstVisitor { 82b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner //===--------------------------------------------------------------------===// 83b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // Interface code - This is the public interface of the InstVisitor that you 84b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // use to visit instructions... 85b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 86b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 87e26057a376f04e20da6c7217d19eaa184767cb1dReid Spencerpublic: 88b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // Generic visit method - Allow visitation to all instructions in a range 89b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner template<class Iterator> 90b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner void visit(Iterator Start, Iterator End) { 91b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner while (Start != End) 92fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner static_cast<SubClass*>(this)->visit(*Start++); 93b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner } 94b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 95004caf4ded406c5699eb575337b0ed865483126eChris Lattner // Define visitors for functions and basic blocks... 96b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 972dd5c96866406711cf20a6bb677a7d147ad3ac3dMisha Brukman void visit(Module &M) { 98fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner static_cast<SubClass*>(this)->visitModule(M); 992dd5c96866406711cf20a6bb677a7d147ad3ac3dMisha Brukman visit(M.begin(), M.end()); 1002dd5c96866406711cf20a6bb677a7d147ad3ac3dMisha Brukman } 1017e70829632f82de15db187845666aaca6e04b792Chris Lattner void visit(Function &F) { 102fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner static_cast<SubClass*>(this)->visitFunction(F); 1037e70829632f82de15db187845666aaca6e04b792Chris Lattner visit(F.begin(), F.end()); 1047296e93f08f7495dbe3f25e35bff0b616b438e19Chris Lattner } 1057e70829632f82de15db187845666aaca6e04b792Chris Lattner void visit(BasicBlock &BB) { 106fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner static_cast<SubClass*>(this)->visitBasicBlock(BB); 1077e70829632f82de15db187845666aaca6e04b792Chris Lattner visit(BB.begin(), BB.end()); 1087296e93f08f7495dbe3f25e35bff0b616b438e19Chris Lattner } 109b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 1107e70829632f82de15db187845666aaca6e04b792Chris Lattner // Forwarding functions so that the user can visit with pointers AND refs. 1117e70829632f82de15db187845666aaca6e04b792Chris Lattner void visit(Module *M) { visit(*M); } 1127e70829632f82de15db187845666aaca6e04b792Chris Lattner void visit(Function *F) { visit(*F); } 1137e70829632f82de15db187845666aaca6e04b792Chris Lattner void visit(BasicBlock *BB) { visit(*BB); } 1147e70829632f82de15db187845666aaca6e04b792Chris Lattner RetTy visit(Instruction *I) { return visit(*I); } 1157e70829632f82de15db187845666aaca6e04b792Chris Lattner 116b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // visit - Finally, code to visit an instruction... 117b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 1187e70829632f82de15db187845666aaca6e04b792Chris Lattner RetTy visit(Instruction &I) { 1197e70829632f82de15db187845666aaca6e04b792Chris Lattner switch (I.getOpcode()) { 120c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown instruction type encountered!"); 121b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // Build the switch statement using the Instruction.def file... 122b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 123fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner case Instruction::OPCODE: return \ 124fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner static_cast<SubClass*>(this)-> \ 125fc4addafb51fe085bc6c9b0677e685f19ec75bfcChris Lattner visit##OPCODE(static_cast<CLASS&>(I)); 1260b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instruction.def" 127b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner } 128b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner } 129b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 130b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner //===--------------------------------------------------------------------===// 131b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // Visitation functions... these functions provide default fallbacks in case 132b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // the user does not specify what to do for a particular instruction type. 133b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // The default behavior is to generalize the instruction type to its subtype 134b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // and try visiting the subtype. All of this should be inlined perfectly, 135b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // because there are no virtual functions to get in the way. 136b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 1377296e93f08f7495dbe3f25e35bff0b616b438e19Chris Lattner 1387296e93f08f7495dbe3f25e35bff0b616b438e19Chris Lattner // When visiting a module, function or basic block directly, these methods get 1397296e93f08f7495dbe3f25e35bff0b616b438e19Chris Lattner // called to indicate when transitioning into a new unit. 1407296e93f08f7495dbe3f25e35bff0b616b438e19Chris Lattner // 1412dd5c96866406711cf20a6bb677a7d147ad3ac3dMisha Brukman void visitModule (Module &M) {} 1427e70829632f82de15db187845666aaca6e04b792Chris Lattner void visitFunction (Function &F) {} 1437e70829632f82de15db187845666aaca6e04b792Chris Lattner void visitBasicBlock(BasicBlock &BB) {} 1440e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner 1450e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner // Define instruction specific visitor functions that can be overridden to 1460e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner // handle SPECIFIC instructions. These functions automatically define 1470e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner // visitMul to proxy to visitBinaryOperator for instance in case the user does 1480e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner // not need this generality. 1490e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner // 1505eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // These functions can also implement fan-out, when a single opcode and 1515eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // instruction have multiple more specific Instruction subclasses. The Call 1525eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // instruction currently supports this. We implement that by redirecting that 1535eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // instruction to a special delegation helper. 1540e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner#define HANDLE_INST(NUM, OPCODE, CLASS) \ 1555eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visit##OPCODE(CLASS &I) { \ 1565eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth if (NUM == Instruction::Call) \ 1575eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth return delegateCallInst(I); \ 1585eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth else \ 1595eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth DELEGATE(CLASS); \ 1605eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth } 1610b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instruction.def" 1620e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner 163b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // Specific Instruction type classes... note that all of the casts are 1645560c9d49ccae132cabf1155f18aa0480dce3edaMisha Brukman // necessary because we use the instruction classes as opaque types... 165b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 166a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitReturnInst(ReturnInst &I) { DELEGATE(TerminatorInst);} 167a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitBranchInst(BranchInst &I) { DELEGATE(TerminatorInst);} 168a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitSwitchInst(SwitchInst &I) { DELEGATE(TerminatorInst);} 169a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);} 170a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);} 171a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);} 172a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);} 173a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);} 174a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);} 175a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitLoadInst(LoadInst &I) { DELEGATE(UnaryInstruction);} 176a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction);} 177a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);} 178a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitAtomicRMWInst(AtomicRMWInst &I) { DELEGATE(Instruction);} 179a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitFenceInst(FenceInst &I) { DELEGATE(Instruction);} 180a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction);} 181a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction);} 182a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitTruncInst(TruncInst &I) { DELEGATE(CastInst);} 183a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitZExtInst(ZExtInst &I) { DELEGATE(CastInst);} 184a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitSExtInst(SExtInst &I) { DELEGATE(CastInst);} 185a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitFPTruncInst(FPTruncInst &I) { DELEGATE(CastInst);} 186a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitFPExtInst(FPExtInst &I) { DELEGATE(CastInst);} 187a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitFPToUIInst(FPToUIInst &I) { DELEGATE(CastInst);} 188a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitFPToSIInst(FPToSIInst &I) { DELEGATE(CastInst);} 189a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitUIToFPInst(UIToFPInst &I) { DELEGATE(CastInst);} 190a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitSIToFPInst(SIToFPInst &I) { DELEGATE(CastInst);} 191a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitPtrToIntInst(PtrToIntInst &I) { DELEGATE(CastInst);} 192a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitIntToPtrInst(IntToPtrInst &I) { DELEGATE(CastInst);} 193a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitBitCastInst(BitCastInst &I) { DELEGATE(CastInst);} 194a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitSelectInst(SelectInst &I) { DELEGATE(Instruction);} 195a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(UnaryInstruction);} 1963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);} 197a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction);} 198a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);} 199a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);} 200a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); } 201a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); } 202b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 2035eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // Handle the special instrinsic instruction classes. 2045eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgInfoIntrinsic);} 2055eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitDbgValueInst(DbgValueInst &I) { DELEGATE(DbgInfoIntrinsic);} 2065eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); } 2075eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitMemSetInst(MemSetInst &I) { DELEGATE(MemIntrinsic); } 2085eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitMemCpyInst(MemCpyInst &I) { DELEGATE(MemTransferInst); } 2095eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitMemMoveInst(MemMoveInst &I) { DELEGATE(MemTransferInst); } 2105eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitMemTransferInst(MemTransferInst &I) { DELEGATE(MemIntrinsic); } 2115eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitMemIntrinsic(MemIntrinsic &I) { DELEGATE(IntrinsicInst); } 212976f770e2d008d323b760393c998cfc912763eecEvgeniy Stepanov RetTy visitVAStartInst(VAStartInst &I) { DELEGATE(IntrinsicInst); } 213976f770e2d008d323b760393c998cfc912763eecEvgeniy Stepanov RetTy visitVAEndInst(VAEndInst &I) { DELEGATE(IntrinsicInst); } 214976f770e2d008d323b760393c998cfc912763eecEvgeniy Stepanov RetTy visitVACopyInst(VACopyInst &I) { DELEGATE(IntrinsicInst); } 2155eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy visitIntrinsicInst(IntrinsicInst &I) { DELEGATE(CallInst); } 2165eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth 2177384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth // Call and Invoke are slightly different as they delegate first through 2187384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth // a generic CallSite visitor. 2197384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth RetTy visitCallInst(CallInst &I) { 2207384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth return static_cast<SubClass*>(this)->visitCallSite(&I); 2217384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth } 2227384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth RetTy visitInvokeInst(InvokeInst &I) { 2237384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth return static_cast<SubClass*>(this)->visitCallSite(&I); 2247384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth } 2257384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth 226bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson // Next level propagators: If the user does not overload a specific 227b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // instruction type, they can overload one of these to get the whole class 228b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // of instructions... 229b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 230a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitCastInst(CastInst &I) { DELEGATE(UnaryInstruction);} 231a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction);} 232a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitCmpInst(CmpInst &I) { DELEGATE(Instruction);} 233a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction);} 234a87a75fd806cd9bd74b44f9ec1ab4b0435bb2791Chandler Carruth RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);} 235b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 2367384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth // Provide a special visitor for a 'callsite' that visits both calls and 2377384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth // invokes. When unimplemented, properly delegates to either the terminator or 2387384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth // regular instruction visitor. 2397384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth RetTy visitCallSite(CallSite CS) { 2407384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth assert(CS); 2417384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth Instruction &I = *CS.getInstruction(); 2427384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth if (CS.isCall()) 2437384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth DELEGATE(Instruction); 2447384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth 2457384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth assert(CS.isInvoke()); 2467384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth DELEGATE(TerminatorInst); 2477384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth } 2487384530c7cb1e0f747afa0a076dc7a9c13106518Chandler Carruth 249b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // If the user wants a 'default' case, they can choose to override this 250bb2ead6e5f1f901b25cf79b7a8752dce3cfd5c23Bob Wilson // function. If this function is not overloaded in the user's subclass, then 251b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // this instruction just gets ignored. 252b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner // 253536fe85d6d7915915e7b8c4e6eefc2bce701505dChris Lattner // Note that you MUST override this function if your return type is not void. 254536fe85d6d7915915e7b8c4e6eefc2bce701505dChris Lattner // 2557e70829632f82de15db187845666aaca6e04b792Chris Lattner void visitInstruction(Instruction &I) {} // Ignore unhandled instructions 2565eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth 2575eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruthprivate: 2585eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // Special helper function to delegate to CallInst subclass visitors. 2595eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy delegateCallInst(CallInst &I) { 2605eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth if (const Function *F = I.getCalledFunction()) { 2615eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth switch ((Intrinsic::ID)F->getIntrinsicID()) { 2625eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth default: DELEGATE(IntrinsicInst); 2635eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst); 2645eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth case Intrinsic::dbg_value: DELEGATE(DbgValueInst); 2655eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth case Intrinsic::memcpy: DELEGATE(MemCpyInst); 2665eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth case Intrinsic::memmove: DELEGATE(MemMoveInst); 2675eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth case Intrinsic::memset: DELEGATE(MemSetInst); 268976f770e2d008d323b760393c998cfc912763eecEvgeniy Stepanov case Intrinsic::vastart: DELEGATE(VAStartInst); 269976f770e2d008d323b760393c998cfc912763eecEvgeniy Stepanov case Intrinsic::vaend: DELEGATE(VAEndInst); 270976f770e2d008d323b760393c998cfc912763eecEvgeniy Stepanov case Intrinsic::vacopy: DELEGATE(VACopyInst); 2715eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth case Intrinsic::not_intrinsic: break; 2725eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth } 2735eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth } 2745eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth DELEGATE(CallInst); 2755eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth } 2765eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth 2775eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // An overload that will never actually be called, it is used only from dead 2785eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth // code in the dispatching from opcodes to instruction subclasses. 2795eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth RetTy delegateCallInst(Instruction &I) { 2805eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth llvm_unreachable("delegateCallInst called for non-CallInst"); 2815eb301740c4ee5d978535caa917cc004733a7fcaChandler Carruth } 282b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner}; 283b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner 2840e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner#undef DELEGATE 2850e743b83976dd9b31c8fc7ad19f61c30b743dedfChris Lattner 286d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke} // End llvm namespace 287d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 288b4c5f83eacbdb7643f9efada8fd281ef77a662c3Chris Lattner#endif 289