Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-12-03 19:32:35 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Remove support for pnaclcall attribute

Browse Source 
Summary:
It was used for interoperability with PNaCl's calling conventions, but
it's no longer needed.

Also Remove NaCl*ABIInfo which just existed to delegate to either the portable
or native ABIInfo, and remove checkCallingConvention which was now a no-op
override.

Reviewers: jvoung

Subscribers: jfb, llvm-commits

Differential Revision: http://reviews.llvm.org/D7206

llvm-svn: 227362
This commit is contained in:
Derek Schuff 2015-01-28 20:24:52 +00:00
parent fee9e20b90
commit 3970a7ec9b
15 changed files with 3 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clang/include/clang-c/Index.h
View File

@ -2854,7 +2854,7 @@ enum CXCallingConv {
CXCallingConv_X86Pascal = 5,
CXCallingConv_AAPCS = 6,
CXCallingConv_AAPCS_VFP = 7,
CXCallingConv_PnaclCall = 8,
/* Value 8 was PnaclCall, but it was never used, so it could safely be re-used. */
CXCallingConv_IntelOclBicc = 9,
CXCallingConv_X86_64Win64 = 10,
CXCallingConv_X86_64SysV = 11,

1
clang/include/clang/AST/Type.h
View File

@ -3472,7 +3472,6 @@ public:
attr_thiscall,
attr_pascal,
attr_vectorcall,
attr_pnaclcall,
attr_inteloclbicc,
attr_ms_abi,
attr_sysv_abi,

6
clang/include/clang/Basic/Attr.td
View File

@ -1141,12 +1141,6 @@ def Packed : InheritableAttr {
let Documentation = [Undocumented];
}
def PnaclCall : InheritableAttr {
let Spellings = [GNU<"pnaclcall">];
// let Subjects = [Function, ObjCMethod];
let Documentation = [Undocumented];
}
def IntelOclBicc : InheritableAttr {
let Spellings = [GNU<"intel_ocl_bicc">];
// let Subjects = [Function, ObjCMethod];

1
clang/include/clang/Basic/Specifiers.h
View File

@ -209,7 +209,6 @@ namespace clang {
CC_X86_64SysV, // __attribute__((sysv_abi))
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

2
clang/lib/AST/Type.cpp
View File

@ -1586,7 +1586,6 @@ StringRef FunctionType::getNameForCallConv(CallingConv CC) {
case CC_X86_64SysV: return "sysv_abi";
case CC_AAPCS: return "aapcs";
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";
@ -1938,7 +1937,6 @@ bool AttributedType::isCallingConv() const {
case attr_pascal:
case attr_ms_abi:
case attr_sysv_abi:
case attr_pnaclcall:
case attr_inteloclbicc:
return true;
}

4
clang/lib/AST/TypePrinter.cpp
View File

@ -685,9 +685,6 @@ void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
case CC_AAPCS_VFP:
OS << " __attribute__((pcs(\"aapcs-vfp\")))";
break;
case CC_PnaclCall:
OS << " __attribute__((pnaclcall))";
break;
case CC_IntelOclBicc:
OS << " __attribute__((intel_ocl_bicc))";
break;
@ -1257,7 +1254,6 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
OS << ')';
break;
}
case AttributedType::attr_pnaclcall: OS << "pnaclcall"; break;
case AttributedType::attr_inteloclbicc: OS << "inteloclbicc"; break;
}
OS << "))";

5
clang/lib/Basic/Targets.cpp
View File

@ -686,11 +686,6 @@ public:
this->DescriptionString = "e-p:32:32-i64:64";
}
}
typename Target::CallingConvCheckResult checkCallingConvention(
CallingConv CC) const override {
return CC == CC_PnaclCall ? Target::CCCR_OK :
Target::checkCallingConvention(CC);
}
};
} // end anonymous namespace.

3
clang/lib/CodeGen/CGCall.cpp
View File

