Skip site navigation (1)Skip section navigation (2)
Date:      Thu, 3 Oct 2013 20:38:57 +0000 (UTC)
From:      Dimitry Andric <dim@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org
Subject:   svn commit: r256030 - in head/contrib/llvm: include/llvm/IR lib/AsmParser lib/IR lib/Target/X86 tools/clang/include/clang-c tools/clang/include/clang/AST tools/clang/include/clang/Basic tools/clang...
Message-ID:  <201310032038.r93KcvVl010208@svn.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: dim
Date: Thu Oct  3 20:38:57 2013
New Revision: 256030
URL: http://svnweb.freebsd.org/changeset/base/256030

Log:
  Pull in r189644 from upstream llvm trunk:
  
    Add ms_abi and sysv_abi attribute handling.
  
    Based on a patch by Benno Rice!
  
  This will help to develop EFI support.
  
  Approved by:	re (kib)
  Verified by:	benno
  MFC after:	1 week

Modified:
  head/contrib/llvm/include/llvm/IR/CallingConv.h
  head/contrib/llvm/lib/AsmParser/LLLexer.cpp
  head/contrib/llvm/lib/AsmParser/LLParser.cpp
  head/contrib/llvm/lib/AsmParser/LLToken.h
  head/contrib/llvm/lib/IR/AsmWriter.cpp
  head/contrib/llvm/lib/Target/X86/X86CallingConv.td
  head/contrib/llvm/lib/Target/X86/X86FastISel.cpp
  head/contrib/llvm/lib/Target/X86/X86ISelLowering.cpp
  head/contrib/llvm/lib/Target/X86/X86Subtarget.h
  head/contrib/llvm/tools/clang/include/clang-c/Index.h
  head/contrib/llvm/tools/clang/include/clang/AST/Type.h
  head/contrib/llvm/tools/clang/include/clang/Basic/Attr.td
  head/contrib/llvm/tools/clang/include/clang/Basic/Specifiers.h
  head/contrib/llvm/tools/clang/lib/AST/DumpXML.cpp
  head/contrib/llvm/tools/clang/lib/AST/MicrosoftMangle.cpp
  head/contrib/llvm/tools/clang/lib/AST/Type.cpp
  head/contrib/llvm/tools/clang/lib/AST/TypePrinter.cpp
  head/contrib/llvm/tools/clang/lib/Basic/Targets.cpp
  head/contrib/llvm/tools/clang/lib/CodeGen/CGCall.cpp
  head/contrib/llvm/tools/clang/lib/Sema/SemaDeclAttr.cpp
  head/contrib/llvm/tools/clang/lib/Sema/SemaType.cpp

Modified: head/contrib/llvm/include/llvm/IR/CallingConv.h
==============================================================================
--- head/contrib/llvm/include/llvm/IR/CallingConv.h	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/include/llvm/IR/CallingConv.h	Thu Oct  3 20:38:57 2013	(r256030)
@@ -119,8 +119,17 @@ namespace CallingConv {
     SPIR_KERNEL = 76,
 
     /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins
-    Intel_OCL_BI = 77
+    Intel_OCL_BI = 77,
 
+    /// \brief The C convention as specified in the x86-64 supplement to the
+    /// System V ABI, used on most non-Windows systems.
+    X86_64_SysV = 78,
+
+    /// \brief The C convention as implemented on Windows/x86-64. This
+    /// convention differs from the more common \c X86_64_SysV convention
+    /// in a number of ways, most notably in that XMM registers used to pass
+    /// arguments are shadowed by GPRs, and vice versa.
+    X86_64_Win64 = 79
   };
 } // End CallingConv namespace
 

