CC_AAPCS, // __attribute__((pcs("aapcs")))
CC_AAPCS_VFP, // __attribute__((pcs("aapcs-vfp")))
CC_PnaclCall, // __attribute__((pnaclcall))
- CC_IntelOclBicc, // __attribute__((intel_ocl_bicc))
- CC_SpirFunction, // default for OpenCL functions on SPIR target
- CC_SpirKernel // inferred for OpenCL kernels on SPIR target
+ CC_IntelOclBicc // __attribute__((intel_ocl_bicc))
};
/// \brief Checks whether the given calling convention supports variadic
case CC_X86ThisCall:
case CC_X86Pascal:
case CC_X86VectorCall:
- case CC_SpirFunction:
- case CC_SpirKernel:
return false;
default:
return true;
if (IsCXXMethod)
return ABI->getDefaultMethodCallConv(IsVariadic);
- if (LangOpts.MRTD && !IsVariadic) return CC_X86StdCall;
-
- return Target->getDefaultCallingConv(TargetInfo::CCMT_Unknown);
+ return (LangOpts.MRTD && !IsVariadic) ? CC_X86StdCall : CC_C;
}
bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const {
case CC_AAPCS_VFP: return "aapcs-vfp";
case CC_PnaclCall: return "pnaclcall";
case CC_IntelOclBicc: return "intel_ocl_bicc";
- case CC_SpirFunction: return "spir_function";
- case CC_SpirKernel: return "spir_kernel";
}
llvm_unreachable("Invalid calling convention.");
case CC_X86_64SysV:
OS << " __attribute__((sysv_abi))";
break;
- case CC_SpirFunction:
- case CC_SpirKernel:
- // Do nothing. These CCs are not available as attributes.
- break;
}
}
BuiltinVaListKind getBuiltinVaListKind() const override {
return TargetInfo::VoidPtrBuiltinVaList;
}
-
- CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
- return (CC == CC_SpirFunction ||
- CC == CC_SpirKernel) ? CCCR_OK : CCCR_Warning;
- }
-
- CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
- return CC_SpirFunction;
- }
};
case CC_X86Pascal: return llvm::CallingConv::C;
// TODO: Add support for __vectorcall to LLVM.
case CC_X86VectorCall: return llvm::CallingConv::X86_VectorCall;
- case CC_SpirFunction: return llvm::CallingConv::SPIR_FUNC;
- case CC_SpirKernel: return llvm::CallingConv::SPIR_KERNEL;
}
}
}
}
- CallingConv CC = S.Context.getDefaultCallingConvention(FTI.isVariadic,
- IsCXXInstanceMethod);
-
- // Attribute AT_OpenCLKernel affects the calling convention only on
- // the SPIR target, hence it cannot be treated as a calling
- // convention attribute. This is the simplest place to infer
- // "spir_kernel" for OpenCL kernels on SPIR.
- if (CC == CC_SpirFunction) {
- for (const AttributeList *Attr = D.getDeclSpec().getAttributes().getList();
- Attr; Attr = Attr->getNext()) {
- if (Attr->getKind() == AttributeList::AT_OpenCLKernel) {
- CC = CC_SpirKernel;
- break;
- }
- }
- }
-
- return CC;
+ return S.Context.getDefaultCallingConvention(FTI.isVariadic,
+ IsCXXInstanceMethod);
}
static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
+++ /dev/null
-// RUN: %clang_cc1 %s -triple "spir-unknown-unknown" -emit-llvm -o - | FileCheck %s
-
-int get_dummy_id(int D);
-
-kernel void bar(global int *A);
-
-kernel void foo(global int *A)
-// CHECK: define spir_kernel void @foo(i32 addrspace(1)* %A)
-{
- int id = get_dummy_id(0);
- // CHECK: %call = tail call spir_func i32 @get_dummy_id(i32 0)
- A[id] = id;
- bar(A);
- // CHECK: tail call spir_kernel void @bar(i32 addrspace(1)* %A)
-}
-
-// CHECK: declare spir_func i32 @get_dummy_id(i32)
-// CHECK: declare spir_kernel void @bar(i32 addrspace(1)*)
TCALLINGCONV(AAPCS_VFP);
TCALLINGCONV(PnaclCall);
TCALLINGCONV(IntelOclBicc);
- case CC_SpirFunction: return CXCallingConv_Unexposed;
- case CC_SpirKernel: return CXCallingConv_Unexposed;
- break;
}
#undef TCALLINGCONV
}