@ -135,9 +135,6 @@ static CallingConv getCallingConventionForDecl(const Decl *D, bool IsWindows) {
if (PcsAttr *PCS = D->getAttr<PcsAttr>())
return (PCS->getPCS() == PcsAttr::AAPCS ? CC_AAPCS : CC_AAPCS_VFP);
if (D->hasAttr<PnaclCallAttr>())
return CC_PnaclCall;
if (D->hasAttr<IntelOclBiccAttr>())
return CC_IntelOclBicc;

59
clang/lib/CodeGen/TargetInfo.cpp
View File

@ -3092,23 +3092,11 @@ llvm::Value *WinX86_64ABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
namespace {
class NaClX86_64ABIInfo : public ABIInfo {
public:
NaClX86_64ABIInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX)
: ABIInfo(CGT), PInfo(CGT), NInfo(CGT, HasAVX) {}
void computeInfo(CGFunctionInfo &FI) const override;
llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
CodeGenFunction &CGF) const override;
private:
PNaClABIInfo PInfo; // Used for generating calls with pnaclcall callingconv.
X86_64ABIInfo NInfo; // Used for everything else.
};
class NaClX86_64TargetCodeGenInfo : public TargetCodeGenInfo {
bool HasAVX;
public:
NaClX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX)
: TargetCodeGenInfo(new NaClX86_64ABIInfo(CGT, HasAVX)), HasAVX(HasAVX) {
: TargetCodeGenInfo(new X86_64ABIInfo(CGT, HasAVX)), HasAVX(HasAVX) {
}
unsigned getOpenMPSimdDefaultAlignment(QualType) const override {
return HasAVX ? 32 : 16;
@ -3117,21 +3105,6 @@ class NaClX86_64TargetCodeGenInfo : public TargetCodeGenInfo {
}
void NaClX86_64ABIInfo::computeInfo(CGFunctionInfo &FI) const {
if (FI.getASTCallingConvention() == CC_PnaclCall)
PInfo.computeInfo(FI);
else
NInfo.computeInfo(FI);
}
llvm::Value *NaClX86_64ABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
CodeGenFunction &CGF) const {
// Always use the native convention; calling pnacl-style varargs functions
// is unuspported.
return NInfo.EmitVAArg(VAListAddr, Ty, CGF);
}
// PowerPC-32
namespace {
/// PPC32_SVR4_ABIInfo - The 32-bit PowerPC ELF (SVR4) ABI information.
@ -5098,39 +5071,11 @@ llvm::Value *ARMABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
}
namespace {
class NaClARMABIInfo : public ABIInfo {
public:
NaClARMABIInfo(CodeGen::CodeGenTypes &CGT, ARMABIInfo::ABIKind Kind)
: ABIInfo(CGT), PInfo(CGT), NInfo(CGT, Kind) {}
void computeInfo(CGFunctionInfo &FI) const override;
llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
CodeGenFunction &CGF) const override;
private:
PNaClABIInfo PInfo; // Used for generating calls with pnaclcall callingconv.
ARMABIInfo NInfo; // Used for everything else.
};
class NaClARMTargetCodeGenInfo : public TargetCodeGenInfo {
public:
NaClARMTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, ARMABIInfo::ABIKind Kind)
: TargetCodeGenInfo(new NaClARMABIInfo(CGT, Kind)) {}
: TargetCodeGenInfo(new ARMABIInfo(CGT, Kind)) {}
};
}
void NaClARMABIInfo::computeInfo(CGFunctionInfo &FI) const {
if (FI.getASTCallingConvention() == CC_PnaclCall)
PInfo.computeInfo(FI);
else
static_cast<const ABIInfo&>(NInfo).computeInfo(FI);
}
llvm::Value *NaClARMABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
CodeGenFunction &CGF) const {
// Always use the native convention; calling pnacl-style varargs functions
// is unsupported.
return static_cast<const ABIInfo&>(NInfo).EmitVAArg(VAListAddr, Ty, CGF);
}
//===----------------------------------------------------------------------===//

7
clang/lib/Sema/SemaDeclAttr.cpp
View File

@ -3331,11 +3331,6 @@ static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Attr.getAttributeSpellingListIndex()));
return;
}
case AttributeList::AT_PnaclCall:
D->addAttr(::new (S.Context)
PnaclCallAttr(Attr.getRange(), S.Context,
Attr.getAttributeSpellingListIndex()));
return;
case AttributeList::AT_IntelOclBicc:
D->addAttr(::new (S.Context)
IntelOclBiccAttr(Attr.getRange(), S.Context,
@ -3392,7 +3387,6 @@ bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
Diag(attr.getLoc(), diag::err_invalid_pcs);
return true;
}
case AttributeList::AT_PnaclCall: CC = CC_PnaclCall; break;
case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
default: llvm_unreachable("unexpected attribute kind");
}
@ -4668,7 +4662,6 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
case AttributeList::AT_MSABI:
case AttributeList::AT_SysVABI:
case AttributeList::AT_Pcs:
case AttributeList::AT_PnaclCall:
case AttributeList::AT_IntelOclBicc:
handleCallConvAttr(S, D, Attr);
break;

5
clang/lib/Sema/SemaType.cpp
View File