Modified: head/contrib/llvm/lib/AsmParser/LLLexer.cpp
==============================================================================
--- head/contrib/llvm/lib/AsmParser/LLLexer.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/AsmParser/LLLexer.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -556,6 +556,8 @@ lltok::Kind LLLexer::LexIdentifier() {
   KEYWORD(spir_kernel);
   KEYWORD(spir_func);
   KEYWORD(intel_ocl_bicc);
+  KEYWORD(x86_64_sysvcc);
+  KEYWORD(x86_64_win64cc);
 
   KEYWORD(cc);
   KEYWORD(c);

Modified: head/contrib/llvm/lib/AsmParser/LLParser.cpp
==============================================================================
--- head/contrib/llvm/lib/AsmParser/LLParser.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/AsmParser/LLParser.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -1337,6 +1337,8 @@ bool LLParser::ParseOptionalVisibility(u
 ///   ::= 'ptx_device'
 ///   ::= 'spir_func'
 ///   ::= 'spir_kernel'
+///   ::= 'x86_64_sysvcc'
+///   ::= 'x86_64_win64cc'
 ///   ::= 'cc' UINT
 ///
 bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) {
@@ -1357,6 +1359,8 @@ bool LLParser::ParseOptionalCallingConv(
   case lltok::kw_spir_kernel:    CC = CallingConv::SPIR_KERNEL; break;
   case lltok::kw_spir_func:      CC = CallingConv::SPIR_FUNC; break;
   case lltok::kw_intel_ocl_bicc: CC = CallingConv::Intel_OCL_BI; break;
+  case lltok::kw_x86_64_sysvcc:  CC = CallingConv::X86_64_SysV; break;
+  case lltok::kw_x86_64_win64cc: CC = CallingConv::X86_64_Win64; break;
   case lltok::kw_cc: {
       unsigned ArbitraryCC;
       Lex.Lex();

Modified: head/contrib/llvm/lib/AsmParser/LLToken.h
==============================================================================
--- head/contrib/llvm/lib/AsmParser/LLToken.h	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/AsmParser/LLToken.h	Thu Oct  3 20:38:57 2013	(r256030)
@@ -84,12 +84,13 @@ namespace lltok {
     kw_c,
 
     kw_cc, kw_ccc, kw_fastcc, kw_coldcc,
-	  kw_intel_ocl_bicc,
+    kw_intel_ocl_bicc,
     kw_x86_stdcallcc, kw_x86_fastcallcc, kw_x86_thiscallcc,
     kw_arm_apcscc, kw_arm_aapcscc, kw_arm_aapcs_vfpcc,
     kw_msp430_intrcc,
     kw_ptx_kernel, kw_ptx_device,
     kw_spir_kernel, kw_spir_func,
+    kw_x86_64_sysvcc, kw_x86_64_win64cc,
 
     // Attributes:
     kw_attributes,

Modified: head/contrib/llvm/lib/IR/AsmWriter.cpp
==============================================================================
--- head/contrib/llvm/lib/IR/AsmWriter.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/IR/AsmWriter.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -81,6 +81,8 @@ static void PrintCallingConv(unsigned cc
   case CallingConv::MSP430_INTR:   Out << "msp430_intrcc"; break;
   case CallingConv::PTX_Kernel:    Out << "ptx_kernel"; break;
   case CallingConv::PTX_Device:    Out << "ptx_device"; break;
+  case CallingConv::X86_64_SysV:   Out << "x86_64_sysvcc"; break;
+  case CallingConv::X86_64_Win64:  Out << "x86_64_win64cc"; break;
   }
 }
 

Modified: head/contrib/llvm/lib/Target/X86/X86CallingConv.td
==============================================================================
--- head/contrib/llvm/lib/Target/X86/X86CallingConv.td	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/Target/X86/X86CallingConv.td	Thu Oct  3 20:38:57 2013	(r256030)
@@ -156,6 +156,11 @@ def RetCC_X86_32 : CallingConv<[
 def RetCC_X86_64 : CallingConv<[
   // HiPE uses RetCC_X86_64_HiPE
   CCIfCC<"CallingConv::HiPE", CCDelegateTo<RetCC_X86_64_HiPE>>,
+
+  // Handle explicit CC selection
+  CCIfCC<"CallingConv::X86_64_Win64", CCDelegateTo<RetCC_X86_Win64_C>>,
+  CCIfCC<"CallingConv::X86_64_SysV", CCDelegateTo<RetCC_X86_64_C>>,
+
   // Mingw64 and native Win64 use Win64 CC
   CCIfSubtarget<"isTargetWin64()", CCDelegateTo<RetCC_X86_Win64_C>>,
 
@@ -489,6 +494,8 @@ def CC_X86_32 : CallingConv<[
 def CC_X86_64 : CallingConv<[
   CCIfCC<"CallingConv::GHC", CCDelegateTo<CC_X86_64_GHC>>,
   CCIfCC<"CallingConv::HiPE", CCDelegateTo<CC_X86_64_HiPE>>,
+  CCIfCC<"CallingConv::X86_64_Win64", CCDelegateTo<CC_X86_Win64_C>>,
+  CCIfCC<"CallingConv::X86_64_SysV", CCDelegateTo<CC_X86_64_C>>,
 
   // Mingw64 and native Win64 use Win64 CC
   CCIfSubtarget<"isTargetWin64()", CCDelegateTo<CC_X86_Win64_C>>,

Modified: head/contrib/llvm/lib/Target/X86/X86FastISel.cpp
==============================================================================
--- head/contrib/llvm/lib/Target/X86/X86FastISel.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/Target/X86/X86FastISel.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -717,10 +717,11 @@ bool X86FastISel::X86SelectRet(const Ins
   CallingConv::ID CC = F.getCallingConv();
   if (CC != CallingConv::C &&
       CC != CallingConv::Fast &&
-      CC != CallingConv::X86_FastCall)
+      CC != CallingConv::X86_FastCall &&
+      CC != CallingConv::X86_64_SysV)
     return false;
 
-  if (Subtarget->isTargetWin64())
+  if (Subtarget->isCallingConvWin64(CC))
     return false;
 
   // Don't handle popping bytes on return for now.
@@ -1643,9 +1644,6 @@ bool X86FastISel::FastLowerArguments() {
   if (!FuncInfo.CanLowerReturn)
     return false;
 
-  if (Subtarget->isTargetWin64())
-    return false;
-
   const Function *F = FuncInfo.Fn;
   if (F->isVarArg())
     return false;
@@ -1653,7 +1651,10 @@ bool X86FastISel::FastLowerArguments() {
   CallingConv::ID CC = F->getCallingConv();
   if (CC != CallingConv::C)
     return false;
-  
+
+  if (Subtarget->isCallingConvWin64(CC))
+    return false;
+
   if (!Subtarget->is64Bit())
     return false;
   
@@ -1757,8 +1758,10 @@ bool X86FastISel::DoSelectCall(const Ins
   // Handle only C and fastcc calling conventions for now.
   ImmutableCallSite CS(CI);
   CallingConv::ID CC = CS.getCallingConv();
+  bool isWin64 = Subtarget->isCallingConvWin64(CC);
   if (CC != CallingConv::C && CC != CallingConv::Fast &&
-      CC != CallingConv::X86_FastCall)
+      CC != CallingConv::X86_FastCall && CC != CallingConv::X86_64_Win64 &&
+      CC != CallingConv::X86_64_SysV)
     return false;
 
   // fastcc with -tailcallopt is intended to provide a guaranteed
@@ -1772,7 +1775,7 @@ bool X86FastISel::DoSelectCall(const Ins
 
   // Don't know how to handle Win64 varargs yet.  Nothing special needed for
   // x86-32.  Special handling for x86-64 is implemented.
-  if (isVarArg && Subtarget->isTargetWin64())
+  if (isVarArg && isWin64)
     return false;
 
   // Fast-isel doesn't know about callee-pop yet.
@@ -1902,7 +1905,7 @@ bool X86FastISel::DoSelectCall(const Ins
                  I->getParent()->getContext());
 
   // Allocate shadow area for Win64
-  if (Subtarget->isTargetWin64())
+  if (isWin64)
     CCInfo.AllocateStack(32, 8);
 
   CCInfo.AnalyzeCallOperands(ArgVTs, ArgFlags, CC_X86);
@@ -2016,7 +2019,7 @@ bool X86FastISel::DoSelectCall(const Ins
             X86::EBX).addReg(Base);
   }
 
-  if (Subtarget->is64Bit() && isVarArg && !Subtarget->isTargetWin64()) {
+  if (Subtarget->is64Bit() && isVarArg && !isWin64) {
     // Count the number of XMM registers allocated.
     static const uint16_t XMMArgRegs[] = {
       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
@@ -2085,7 +2088,7 @@ bool X86FastISel::DoSelectCall(const Ins
   if (Subtarget->isPICStyleGOT())
     MIB.addReg(X86::EBX, RegState::Implicit);
 
-  if (Subtarget->is64Bit() && isVarArg && !Subtarget->isTargetWin64())
+  if (Subtarget->is64Bit() && isVarArg && !isWin64)
     MIB.addReg(X86::AL, RegState::Implicit);
 
   // Add implicit physical register uses to the call.

Modified: head/contrib/llvm/lib/Target/X86/X86ISelLowering.cpp
==============================================================================
--- head/contrib/llvm/lib/Target/X86/X86ISelLowering.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/Target/X86/X86ISelLowering.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -1883,13 +1883,19 @@ static bool IsTailCallConvention(Calling
           CC == CallingConv::HiPE);
 }
 
+/// \brief Return true if the calling convention is a C calling convention.
+static bool IsCCallConvention(CallingConv::ID CC) {
+  return (CC == CallingConv::C || CC == CallingConv::X86_64_Win64 ||
+          CC == CallingConv::X86_64_SysV);
+}
+
 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
     return false;
 
   CallSite CS(CI);
   CallingConv::ID CalleeCC = CS.getCallingConv();
-  if (!IsTailCallConvention(CalleeCC) && CalleeCC != CallingConv::C)
+  if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
     return false;
 
   return true;
@@ -1964,7 +1970,7 @@ X86TargetLowering::LowerFormalArguments(
   MachineFrameInfo *MFI = MF.getFrameInfo();
   bool Is64Bit = Subtarget->is64Bit();
   bool IsWindows = Subtarget->isTargetWindows();
-  bool IsWin64 = Subtarget->isTargetWin64();
+  bool IsWin64 = Subtarget->isCallingConvWin64(CallConv);
 
   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
          "Var args not supported with calling convention fastcc, ghc or hipe");
@@ -1975,9 +1981,8 @@ X86TargetLowering::LowerFormalArguments(
                  ArgLocs, *DAG.getContext());
 
   // Allocate shadow area for Win64
-  if (IsWin64) {
+  if (IsWin64)
     CCInfo.AllocateStack(32, 8);
-  }
 
   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
 
@@ -2290,7 +2295,7 @@ X86TargetLowering::LowerCall(TargetLower
 
   MachineFunction &MF = DAG.getMachineFunction();
   bool Is64Bit        = Subtarget->is64Bit();
-  bool IsWin64        = Subtarget->isTargetWin64();
+  bool IsWin64        = Subtarget->isCallingConvWin64(CallConv);
   bool IsWindows      = Subtarget->isTargetWindows();
   StructReturnType SR = callIsStructReturn(Outs);
   bool IsSibcall      = false;
@@ -2323,9 +2328,8 @@ X86TargetLowering::LowerCall(TargetLower
                  ArgLocs, *DAG.getContext());
 
   // Allocate shadow area for Win64
-  if (IsWin64) {
+  if (IsWin64)
     CCInfo.AllocateStack(32, 8);
-  }
 
   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
 
@@ -2831,13 +2835,12 @@ X86TargetLowering::IsEligibleForTailCall
                                     const SmallVectorImpl<SDValue> &OutVals,
                                     const SmallVectorImpl<ISD::InputArg> &Ins,
                                                      SelectionDAG &DAG) const {
-  if (!IsTailCallConvention(CalleeCC) &&
-      CalleeCC != CallingConv::C)
+  if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
     return false;
 
   // If -tailcallopt is specified, make fastcc functions tail-callable.
   const MachineFunction &MF = DAG.getMachineFunction();
-  const Function *CallerF = DAG.getMachineFunction().getFunction();
+  const Function *CallerF = MF.getFunction();
 
   // If the function return type is x86_fp80 and the callee return type is not,
   // then the FP_EXTEND of the call result is not a nop. It's not safe to
@@ -2847,6 +2850,8 @@ X86TargetLowering::IsEligibleForTailCall
 
   CallingConv::ID CallerCC = CallerF->getCallingConv();
   bool CCMatch = CallerCC == CalleeCC;
+  bool IsCalleeWin64 = Subtarget->isCallingConvWin64(CalleeCC);
+  bool IsCallerWin64 = Subtarget->isCallingConvWin64(CallerCC);
 
   if (getTargetMachine().Options.GuaranteedTailCallOpt) {
     if (IsTailCallConvention(CalleeCC) && CCMatch)
@@ -2878,7 +2883,7 @@ X86TargetLowering::IsEligibleForTailCall
 
     // Optimizing for varargs on Win64 is unlikely to be safe without
     // additional testing.
-    if (Subtarget->isTargetWin64())
+    if (IsCalleeWin64 || IsCallerWin64)
       return false;
 
     SmallVector<CCValAssign, 16> ArgLocs;
@@ -2953,9 +2958,8 @@ X86TargetLowering::IsEligibleForTailCall
                    getTargetMachine(), ArgLocs, *DAG.getContext());
 
     // Allocate shadow area for Win64
-    if (Subtarget->isTargetWin64()) {
+    if (IsCalleeWin64)
       CCInfo.AllocateStack(32, 8);
-    }
 
     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
     if (CCInfo.getNextStackOffset()) {

Modified: head/contrib/llvm/lib/Target/X86/X86Subtarget.h
==============================================================================
--- head/contrib/llvm/lib/Target/X86/X86Subtarget.h	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/lib/Target/X86/X86Subtarget.h	Thu Oct  3 20:38:57 2013	(r256030)
@@ -338,7 +338,13 @@ public:
   }
   bool isPICStyleStubAny() const {
     return PICStyle == PICStyles::StubDynamicNoPIC ||
-           PICStyle == PICStyles::StubPIC; }
+           PICStyle == PICStyles::StubPIC;
+  }
+
+  bool isCallingConvWin64(CallingConv::ID CC) const {
+    return (isTargetWin64() && CC != CallingConv::X86_64_SysV) ||
+           CC == CallingConv::X86_64_Win64;
+  }
 
   /// ClassifyGlobalReference - Classify a global variable reference for the
   /// current subtarget according to how we should reference it in a non-pcrel

Modified: head/contrib/llvm/tools/clang/include/clang-c/Index.h
==============================================================================
--- head/contrib/llvm/tools/clang/include/clang-c/Index.h	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/include/clang-c/Index.h	Thu Oct  3 20:38:57 2013	(r256030)
@@ -2683,6 +2683,8 @@ enum CXCallingConv {
   CXCallingConv_AAPCS_VFP = 7,
   CXCallingConv_PnaclCall = 8,
   CXCallingConv_IntelOclBicc = 9,
+  CXCallingConv_X86_64Win64 = 10,
+  CXCallingConv_X86_64SysV = 11,
 
   CXCallingConv_Invalid = 100,
   CXCallingConv_Unexposed = 200

Modified: head/contrib/llvm/tools/clang/include/clang/AST/Type.h
==============================================================================
--- head/contrib/llvm/tools/clang/include/clang/AST/Type.h	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/include/clang/AST/Type.h	Thu Oct  3 20:38:57 2013	(r256030)
@@ -3335,7 +3335,9 @@ public:
     attr_thiscall,
     attr_pascal,
     attr_pnaclcall,
-    attr_inteloclbicc
+    attr_inteloclbicc,
+    attr_ms_abi,
+    attr_sysv_abi
   };
 
 private:

Modified: head/contrib/llvm/tools/clang/include/clang/Basic/Attr.td
==============================================================================
--- head/contrib/llvm/tools/clang/include/clang/Basic/Attr.td	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/include/clang/Basic/Attr.td	Thu Oct  3 20:38:57 2013	(r256030)
@@ -417,6 +417,10 @@ def MayAlias : InheritableAttr {
   let Spellings = [GNU<"may_alias">, CXX11<"gnu", "may_alias">];
 }
 
+def MSABI : InheritableAttr {
+  let Spellings = [GNU<"ms_abi">, CXX11<"gnu", "ms_abi">];
+}
+
 def MSP430Interrupt : InheritableAttr {
   let Spellings = [];
   let Args = [UnsignedArgument<"Number">];
@@ -664,6 +668,10 @@ def StdCall : InheritableAttr {
                    Keyword<"__stdcall">, Keyword<"_stdcall">];
 }
 
+def SysVABI : InheritableAttr {
+  let Spellings = [GNU<"sysv_abi">, CXX11<"gnu", "sysv_abi">];
+}
+
 def ThisCall : InheritableAttr {
   let Spellings = [GNU<"thiscall">, CXX11<"gnu", "thiscall">,
                    Keyword<"__thiscall">, Keyword<"_thiscall">];

Modified: head/contrib/llvm/tools/clang/include/clang/Basic/Specifiers.h
==============================================================================
--- head/contrib/llvm/tools/clang/include/clang/Basic/Specifiers.h	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/include/clang/Basic/Specifiers.h	Thu Oct  3 20:38:57 2013	(r256030)
@@ -206,6 +206,8 @@ namespace clang {
     CC_X86FastCall, // __attribute__((fastcall))
     CC_X86ThisCall, // __attribute__((thiscall))
     CC_X86Pascal,   // __attribute__((pascal))
+    CC_X86_64Win64, // __attribute__((ms_abi))
+    CC_X86_64SysV,  // __attribute__((sysv_abi))
     CC_AAPCS,       // __attribute__((pcs("aapcs")))
     CC_AAPCS_VFP,   // __attribute__((pcs("aapcs-vfp")))
     CC_PnaclCall,   // __attribute__((pnaclcall))

Modified: head/contrib/llvm/tools/clang/lib/AST/DumpXML.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/AST/DumpXML.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/AST/DumpXML.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -921,6 +921,8 @@ struct XMLDumper : public XMLDeclVisitor
     case CC_X86StdCall: return set("cc", "x86_stdcall");
     case CC_X86ThisCall: return set("cc", "x86_thiscall");
     case CC_X86Pascal: return set("cc", "x86_pascal");
+    case CC_X86_64Win64: return set("cc", "x86_64_win64");
+    case CC_X86_64SysV: return set("cc", "x86_64_sysv");
     case CC_AAPCS: return set("cc", "aapcs");
     case CC_AAPCS_VFP: return set("cc", "aapcs_vfp");
     case CC_PnaclCall: return set("cc", "pnaclcall");

Modified: head/contrib/llvm/tools/clang/lib/AST/MicrosoftMangle.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/AST/MicrosoftMangle.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/AST/MicrosoftMangle.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -1311,6 +1311,8 @@ void MicrosoftCXXNameMangler::mangleCall
   switch (CC) {
     default:
       llvm_unreachable("Unsupported CC for mangling");
+    case CC_X86_64Win64:
+    case CC_X86_64SysV:
     case CC_Default:
     case CC_C: Out << 'A'; break;
     case CC_X86Pascal: Out << 'C'; break;

Modified: head/contrib/llvm/tools/clang/lib/AST/Type.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/AST/Type.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/AST/Type.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -1574,6 +1574,8 @@ StringRef FunctionType::getNameForCallCo
   case CC_X86FastCall: return "fastcall";
   case CC_X86ThisCall: return "thiscall";
   case CC_X86Pascal: return "pascal";
+  case CC_X86_64Win64: return "ms_abi";
+  case CC_X86_64SysV: return "sysv_abi";
   case CC_AAPCS: return "aapcs";
   case CC_AAPCS_VFP: return "aapcs-vfp";
   case CC_PnaclCall: return "pnaclcall";

Modified: head/contrib/llvm/tools/clang/lib/AST/TypePrinter.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/AST/TypePrinter.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/AST/TypePrinter.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -650,6 +650,12 @@ void TypePrinter::printFunctionProtoAfte
   case CC_IntelOclBicc:
     OS << " __attribute__((intel_ocl_bicc))";
     break;
+   case CC_X86_64Win64:
+     OS << " __attribute__((ms_abi))";
+     break;
+   case CC_X86_64SysV:
+     OS << " __attribute__((sysv_abi))";
+     break;
   }
   if (Info.getNoReturn())
     OS << " __attribute__((noreturn))";
@@ -1160,6 +1166,8 @@ void TypePrinter::printAttributedAfter(c
   case AttributedType::attr_stdcall: OS << "stdcall"; break;
   case AttributedType::attr_thiscall: OS << "thiscall"; break;
   case AttributedType::attr_pascal: OS << "pascal"; break;
+  case AttributedType::attr_ms_abi: OS << "ms_abi"; break;
+  case AttributedType::attr_sysv_abi: OS << "sysv_abi"; break;
   case AttributedType::attr_pcs: {
     OS << "pcs(";
    QualType t = T->getEquivalentType();

Modified: head/contrib/llvm/tools/clang/lib/Basic/Targets.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/Basic/Targets.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/Basic/Targets.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -3182,8 +3182,9 @@ public:
 
   virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
     return (CC == CC_Default ||
-            CC == CC_C || 
-            CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
+            CC == CC_C ||
+            CC == CC_IntelOclBicc ||
+            CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
   }
 
   virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
@@ -3219,6 +3220,11 @@ public:
   virtual BuiltinVaListKind getBuiltinVaListKind() const {
     return TargetInfo::CharPtrBuiltinVaList;
   }
+  virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
+    return (CC == CC_C ||
+            CC == CC_IntelOclBicc ||
+            CC == CC_X86_64SysV) ? CCCR_OK : CCCR_Warning;
+  }
 };
 } // end anonymous namespace
 

Modified: head/contrib/llvm/tools/clang/lib/CodeGen/CGCall.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/CodeGen/CGCall.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/CodeGen/CGCall.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -41,6 +41,8 @@ static unsigned ClangCallConvToLLVMCallC
   case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
   case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
   case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
+  case CC_X86_64Win64: return llvm::CallingConv::X86_64_Win64;
+  case CC_X86_64SysV: return llvm::CallingConv::X86_64_SysV;
   case CC_AAPCS: return llvm::CallingConv::ARM_AAPCS;
   case CC_AAPCS_VFP: return llvm::CallingConv::ARM_AAPCS_VFP;
   case CC_IntelOclBicc: return llvm::CallingConv::Intel_OCL_BI;

Modified: head/contrib/llvm/tools/clang/lib/Sema/SemaDeclAttr.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/Sema/SemaDeclAttr.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/Sema/SemaDeclAttr.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -3961,6 +3961,16 @@ static void handleCallConvAttr(Sema &S, 
                PascalAttr(Attr.getRange(), S.Context,
                           Attr.getAttributeSpellingListIndex()));
     return;
+  case AttributeList::AT_MSABI:
+    D->addAttr(::new (S.Context)
+               MSABIAttr(Attr.getRange(), S.Context,
+                         Attr.getAttributeSpellingListIndex()));
+    return;
+  case AttributeList::AT_SysVABI:
+    D->addAttr(::new (S.Context)
+               SysVABIAttr(Attr.getRange(), S.Context,
+                           Attr.getAttributeSpellingListIndex()));
+    return;
   case AttributeList::AT_Pcs: {
     PcsAttr::PCSType PCS;
     switch (CC) {
@@ -4036,6 +4046,14 @@ bool Sema::CheckCallingConvAttr(const At
   case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
   case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
   case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
+  case AttributeList::AT_MSABI:
+    CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
+                                                             CC_X86_64Win64;
+    break;
+  case AttributeList::AT_SysVABI:
+    CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
+                                                             CC_C;
+    break;
   case AttributeList::AT_Pcs: {
     Expr *Arg = attr.getArg(0);
     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
@@ -4876,6 +4894,8 @@ static void ProcessInheritableDeclAttr(S
   case AttributeList::AT_FastCall:
   case AttributeList::AT_ThisCall:
   case AttributeList::AT_Pascal:
+  case AttributeList::AT_MSABI:
+  case AttributeList::AT_SysVABI:
   case AttributeList::AT_Pcs:
   case AttributeList::AT_PnaclCall:
   case AttributeList::AT_IntelOclBicc:

Modified: head/contrib/llvm/tools/clang/lib/Sema/SemaType.cpp
==============================================================================
--- head/contrib/llvm/tools/clang/lib/Sema/SemaType.cpp	Thu Oct  3 18:58:35 2013	(r256029)
+++ head/contrib/llvm/tools/clang/lib/Sema/SemaType.cpp	Thu Oct  3 20:38:57 2013	(r256030)
@@ -105,6 +105,8 @@ static void diagnoseBadTypeAttribute(Sem
     case AttributeList::AT_StdCall: \
     case AttributeList::AT_ThisCall: \
     case AttributeList::AT_Pascal: \
+    case AttributeList::AT_MSABI: \
+    case AttributeList::AT_SysVABI: \
     case AttributeList::AT_Regparm: \
     case AttributeList::AT_Pcs: \
     case AttributeList::AT_PnaclCall: \
@@ -3296,6 +3298,10 @@ static AttributeList::Kind getAttrListKi
     return AttributeList::AT_PnaclCall;
   case AttributedType::attr_inteloclbicc:
     return AttributeList::AT_IntelOclBicc;
+  case AttributedType::attr_ms_abi:
+    return AttributeList::AT_MSABI;
+  case AttributedType::attr_sysv_abi:
+    return AttributeList::AT_SysVABI;
   }
   llvm_unreachable("unexpected attribute kind!");
 }



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201310032038.r93KcvVl010208>