[PATCH 3/8] Implement the 'explicitcc' calling convention for X86

lib/Target/X86/X86CallingConv.h

   return false;
 }
 
+bool CC_X86_HWReg(unsigned &, MVT &, MVT &,
+      CCValAssign::LocInfo &, ISD::ArgFlagsTy &,
+      CCState &);
 } // End llvm namespace
 
 #endif

lib/Target/X86/X86CallingConv.td

   CCCustom<"CC_X86_AnyReg_Error">
 ]>;
 
+def RetCC_X86_64_Explicit : CallingConv<[
+      CCCustom<"CC_X86_AnyReg_Error">
+]>;
+
 // This is the root return-value convention for the X86-32 backend.
 def RetCC_X86_32 : CallingConv<[
   // If FastCC, use RetCC_X86_32_Fast.

   CCIfCC<"CallingConv::WebKit_JS", CCDelegateTo<RetCC_X86_64_WebKit_JS>>,
   CCIfCC<"CallingConv::AnyReg", CCDelegateTo<RetCC_X86_64_AnyReg>>,
 
+  // Handle ExplicitCC calls.
+  CCIfCC<"CallingConv::Explicit",
+          CCDelegateTo<RetCC_X86_64_Explicit>>,
+
   // Handle explicit CC selection
   CCIfCC<"CallingConv::X86_64_Win64", CCDelegateTo<RetCC_X86_Win64_C>>,
   CCIfCC<"CallingConv::X86_64_SysV", CCDelegateTo<RetCC_X86_64_C>>,

   CCCustom<"CC_X86_AnyReg_Error">
 ]>;
 
+def CC_X86_64_Explicit : CallingConv<[
+  CCCustom<"CC_X86_HWReg">
+]>;
+
 //===----------------------------------------------------------------------===//
 // X86 C Calling Convention
 //===----------------------------------------------------------------------===//

   CCIfCC<"CallingConv::HiPE", CCDelegateTo<CC_X86_64_HiPE>>,
   CCIfCC<"CallingConv::WebKit_JS", CCDelegateTo<CC_X86_64_WebKit_JS>>,
   CCIfCC<"CallingConv::AnyReg", CCDelegateTo<CC_X86_64_AnyReg>>,
+  CCIfCC<"CallingConv::Explicit", CCDelegateTo<CC_X86_64_Explicit>>,
   CCIfCC<"CallingConv::X86_64_Win64", CCDelegateTo<CC_X86_Win64_C>>,
   CCIfCC<"CallingConv::X86_64_SysV", CCDelegateTo<CC_X86_64_C>>,
   CCIfCC<"CallingConv::X86_VectorCall", CCDelegateTo<CC_X86_Win64_VectorCall>>,

 
 def CSR_NoRegs : CalleeSavedRegs<(add)>;
 
+def CSR_32_Explicit : CalleeSavedRegs<(add EBP)>;
+def CSR_64_Explicit : CalleeSavedRegs<(add RBP)>;
+
 def CSR_32 : CalleeSavedRegs<(add ESI, EDI, EBX, EBP)>;
 def CSR_64 : CalleeSavedRegs<(add RBX, R12, R13, R14, R15, RBP)>;
 

lib/Target/X86/X86ISelLowering.cpp

   return SrcAS < 256 && DestAS < 256;
 }
 
+bool llvm::CC_X86_HWReg(unsigned &ValNo, MVT &ValVT, MVT &LocVT,
+      CCValAssign::LocInfo &LocInfo,
+      ISD::ArgFlagsTy &ArgFlags,
+      CCState &State) {
+
+  assert(ArgFlags.isHWReg() &&
+   "A hw-register must be associated with each argument");
+
+  if (LocVT == MVT::i8 || LocVT == MVT::i16) {
+    LocVT = MVT::i32;
+    if (ArgFlags.isSExt())
+        LocInfo = CCValAssign::SExt;
+    else if (ArgFlags.isZExt())
+        LocInfo = CCValAssign::ZExt;
+    else
+        LocInfo = CCValAssign::AExt;
+  }
+
+  if (unsigned Reg = State.AllocateReg(ArgFlags.getHWReg())) {
+      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
+      return true;
+  }
+  llvm_unreachable("Failed to allocate a register which is assigned by the"
+       " hw-reg attribute");
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 //               Return Value Calling Convention Implementation
 //===----------------------------------------------------------------------===//

lib/Target/X86/X86RegisterInfo.cpp

     if (HasAVX)
       return CSR_64_AllRegs_AVX_SaveList;
     return CSR_64_AllRegs_SaveList;
+  case CallingConv::Explicit:
+    if (Is64Bit)
+      return CSR_64_Explicit_SaveList;
+    else
+      return CSR_32_Explicit_SaveList;
   case CallingConv::PreserveMost:
     return CSR_64_RT_MostRegs_SaveList;
   case CallingConv::PreserveAll:

     if (HasAVX)
       return CSR_64_AllRegs_AVX_RegMask;
     return CSR_64_AllRegs_RegMask;
+  case CallingConv::Explicit:
+    if (Is64Bit)
+      return CSR_64_Explicit_RegMask;
+    else
+      return CSR_32_Explicit_RegMask;
   case CallingConv::PreserveMost:
     return CSR_64_RT_MostRegs_RegMask;
   case CallingConv::PreserveAll: