SystemZ.h source code [clang_source_code/lib/Basic/Targets/SystemZ.h]

1	//===--- SystemZ.h - Declare SystemZ target feature support ------ C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file declares SystemZ TargetInfo objects.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_SYSTEMZ_H
14	#define LLVM_CLANG_LIB_BASIC_TARGETS_SYSTEMZ_H
15
16	#include "clang/Basic/TargetInfo.h"
17	#include "clang/Basic/TargetOptions.h"
18	#include "llvm/ADT/Triple.h"
19	#include "llvm/Support/Compiler.h"
20
21	namespace clang {
22	namespace targets {
23
24	class LLVM_LIBRARY_VISIBILITY SystemZTargetInfo : public TargetInfo {
25
26	static const Builtin::Info BuiltinInfo[];
27	static const char *const GCCRegNames[];
28	std::string CPU;
29	int ISARevision;
30	bool HasTransactionalExecution;
31	bool HasVector;
32
33	public:
34	SystemZTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
35	: TargetInfo(Triple), CPU("z10"), ISARevision(8),
36	HasTransactionalExecution(false), HasVector(false) {
37	IntMaxType = SignedLong;
38	Int64Type = SignedLong;
39	TLSSupported = true;
40	IntWidth = IntAlign = 32;
41	LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
42	PointerWidth = PointerAlign = 64;
43	LongDoubleWidth = 128;
44	LongDoubleAlign = 64;
45	LongDoubleFormat = &llvm::APFloat::IEEEquad();
46	DefaultAlignForAttributeAligned = 64;
47	MinGlobalAlign = 16;
48	resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64");
49	MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
50	}
51
52	void getTargetDefines(const LangOptions &Opts,
53	MacroBuilder &Builder) const override;
54
55	ArrayRef<Builtin::Info> getTargetBuiltins() const override;
56
57	ArrayRef<const char *> getGCCRegNames() const override;
58
59	ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
60	// No aliases.
61	return None;
62	}
63
64	ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override;
65
66	bool validateAsmConstraint(const char *&Name,
67	TargetInfo::ConstraintInfo &info) const override;
68
69	const char *getClobbers() const override {
70	// FIXME: Is this really right?
71	return "";
72	}
73
74	BuiltinVaListKind getBuiltinVaListKind() const override {
75	return TargetInfo::SystemZBuiltinVaList;
76	}
77
78	int getISARevision(StringRef Name) const;
79
80	bool isValidCPUName(StringRef Name) const override {
81	return getISARevision(Name) != -1;
82	}
83
84	void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
85
86	bool setCPU(const std::string &Name) override {
87	CPU = Name;
88	ISARevision = getISARevision(CPU);
89	return ISARevision != -1;
90	}
91
92	bool
93	initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
94	StringRef CPU,
95	const std::vector<std::string> &FeaturesVec) const override {
96	int ISARevision = getISARevision(CPU);
97	if (ISARevision >= 10)
98	Features["transactional-execution"] = true;
99	if (ISARevision >= 11)
100	Features["vector"] = true;
101	if (ISARevision >= 12)
102	Features["vector-enhancements-1"] = true;
103	return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
104	}
105
106	bool handleTargetFeatures(std::vector<std::string> &Features,
107	DiagnosticsEngine &Diags) override {
108	HasTransactionalExecution = false;
109	HasVector = false;
110	for (const auto &Feature : Features) {
111	if (Feature == "+transactional-execution")
112	HasTransactionalExecution = true;
113	else if (Feature == "+vector")
114	HasVector = true;
115	}
116	// If we use the vector ABI, vector types are 64-bit aligned.
117	if (HasVector) {
118	MaxVectorAlign = 64;
119	resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64"
120	"-v128:64-a:8:16-n32:64");
121	}
122	return true;
123	}
124
125	bool hasFeature(StringRef Feature) const override;
126
127	CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
128	switch (CC) {
129	case CC_C:
130	case CC_Swift:
131	case CC_OpenCLKernel:
132	return CCCR_OK;
133	default:
134	return CCCR_Warning;
135	}
136	}
137
138	StringRef getABI() const override {
139	if (HasVector)
140	return "vector";
141	return "";
142	}
143
144	bool useFloat128ManglingForLongDouble() const override { return true; }
145	};
146	} // namespace targets
147	} // namespace clang
148	#endif // LLVM_CLANG_LIB_BASIC_TARGETS_SYSTEMZ_H
149

Clang Project