Add support for shifts

[oota-llvm.git] / include / llvm / Support / InstVisitor.h

diff --git a/include/llvm/Support/InstVisitor.h b/include/llvm/Support/InstVisitor.h
index ebb603b0c9c35549d93593a3f20ca70f77fd2f3c..a9b3b7150656c159648d1851d473c8b0ecd16ff1 100644 (file)
--- a/include/llvm/Support/InstVisitor.h
+++ b/include/llvm/Support/InstVisitor.h
@@ -1,4 +1,11 @@
-//===- llvm/Support/InstVisitor.h - Define instruction visitors --*- C++ -*--=//
+//===- llvm/Support/InstVisitor.h - Define instruction visitors -*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // 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
@@ -43,8 +50,10 @@
 #ifndef LLVM_SUPPORT_INSTVISITOR_H
 #define LLVM_SUPPORT_INSTVISITOR_H
 
-#include "llvm/Instruction.h"
-class Module;
+#include "llvm/Function.h"
+#include "llvm/Module.h"
+
+namespace llvm {
 
 // We operate on opaque instruction classes, so forward declare all instruction
 // types now...
@@ -56,15 +65,12 @@ class Module;
 class TerminatorInst; class BinaryOperator;
 class AllocationInst;
 
-
 #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...
@@ -77,7 +83,7 @@ struct InstVisitor {
       ((SubClass*)this)->visit(*Start++);
   }
 
-  // Define visitors for modules, functions and basic blocks...
+  // Define visitors for functions and basic blocks...
   //
   void visit(Module &M) {
     ((SubClass*)this)->visitModule(M);
@@ -140,26 +146,17 @@ struct InstVisitor {
   //
 #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 visitVarArg(VarArgInst &I)   { DELEGATE(VarArgInst);  }
-  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...
+  // 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 visitInvokeInst(InvokeInst &I)              { DELEGATE(TerminatorInst);}
+  RetTy visitUnwindInst(UnwindInst &I)              { DELEGATE(TerminatorInst);}
+  RetTy visitUnreachableInst(UnreachableInst &I)    { DELEGATE(TerminatorInst);}
   RetTy visitSetCondInst(SetCondInst &I)            { DELEGATE(BinaryOperator);}
   RetTy visitMallocInst(MallocInst &I)              { DELEGATE(AllocationInst);}
   RetTy visitAllocaInst(AllocaInst &I)              { DELEGATE(AllocationInst);}
@@ -169,11 +166,13 @@ struct InstVisitor {
   RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction); }
   RetTy visitPHINode(PHINode       &I)              { DELEGATE(Instruction); }
   RetTy visitCastInst(CastInst     &I)              { DELEGATE(Instruction); }
+  RetTy visitSelectInst(SelectInst &I)              { DELEGATE(Instruction); }
   RetTy visitCallInst(CallInst     &I)              { DELEGATE(Instruction); }
   RetTy visitShiftInst(ShiftInst   &I)              { DELEGATE(Instruction); }
-  RetTy visitVarArgInst(VarArgInst &I)              { DELEGATE(Instruction); }
+  RetTy visitVANextInst(VANextInst &I)              { DELEGATE(Instruction); }
+  RetTy visitVAArgInst(VAArgInst   &I)              { DELEGATE(Instruction); }
 
-  // Next level propogators... if the user does not overload a specific
+  // 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...
   //
@@ -192,4 +191,6 @@ struct InstVisitor {
 
 #undef DELEGATE
 
+} // End llvm namespace
+
 #endif