Delete unnecessary elses.

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

diff --git a/include/llvm/CodeGen/CallingConvLower.h b/include/llvm/CodeGen/CallingConvLower.h
index 959d0528c651b0185beadb61ac804bdb31f2f67a..2a57cc183d2a7ccfb8bafcee02f3babe730c1fa6 100644 (file)
--- a/include/llvm/CodeGen/CallingConvLower.h
+++ b/include/llvm/CodeGen/CallingConvLower.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -17,9 +17,10 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/CodeGen/SelectionDAGNodes.h"
 
 namespace llvm {
-  class MRegisterInfo;
+  class TargetRegisterInfo;
   class TargetMachine;
   class CCState;
   class SDNode;
@@ -48,14 +49,14 @@ private:
   LocInfo HTP : 7;
   
   /// ValVT - The type of the value being assigned.
-  MVT::ValueType ValVT;
+  MVT ValVT;
 
   /// LocVT - The type of the location being assigned to.
-  MVT::ValueType LocVT;
+  MVT LocVT;
 public:
     
-  static CCValAssign getReg(unsigned ValNo, MVT::ValueType ValVT,
-                            unsigned RegNo, MVT::ValueType LocVT,
+  static CCValAssign getReg(unsigned ValNo, MVT ValVT,
+                            unsigned RegNo, MVT LocVT,
                             LocInfo HTP) {
     CCValAssign Ret;
     Ret.ValNo = ValNo;
@@ -66,8 +67,8 @@ public:
     Ret.LocVT = LocVT;
     return Ret;
   }
-  static CCValAssign getMem(unsigned ValNo, MVT::ValueType ValVT,
-                            unsigned Offset, MVT::ValueType LocVT,
+  static CCValAssign getMem(unsigned ValNo, MVT ValVT,
+                            unsigned Offset, MVT LocVT,
                             LocInfo HTP) {
     CCValAssign Ret;
     Ret.ValNo = ValNo;
@@ -80,14 +81,14 @@ public:
   }
   
   unsigned getValNo() const { return ValNo; }
-  MVT::ValueType getValVT() const { return ValVT; }
+  MVT getValVT() const { return ValVT; }
 
   bool isRegLoc() const { return !isMem; }
   bool isMemLoc() const { return isMem; }
   
   unsigned getLocReg() const { assert(isRegLoc()); return Loc; }
   unsigned getLocMemOffset() const { assert(isMemLoc()); return Loc; }
-  MVT::ValueType getLocVT() const { return LocVT; }
+  MVT getLocVT() const { return LocVT; }
   
   LocInfo getLocInfo() const { return HTP; }
 };
@@ -95,9 +96,9 @@ public:
 
 /// CCAssignFn - This function assigns a location for Val, updating State to
 /// reflect the change.
-typedef bool CCAssignFn(unsigned ValNo, MVT::ValueType ValVT,
-                        MVT::ValueType LocVT, CCValAssign::LocInfo LocInfo,
-                        unsigned ArgFlags, CCState &State);
+typedef bool CCAssignFn(unsigned ValNo, MVT ValVT,
+                        MVT LocVT, CCValAssign::LocInfo LocInfo,
+                        ISD::ArgFlagsTy ArgFlags, CCState &State);
 
   
 /// CCState - This class holds information needed while lowering arguments and
@@ -107,7 +108,7 @@ class CCState {
   unsigned CallingConv;
   bool IsVarArg;
   const TargetMachine &TM;
-  const MRegisterInfo &MRI;
+  const TargetRegisterInfo &TRI;
   SmallVector<CCValAssign, 16> &Locs;
   
   unsigned StackOffset;
@@ -142,12 +143,21 @@ public:
   
   /// AnalyzeCallOperands - Analyze an ISD::CALL node, incorporating info
   /// about the passed values into this state.
-  void AnalyzeCallOperands(SDNode *TheCall, CCAssignFn Fn);
+  void AnalyzeCallOperands(CallSDNode *TheCall, CCAssignFn Fn);
+
+  /// AnalyzeCallOperands - Same as above except it takes vectors of types
+  /// and argument flags.
+  void AnalyzeCallOperands(SmallVectorImpl<MVT> &ArgVTs,
+                           SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
+                           CCAssignFn Fn);
 
   /// AnalyzeCallResult - Analyze the return values of an ISD::CALL node,
   /// incorporating info about the passed values into this state.
-  void AnalyzeCallResult(SDNode *TheCall, CCAssignFn Fn);
+  void AnalyzeCallResult(CallSDNode *TheCall, CCAssignFn Fn);
   
+  /// AnalyzeCallResult - Same as above except it's specialized for calls which
+  /// produce a single value.
+  void AnalyzeCallResult(MVT VT, CCAssignFn Fn);
 
   /// getFirstUnallocated - Return the first unallocated register in the set, or
   /// NumRegs if they are all allocated.
@@ -166,7 +176,15 @@ public:
     MarkAllocated(Reg);
     return Reg;
   }
-  
+
+  /// Version of AllocateReg with extra register to be shadowed.
+  unsigned AllocateReg(unsigned Reg, unsigned ShadowReg) {
+    if (isAllocated(Reg)) return 0;
+    MarkAllocated(Reg);
+    MarkAllocated(ShadowReg);
+    return Reg;
+  }
+
   /// AllocateReg - Attempt to allocate one of the specified registers.  If none
   /// are available, return zero.  Otherwise, return the first one available,
   /// marking it and any aliases as allocated.
@@ -174,13 +192,27 @@ public:
     unsigned FirstUnalloc = getFirstUnallocated(Regs, NumRegs);
     if (FirstUnalloc == NumRegs)
       return 0;    // Didn't find the reg.
-     
+
     // Mark the register and any aliases as allocated.
     unsigned Reg = Regs[FirstUnalloc];
     MarkAllocated(Reg);
     return Reg;
   }
-  
+
+  /// Version of AllocateReg with list of registers to be shadowed.
+  unsigned AllocateReg(const unsigned *Regs, const unsigned *ShadowRegs,
+                       unsigned NumRegs) {
+    unsigned FirstUnalloc = getFirstUnallocated(Regs, NumRegs);
+    if (FirstUnalloc == NumRegs)
+      return 0;    // Didn't find the reg.
+
+    // Mark the register and any aliases as allocated.
+    unsigned Reg = Regs[FirstUnalloc], ShadowReg = ShadowRegs[FirstUnalloc];
+    MarkAllocated(Reg);
+    MarkAllocated(ShadowReg);
+    return Reg;
+  }
+
   /// AllocateStack - Allocate a chunk of stack space with the specified size
   /// and alignment.
   unsigned AllocateStack(unsigned Size, unsigned Align) {
@@ -190,6 +222,14 @@ public:
     StackOffset += Size;
     return Result;
   }
+
+  // HandleByVal - Allocate a stack slot large enough to pass an argument by
+  // value. The size and alignment information of the argument is encoded in its
+  // parameter attribute.
+  void HandleByVal(unsigned ValNo, MVT ValVT,
+                   MVT LocVT, CCValAssign::LocInfo LocInfo,
+                   int MinSize, int MinAlign, ISD::ArgFlagsTy ArgFlags);
+
 private:
   /// MarkAllocated - Mark a register and all of its aliases as allocated.
   void MarkAllocated(unsigned Reg);