Added LLVM copyright header (for lack of a better term).

[oota-llvm.git] / include / llvm / CodeGen / MachineInstrAnnot.h

diff --git a/include/llvm/CodeGen/MachineInstrAnnot.h b/include/llvm/CodeGen/MachineInstrAnnot.h
index bd3f7333e321e6636ffa682161fce3c844c951e8..98dde590b8d01d6417d46b90eafbf4da9e740235 100644 (file)
--- a/include/llvm/CodeGen/MachineInstrAnnot.h
+++ b/include/llvm/CodeGen/MachineInstrAnnot.h
@@ -1,4 +1,11 @@
 //===-- llvm/CodeGen/MachineInstrAnnot.h ------------------------*- 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.
+// 
+//===----------------------------------------------------------------------===//
 //
 //  Annotations used to pass information between code generation phases.
 // 
@@ -7,8 +14,8 @@
 #ifndef MACHINE_INSTR_ANNOT_h
 #define MACHINE_INSTR_ANNOT_h
 
-#include "llvm/Annotation.h"
 #include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/Target/TargetRegInfo.h"
 
 class Value;
 class TmpInstruction;
@@ -20,47 +27,48 @@ class CallArgInfo {
   static const unsigned char FPArgReg  = 0x2;
   static const unsigned char StackSlot = 0x4;
   
-  const Value* argVal;                  // this argument
-  const Value* argValCopy;              // second copy of arg. when multiple 
-                                        // copies must be passed in registers
-  unsigned char passingMethod;          // flags recording passing methods
+  Value*        argVal;         // this argument
+  int           argCopyReg;     // register used for second copy of arg. when
+                                // multiple  copies must be passed in registers
+  unsigned char passingMethod;  // flags recording passing methods
   
 public:
   // Constructors
-  CallArgInfo(const Value* _argVal)
-    : argVal(_argVal), argValCopy(NULL), passingMethod(0x0) {}
+  CallArgInfo(Value* _argVal)
+    : argVal(_argVal), argCopyReg(TargetRegInfo::getInvalidRegNum()),
+      passingMethod(0x0) {}
   
   CallArgInfo(const CallArgInfo& obj)
-    : argVal(obj.argVal), argValCopy(obj.argValCopy),
+    : argVal(obj.argVal), argCopyReg(obj.argCopyReg),
       passingMethod(obj.passingMethod) {}
   
   // Accessor methods
-  const Value*  getArgVal()       { return argVal; }
-  const Value*  getArgCopy()      { return argValCopy; }
+  Value*        getArgVal()       { return argVal; }
+  int           getArgCopy()      { return argCopyReg; }
   bool          usesIntArgReg()   { return (bool) (passingMethod & IntArgReg);} 
   bool          usesFPArgReg()    { return (bool) (passingMethod & FPArgReg); } 
   bool          usesStackSlot()   { return (bool) (passingMethod & StackSlot);} 
   
   // Modifier methods
-  void          replaceArgVal(const Value* newVal) { argVal = newVal; }
+  void          replaceArgVal(Value* newVal) { argVal = newVal; }
   void          setUseIntArgReg() { passingMethod |= IntArgReg; }
   void          setUseFPArgReg()  { passingMethod |= FPArgReg; }
   void          setUseStackSlot() { passingMethod |= StackSlot; }
-  void          setArgCopy(const Value* tmp) { argValCopy = tmp; }
+  void          setArgCopy(int copyReg) { argCopyReg = copyReg; }
 };
 
 
-class CallArgsDescriptor: public Annotation { // Annotation for a MachineInstr
-  static AnnotationID AID;              // AnnotationID for this class
+class CallArgsDescriptor {
+
   std::vector<CallArgInfo> argInfoVec;  // Descriptor for each argument
-  const CallInst* callInstr;            // The call instruction == result value
-  const Value* funcPtr;                 // Pointer for indirect calls 
+  CallInst* callInstr;                  // The call instruction == result value
+  Value* funcPtr;                       // Pointer for indirect calls 
   TmpInstruction* retAddrReg;           // Tmp value for return address reg.
   bool isVarArgs;                       // Is this a varargs call?
   bool noPrototype;                     // Is this a call with no prototype?
   
 public:
-  CallArgsDescriptor(const CallInst* _callInstr, TmpInstruction* _retAddrReg,
+  CallArgsDescriptor(CallInst* _callInstr, TmpInstruction* _retAddrReg,
                      bool _isVarArgs, bool _noPrototype);
   
   // Accessor methods to retrieve information about the call
@@ -68,18 +76,16 @@ public:
   unsigned int    getNumArgs() const          { return argInfoVec.size(); }
   CallArgInfo&    getArgInfo(unsigned int op) { assert(op < argInfoVec.size());
                                                 return argInfoVec[op]; }
-  const CallInst* getReturnValue() const      { return callInstr; }
-  const Value*    getIndirectFuncPtr() const  { return funcPtr; }
+  CallInst*       getCallInst() const         { return callInstr; }
+  CallInst*       getReturnValue() const;
+  Value*          getIndirectFuncPtr() const  { return funcPtr; }
   TmpInstruction* getReturnAddrReg() const    { return retAddrReg; }
   bool            isVarArgsFunc() const       { return isVarArgs; }
   bool            hasNoPrototype() const      { return noPrototype; }
-  
-  // Annotation mechanism to annotate a MachineInstr with the descriptor.
-  // This is not demand-driven because annotations can only be created
-  // at restricted points during code generation.
-  static inline CallArgsDescriptor *get(const MachineInstr* MI) {
-    return (CallArgsDescriptor *) MI->getAnnotation(AID);
-  }
+
+  // Mechanism to get the descriptor for a CALL MachineInstr.
+  // 
+  static CallArgsDescriptor *get(const MachineInstr* MI);
 };