@ -112,7 +112,6 @@ static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr,
case AttributeList::AT_SysVABI: \
case AttributeList::AT_Regparm: \
case AttributeList::AT_Pcs: \
case AttributeList::AT_PnaclCall: \
case AttributeList::AT_IntelOclBicc
// Microsoft-specific type qualifiers.
@ -3448,8 +3447,6 @@ static AttributeList::Kind getAttrListKind(AttributedType::Kind kind) {
case AttributedType::attr_pcs:
case AttributedType::attr_pcs_vfp:
return AttributeList::AT_Pcs;
case AttributedType::attr_pnaclcall:
return AttributeList::AT_PnaclCall;
case AttributedType::attr_inteloclbicc:
return AttributeList::AT_IntelOclBicc;
case AttributedType::attr_ms_abi:
@ -4478,8 +4475,6 @@ static AttributedType::Kind getCCTypeAttrKind(AttributeList &Attr) {
.Case("aapcs", AttributedType::attr_pcs)
.Case("aapcs-vfp", AttributedType::attr_pcs_vfp);
}
case AttributeList::AT_PnaclCall:
return AttributedType::attr_pnaclcall;
case AttributeList::AT_IntelOclBicc:
return AttributedType::attr_inteloclbicc;
case AttributeList::AT_MSABI:

33
clang/test/CodeGen/arm-pnaclcall.c
View File

@ -1,33 +0,0 @@
// RUN: %clang_cc1 -triple armv7-unknown-nacl-gnueabi \
// RUN: -ffreestanding -mfloat-abi hard -target-cpu cortex-a8 \
// RUN: -emit-llvm -w -o - %s | FileCheck %s
// Test that functions with pnaclcall attribute generate portable bitcode
// like the le32 arch target
typedef struct {
int a;
int b;
} s1;
// CHECK-LABEL: define i32 @f48(%struct.s1* byval %s)
int __attribute__((pnaclcall)) f48(s1 s) { return s.a; }
// CHECK-LABEL: define void @f49(%struct.s1* noalias sret %agg.result)
s1 __attribute__((pnaclcall)) f49() { s1 s; s.a = s.b = 1; return s; }
union simple_union {
int a;
char b;
};
// Unions should be passed as byval structs
// CHECK-LABEL: define void @f50(%union.simple_union* byval %s)
void __attribute__((pnaclcall)) f50(union simple_union s) {}
typedef struct {
int b4 : 4;
int b3 : 3;
int b8 : 8;
} bitfield1;
// Bitfields should be passed as byval structs
// CHECK-LABEL: define void @f51(%struct.bitfield1* byval %bf1)
void __attribute__((pnaclcall)) f51(bitfield1 bf1) {}

28
clang/test/CodeGen/x86_64-arguments-nacl.c
View File

@ -90,31 +90,3 @@ void f9122143()
{
func(ss);
}
typedef struct {
int a;
int b;
} s1;
// CHECK-LABEL: define i32 @f48(%struct.s1* byval %s)
int __attribute__((pnaclcall)) f48(s1 s) { return s.a; }
// CHECK-LABEL: define void @f49(%struct.s1* noalias sret %agg.result)
s1 __attribute__((pnaclcall)) f49() { s1 s; s.a = s.b = 1; return s; }
union simple_union {
int a;
char b;
};
// Unions should be passed as byval structs
// CHECK-LABEL: define void @f50(%union.simple_union* byval %s)
void __attribute__((pnaclcall)) f50(union simple_union s) {}
typedef struct {
int b4 : 4;
int b3 : 3;
int b8 : 8;
} bitfield1;
// Bitfields should be passed as byval structs
// CHECK-LABEL: define void @f51(%struct.bitfield1* byval %bf1)
void __attribute__((pnaclcall)) f51(bitfield1 bf1) {}

2
clang/test/Sema/callingconv.c
View File

@ -59,8 +59,6 @@ void __attribute__((cdecl)) ctest3() {}
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) {}
typedef void typedef_fun_t(int);

1
clang/tools/libclang/CXType.cpp
View File

@ -525,7 +525,6 @@ CXCallingConv clang_getFunctionTypeCallingConv(CXType X) {
TCALLINGCONV(X86_64SysV);
TCALLINGCONV(AAPCS);
TCALLINGCONV(AAPCS_VFP);
TCALLINGCONV(PnaclCall);
TCALLINGCONV(IntelOclBicc);
case CC_SpirFunction: return CXCallingConv_Unexposed;
case CC_SpirKernel: return CXCallingConv_Unexposed;