Add a file header

[oota-llvm.git] / include / llvm / iOther.h

diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h
index 3e3bfc4bfd3da908c47553a574c8ebdb60ad78a0..45b8db367d8e27bfd9d165e4c099cf88d8ceb308 100644 (file)
--- a/include/llvm/iOther.h
+++ b/include/llvm/iOther.h
@@ -1,7 +1,7 @@
 //===-- llvm/iOther.h - "Other" instruction node definitions -----*- C++ -*--=//
 //
 // This file contains the declarations for instructions that fall into the 
-// grandios 'other' catagory...
+// grandiose 'other' catagory...
 //
 //===----------------------------------------------------------------------===//
 
@@ -9,29 +9,28 @@
 #define LLVM_IOTHER_H
 
 #include "llvm/InstrTypes.h"
-#include "llvm/Function.h"
 
 //===----------------------------------------------------------------------===//
 //                                 CastInst Class
 //===----------------------------------------------------------------------===//
 
-// CastInst - This class represents a cast from Operand[0] to the type of
-// the instruction (i->getType()).
-//
+/// CastInst - This class represents a cast from Operand[0] to the type of
+/// the instruction (i->getType()).
+///
 class CastInst : public Instruction {
   CastInst(const CastInst &CI) : Instruction(CI.getType(), Cast) {
     Operands.reserve(1);
     Operands.push_back(Use(CI.Operands[0], this));
   }
 public:
-  CastInst(Value *S, const Type *Ty, const std::string &Name = "")
-    : Instruction(Ty, Cast, Name) {
+  CastInst(Value *S, const Type *Ty, const std::string &Name = "",
+           Instruction *InsertBefore = 0)
+    : Instruction(Ty, Cast, Name, InsertBefore) {
     Operands.reserve(1);
     Operands.push_back(Use(S, this));
   }
 
   virtual Instruction *clone() const { return new CastInst(*this); }
-  virtual const char *getOpcodeName() const { return "cast"; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const CastInst *) { return true; }
@@ -45,56 +44,29 @@ public:
 
 
 //===----------------------------------------------------------------------===//
-//                           FunctionArgument Class
-//===----------------------------------------------------------------------===//
-
-class FunctionArgument : public Value {  // Defined in the InstrType.cpp file
-  Function *Parent;
-
-  friend class ValueHolder<FunctionArgument,Function,Function>;
-  inline void setParent(Function *parent) { Parent = parent; }
-
-public:
-  FunctionArgument(const Type *Ty, const std::string &Name = "") 
-    : Value(Ty, Value::FunctionArgumentVal, Name) {
-    Parent = 0;
-  }
-
-  // Specialize setName to handle symbol table majik...
-  virtual void setName(const std::string &name, SymbolTable *ST = 0);
-
-  inline const Function *getParent() const { return Parent; }
-  inline       Function *getParent()       { return Parent; }
-
-  virtual void print(std::ostream &OS) const;
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const FunctionArgument *) { return true; }
-  static inline bool classof(const Value *V) {
-    return V->getValueType() == FunctionArgumentVal;
-  }
-};
-
-
-//===----------------------------------------------------------------------===//
-//             Classes to function calls and method invocations
+//                                 CallInst Class
 //===----------------------------------------------------------------------===//
 
 class CallInst : public Instruction {
   CallInst(const CallInst &CI);
 public:
-  CallInst(Value *M, const std::vector<Value*> &Par, const std::string & = "");
+  CallInst(Value *F, const std::vector<Value*> &Par,
+           const std::string &Name = "", Instruction *InsertBefore = 0);
 
-  virtual const char *getOpcodeName() const { return "call"; }
+  // Alternate CallInst ctors w/ no actuals & one actual, respectively.
+  CallInst(Value *F, const std::string &Name = "",
+           Instruction  *InsertBefore = 0);
+  CallInst(Value *F, Value *Actual, const std::string& Name = "",
+           Instruction* InsertBefore = 0);
 
   virtual Instruction *clone() const { return new CallInst(*this); }
-  bool hasSideEffects() const { return true; }
+  bool mayWriteToMemory() const { return true; }
 
   const Function *getCalledFunction() const {
-    return dyn_cast<Function>(Operands[0]);
+    return dyn_cast<Function>(Operands[0].get());
   }
   Function *getCalledFunction() {
-    return dyn_cast<Function>(Operands[0]);
+    return dyn_cast<Function>(Operands[0].get());
   }
 
   // getCalledValue - Get a pointer to a method that is invoked by this inst.
@@ -125,8 +97,9 @@ class ShiftInst : public Instruction {
     Operands.push_back(Use(SI.Operands[1], this));
   }
 public:
-  ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "")
-    : Instruction(S->getType(), Opcode, Name) {
+  ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "",
+            Instruction *InsertBefore = 0)
+    : Instruction(S->getType(), Opcode, Name, InsertBefore) {
     assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!");
     Operands.reserve(2);
     Operands.push_back(Use(S, this));
@@ -136,9 +109,6 @@ public:
   OtherOps getOpcode() const { return (OtherOps)Instruction::getOpcode(); }
 
   virtual Instruction *clone() const { return new ShiftInst(*this); }
-  virtual const char *getOpcodeName() const {
-    return getOpcode() == Shl ? "shl" : "shr"; 
-  }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ShiftInst *) { return true; }
@@ -151,4 +121,40 @@ public:
   }
 };
 
+
+//===----------------------------------------------------------------------===//
+//                               VarArgInst Class
+//===----------------------------------------------------------------------===//
+
+/// VarArgInst - This class represents the va_arg llvm instruction, which reads
+/// an argument of the destination type from the va_list operand pointed to by
+/// the only operand.
+///
+class VarArgInst : public Instruction {
+  VarArgInst(const VarArgInst &VAI) : Instruction(VAI.getType(), VarArg) {
+    Operands.reserve(1);
+    Operands.push_back(Use(VAI.Operands[0], this));
+  }
+public:
+  VarArgInst(Value *S, const Type *Ty, const std::string &Name = "",
+             Instruction *InsertBefore = 0)
+    : Instruction(Ty, VarArg, Name, InsertBefore) {
+    Operands.reserve(1);
+    Operands.push_back(Use(S, this));
+  }
+
+  virtual Instruction *clone() const { return new VarArgInst(*this); }
+
+  bool mayWriteToMemory() const { return true; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const VarArgInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == VarArg;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
 #endif