Add intel_ocl_bicc calling convention as a function attribute to clang. The calling...

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@171056 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang-c/Index.h b/include/clang-c/Index.h
index ea84de6d79f7982e616bf27162eb0b224a967ec0..94c896ec6e2c39508ef4f99c04d655cb3721262b 100644 (file)
--- a/include/clang-c/Index.h
+++ b/include/clang-c/Index.h
@@ -2626,6 +2626,7 @@ enum CXCallingConv {
   CXCallingConv_AAPCS = 6,
   CXCallingConv_AAPCS_VFP = 7,
   CXCallingConv_PnaclCall = 8,
+  CXCallingConv_IntelOclBicc = 9,
 
   CXCallingConv_Invalid = 100,
   CXCallingConv_Unexposed = 200

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 7277f0fc68c6aff0b26ee0ca62a7fc15d2374c25..70f61cb04101d09e1041275ab8f2b9add18c6bef 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -3330,7 +3330,8 @@ public:
     attr_stdcall,
     attr_thiscall,
     attr_pascal,
-    attr_pnaclcall
+    attr_pnaclcall,
+    attr_inteloclbicc
   };
 
 private:

diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td
index 7b7dc48a38ff2865a57beec7993df95ee6cad194..858df3ae214abc224dce2e4784d05c53d9304623 100644 (file)
--- a/include/clang/Basic/Attr.td
+++ b/include/clang/Basic/Attr.td
@@ -565,6 +565,10 @@ def PnaclCall : InheritableAttr {
   let Spellings = [GNU<"pnaclcall">];
 }
 
+def IntelOclBicc : InheritableAttr {
+  let Spellings = [GNU<"intel_ocl_bicc">];
+}
+
 def Pcs : InheritableAttr {
   let Spellings = [GNU<"pcs">];
   let Args = [EnumArgument<"PCS", "PCSType",

diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h
index fedb3214649977a9f747fbaae00f6bcc7b14878b..321048f98585b256f2ece14610e574476d88c368 100644 (file)
--- a/include/clang/Basic/Specifiers.h
+++ b/include/clang/Basic/Specifiers.h
@@ -192,7 +192,8 @@ namespace clang {
     CC_X86Pascal,   // __attribute__((pascal))
     CC_AAPCS,       // __attribute__((pcs("aapcs")))
     CC_AAPCS_VFP,   // __attribute__((pcs("aapcs-vfp")))
-    CC_PnaclCall    // __attribute__((pnaclcall))
+    CC_PnaclCall,   // __attribute__((pnaclcall))
+    CC_IntelOclBicc // __attribute__((intel_ocl_bicc))
   };
 
 } // end namespace clang

diff --git a/lib/AST/DumpXML.cpp b/lib/AST/DumpXML.cpp
index f2483f4296ff36fde1cd494a91381ee961c89627..ce4e21f90b467f17bd52a2d796ccdcfc56626de4 100644 (file)
--- a/lib/AST/DumpXML.cpp
+++ b/lib/AST/DumpXML.cpp
@@ -922,6 +922,7 @@ struct XMLDumper : public XMLDeclVisitor<XMLDumper>,
     case CC_AAPCS: return set("cc", "aapcs");
     case CC_AAPCS_VFP: return set("cc", "aapcs_vfp");
     case CC_PnaclCall: return set("cc", "pnaclcall");
+    case CC_IntelOclBicc: return set("cc", "intel_ocl_bicc");
     }
   }
 

diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 673528ada0f5f8a28a1004ca34ee7114a43e8790..2f91cd85513b64d85319932b50e3901a0a78c4f3 100644 (file)
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -1552,6 +1552,7 @@ StringRef FunctionType::getNameForCallConv(CallingConv CC) {
   case CC_AAPCS: return "aapcs";
   case CC_AAPCS_VFP: return "aapcs-vfp";
   case CC_PnaclCall: return "pnaclcall";
+  case CC_IntelOclBicc: return "intel_ocl_bicc";
   }
 
   llvm_unreachable("Invalid calling convention.");

diff --git a/lib/AST/TypePrinter.cpp b/lib/AST/TypePrinter.cpp
index 83ffec4cda7a702802816b4c4f1155c87380858b..9feaf5721eecb5af7e252a9c36d8522e5ede23cd 100644 (file)
--- a/lib/AST/TypePrinter.cpp
+++ b/lib/AST/TypePrinter.cpp
@@ -647,6 +647,9 @@ void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
   case CC_PnaclCall:
     OS << " __attribute__((pnaclcall))";
     break;
+  case CC_IntelOclBicc:
+    OS << " __attribute__((intel_ocl_bicc))";
+    break;
   }
   if (Info.getNoReturn())
     OS << " __attribute__((noreturn))";
@@ -1168,6 +1171,7 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
    break;
   }
   case AttributedType::attr_pnaclcall: OS << "pnaclcall"; break;
+  case AttributedType::attr_inteloclbicc: OS << "inteloclbicc"; break;
   }
   OS << "))";
 }

diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp
index 5f7f75d440438d16f2726ce4cc2a20e5b6472366..ea19b15848e2283dcd6d8a27c0f20baa5417310d 100644 (file)
--- a/lib/Basic/Targets.cpp
+++ b/lib/Basic/Targets.cpp
@@ -1803,7 +1803,8 @@ public:
             CC == CC_X86FastCall ||
             CC == CC_X86StdCall || 
             CC == CC_C || 
-            CC == CC_X86Pascal) ? CCCR_OK : CCCR_Warning;
+            CC == CC_X86Pascal ||
+            CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
   }
 
   virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {

diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp
index 31cff910a212826277d906e14d4e33ced34a42ee..cdac2fc7620ea88fb3812ece686ca3ea4389ed02 100644 (file)
--- a/lib/CodeGen/CGCall.cpp
+++ b/lib/CodeGen/CGCall.cpp
@@ -41,6 +41,7 @@ static unsigned ClangCallConvToLLVMCallConv(CallingConv CC) {
   case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
   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;
   // TODO: add support for CC_X86Pascal to llvm
   }
 }
@@ -151,6 +152,9 @@ static CallingConv getCallingConventionForDecl(const Decl *D) {
   if (D->hasAttr<PnaclCallAttr>())
     return CC_PnaclCall;
 
+  if (D->hasAttr<IntelOclBiccAttr>())
+    return CC_IntelOclBicc;
+
   return CC_C;
 }
 

diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
index 437e2a826beb919dbfe2ae6c2f2dcbfe494b1a21..cf3335316e0b85c2c17b78ad134e05d1a3374c48 100644 (file)
--- a/lib/Sema/SemaDeclAttr.cpp
+++ b/lib/Sema/SemaDeclAttr.cpp
@@ -3613,6 +3613,9 @@ static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
   case AttributeList::AT_PnaclCall:
     D->addAttr(::new (S.Context) PnaclCallAttr(Attr.getRange(), S.Context));
     return;
+  case AttributeList::AT_IntelOclBicc:
+    D->addAttr(::new (S.Context) IntelOclBiccAttr(Attr.getRange(), S.Context));
+    return;
 
   default:
     llvm_unreachable("unexpected attribute kind");
@@ -3668,6 +3671,7 @@ bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
     return true;
   }
   case AttributeList::AT_PnaclCall: CC = CC_PnaclCall; break;
+  case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
   default: llvm_unreachable("unexpected attribute kind");
   }
 
@@ -4440,6 +4444,7 @@ static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
   case AttributeList::AT_Pascal:
   case AttributeList::AT_Pcs:
   case AttributeList::AT_PnaclCall:
+  case AttributeList::AT_IntelOclBicc:
     handleCallConvAttr(S, D, Attr);
     break;
   case AttributeList::AT_OpenCLKernel:

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 1afc8c7f25b52db21b3f9f2bb058ade3f6280f0b..bbd8a7e93563e61eb92ae9d2b98b4177438e0d7f 100644 (file)
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -106,7 +106,8 @@ static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr,
     case AttributeList::AT_Pascal: \
     case AttributeList::AT_Regparm: \
     case AttributeList::AT_Pcs: \
-    case AttributeList::AT_PnaclCall \
+    case AttributeList::AT_PnaclCall: \
+    case AttributeList::AT_IntelOclBicc \
 
 namespace {
   /// An object which stores processing state for the entire
@@ -3032,6 +3033,8 @@ static AttributeList::Kind getAttrListKind(AttributedType::Kind kind) {
     return AttributeList::AT_Pcs;
   case AttributedType::attr_pnaclcall:
     return AttributeList::AT_PnaclCall;
+  case AttributedType::attr_inteloclbicc:
+    return AttributeList::AT_IntelOclBicc;
   }
   llvm_unreachable("unexpected attribute kind!");
 }

diff --git a/test/CodeGen/intel_ocl_bicc.c b/test/CodeGen/intel_ocl_bicc.c
new file mode 100644 (file)
index 0000000..2f5c58c
--- /dev/null
+++ b/test/CodeGen/intel_ocl_bicc.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
+void __attribute__((intel_ocl_bicc)) f1(void);
+
+void f2(void) {
+  f1();
+// CHECK: call intel_ocl_bicc void @f1()
+}
+
+// CHECK: declare intel_ocl_bicc void @f1()

diff --git a/test/Sema/callingconv.c b/test/Sema/callingconv.c
index 266242d4a3a9a725498e20d24c391ba3ded3b9c6..4c0d4b1bb1ca08fbced43022638e799728726a7f 100644 (file)
--- a/test/Sema/callingconv.c
+++ b/test/Sema/callingconv.c
@@ -54,3 +54,5 @@ typedef __attribute__((stdcall)) void (*PROC)();
 PROC __attribute__((cdecl)) ctest4(const char *x) {}
 
 void __attribute__((pnaclcall)) pnaclfunc(float *a) {} // expected-warning {{calling convention 'pnaclcall' ignored for this target}}
+
+void __attribute__((intel_ocl_bicc)) inteloclbifunc(float *a) {}

diff --git a/tools/libclang/CXType.cpp b/tools/libclang/CXType.cpp
index e2fbc0be82ecc56cf7f0a8995f7025e6ec1f5c3a..25ea2853d3fdb5beaaeb526621e496f1ee46a4c3 100644 (file)
--- a/tools/libclang/CXType.cpp
+++ b/tools/libclang/CXType.cpp
@@ -480,6 +480,7 @@ CXCallingConv clang_getFunctionTypeCallingConv(CXType X) {
       TCALLINGCONV(AAPCS);
       TCALLINGCONV(AAPCS_VFP);
       TCALLINGCONV(PnaclCall);
+      TCALLINGCONV(IntelOclBicc);
     }
 #undef TCALLINGCONV
   }