/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Basic/Targets/SystemZ.h
Line | Count | Source (jump to first uncovered line) |
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 | | bool SoftFloat; |
33 | | |
34 | | public: |
35 | | SystemZTargetInfo(const llvm::Triple &Triple, const TargetOptions &) |
36 | | : TargetInfo(Triple), CPU("z10"), ISARevision(8), |
37 | 92 | HasTransactionalExecution(false), HasVector(false), SoftFloat(false) { |
38 | 92 | IntMaxType = SignedLong; |
39 | 92 | Int64Type = SignedLong; |
40 | 92 | TLSSupported = true; |
41 | 92 | IntWidth = IntAlign = 32; |
42 | 92 | LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64; |
43 | 92 | PointerWidth = PointerAlign = 64; |
44 | 92 | LongDoubleWidth = 128; |
45 | 92 | LongDoubleAlign = 64; |
46 | 92 | LongDoubleFormat = &llvm::APFloat::IEEEquad(); |
47 | 92 | DefaultAlignForAttributeAligned = 64; |
48 | 92 | MinGlobalAlign = 16; |
49 | 92 | if (Triple.isOSzOS()) { |
50 | | // All vector types are default aligned on an 8-byte boundary, even if the |
51 | | // vector facility is not available. That is different from Linux. |
52 | 28 | MaxVectorAlign = 64; |
53 | | // Compared to Linux/ELF, the data layout differs only in some details: |
54 | | // - name mangling is GOFF |
55 | | // - 128 bit vector types are 64 bit aligned |
56 | 28 | resetDataLayout( |
57 | 28 | "E-m:l-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"); |
58 | 28 | } else |
59 | 64 | resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64"); |
60 | 92 | MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; |
61 | 92 | HasStrictFP = true; |
62 | 92 | } clang::targets::SystemZTargetInfo::SystemZTargetInfo(llvm::Triple const&, clang::TargetOptions const&) Line | Count | Source | 37 | 13 | HasTransactionalExecution(false), HasVector(false), SoftFloat(false) { | 38 | 13 | IntMaxType = SignedLong; | 39 | 13 | Int64Type = SignedLong; | 40 | 13 | TLSSupported = true; | 41 | 13 | IntWidth = IntAlign = 32; | 42 | 13 | LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64; | 43 | 13 | PointerWidth = PointerAlign = 64; | 44 | 13 | LongDoubleWidth = 128; | 45 | 13 | LongDoubleAlign = 64; | 46 | 13 | LongDoubleFormat = &llvm::APFloat::IEEEquad(); | 47 | 13 | DefaultAlignForAttributeAligned = 64; | 48 | 13 | MinGlobalAlign = 16; | 49 | 13 | if (Triple.isOSzOS()) { | 50 | | // All vector types are default aligned on an 8-byte boundary, even if the | 51 | | // vector facility is not available. That is different from Linux. | 52 | 0 | MaxVectorAlign = 64; | 53 | | // Compared to Linux/ELF, the data layout differs only in some details: | 54 | | // - name mangling is GOFF | 55 | | // - 128 bit vector types are 64 bit aligned | 56 | 0 | resetDataLayout( | 57 | 0 | "E-m:l-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"); | 58 | 0 | } else | 59 | 13 | resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64"); | 60 | 13 | MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; | 61 | 13 | HasStrictFP = true; | 62 | 13 | } |
clang::targets::SystemZTargetInfo::SystemZTargetInfo(llvm::Triple const&, clang::TargetOptions const&) Line | Count | Source | 37 | 79 | HasTransactionalExecution(false), HasVector(false), SoftFloat(false) { | 38 | 79 | IntMaxType = SignedLong; | 39 | 79 | Int64Type = SignedLong; | 40 | 79 | TLSSupported = true; | 41 | 79 | IntWidth = IntAlign = 32; | 42 | 79 | LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64; | 43 | 79 | PointerWidth = PointerAlign = 64; | 44 | 79 | LongDoubleWidth = 128; | 45 | 79 | LongDoubleAlign = 64; | 46 | 79 | LongDoubleFormat = &llvm::APFloat::IEEEquad(); | 47 | 79 | DefaultAlignForAttributeAligned = 64; | 48 | 79 | MinGlobalAlign = 16; | 49 | 79 | if (Triple.isOSzOS()) { | 50 | | // All vector types are default aligned on an 8-byte boundary, even if the | 51 | | // vector facility is not available. That is different from Linux. | 52 | 28 | MaxVectorAlign = 64; | 53 | | // Compared to Linux/ELF, the data layout differs only in some details: | 54 | | // - name mangling is GOFF | 55 | | // - 128 bit vector types are 64 bit aligned | 56 | 28 | resetDataLayout( | 57 | 28 | "E-m:l-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"); | 58 | 28 | } else | 59 | 51 | resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64"); | 60 | 79 | MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64; | 61 | 79 | HasStrictFP = true; | 62 | 79 | } |
|
63 | | |
64 | | void getTargetDefines(const LangOptions &Opts, |
65 | | MacroBuilder &Builder) const override; |
66 | | |
67 | | ArrayRef<Builtin::Info> getTargetBuiltins() const override; |
68 | | |
69 | | ArrayRef<const char *> getGCCRegNames() const override; |
70 | | |
71 | 8 | ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override { |
72 | | // No aliases. |
73 | 8 | return None; |
74 | 8 | } |
75 | | |
76 | | ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override; |
77 | | |
78 | 1 | bool isSPRegName(StringRef RegName) const override { |
79 | 1 | return RegName.equals("r15"); |
80 | 1 | } |
81 | | |
82 | | bool validateAsmConstraint(const char *&Name, |
83 | | TargetInfo::ConstraintInfo &info) const override; |
84 | | |
85 | 169 | std::string convertConstraint(const char *&Constraint) const override { |
86 | 169 | switch (Constraint[0]) { |
87 | 2 | case 'p': // Keep 'p' constraint. |
88 | 2 | return std::string("p"); |
89 | 0 | case 'Z': |
90 | 0 | switch (Constraint[1]) { |
91 | 0 | case 'Q': // Address with base and unsigned 12-bit displacement |
92 | 0 | case 'R': // Likewise, plus an index |
93 | 0 | case 'S': // Address with base and signed 20-bit displacement |
94 | 0 | case 'T': // Likewise, plus an index |
95 | | // "^" hints llvm that this is a 2 letter constraint. |
96 | | // "Constraint++" is used to promote the string iterator |
97 | | // to the next constraint. |
98 | 0 | return std::string("^") + std::string(Constraint++, 2); |
99 | 0 | default: |
100 | 0 | break; |
101 | 0 | } |
102 | 0 | break; |
103 | 167 | default: |
104 | 167 | break; |
105 | 169 | } |
106 | 167 | return TargetInfo::convertConstraint(Constraint); |
107 | 169 | } |
108 | | |
109 | 61 | const char *getClobbers() const override { |
110 | | // FIXME: Is this really right? |
111 | 61 | return ""; |
112 | 61 | } |
113 | | |
114 | 83 | BuiltinVaListKind getBuiltinVaListKind() const override { |
115 | 83 | return TargetInfo::SystemZBuiltinVaList; |
116 | 83 | } |
117 | | |
118 | | int getISARevision(StringRef Name) const; |
119 | | |
120 | 0 | bool isValidCPUName(StringRef Name) const override { |
121 | 0 | return getISARevision(Name) != -1; |
122 | 0 | } |
123 | | |
124 | | void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override; |
125 | | |
126 | 44 | bool setCPU(const std::string &Name) override { |
127 | 44 | CPU = Name; |
128 | 44 | ISARevision = getISARevision(CPU); |
129 | 44 | return ISARevision != -1; |
130 | 44 | } |
131 | | |
132 | | bool |
133 | | initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, |
134 | | StringRef CPU, |
135 | 90 | const std::vector<std::string> &FeaturesVec) const override { |
136 | 90 | int ISARevision = getISARevision(CPU); |
137 | 90 | if (ISARevision >= 10) |
138 | 28 | Features["transactional-execution"] = true; |
139 | 90 | if (ISARevision >= 11) |
140 | 28 | Features["vector"] = true; |
141 | 90 | if (ISARevision >= 12) |
142 | 16 | Features["vector-enhancements-1"] = true; |
143 | 90 | if (ISARevision >= 13) |
144 | 10 | Features["vector-enhancements-2"] = true; |
145 | 90 | if (ISARevision >= 14) |
146 | 5 | Features["nnp-assist"] = true; |
147 | 90 | return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec); |
148 | 90 | } |
149 | | |
150 | | bool handleTargetFeatures(std::vector<std::string> &Features, |
151 | 90 | DiagnosticsEngine &Diags) override { |
152 | 90 | HasTransactionalExecution = false; |
153 | 90 | HasVector = false; |
154 | 90 | SoftFloat = false; |
155 | 91 | for (const auto &Feature : Features) { |
156 | 91 | if (Feature == "+transactional-execution") |
157 | 28 | HasTransactionalExecution = true; |
158 | 63 | else if (Feature == "+vector") |
159 | 30 | HasVector = true; |
160 | 33 | else if (Feature == "+soft-float") |
161 | 2 | SoftFloat = true; |
162 | 91 | } |
163 | 90 | HasVector &= !SoftFloat; |
164 | | |
165 | | // If we use the vector ABI, vector types are 64-bit aligned. |
166 | 90 | if (HasVector && !getTriple().isOSzOS()28 ) { |
167 | 26 | MaxVectorAlign = 64; |
168 | 26 | resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64" |
169 | 26 | "-v128:64-a:8:16-n32:64"); |
170 | 26 | } |
171 | 90 | return true; |
172 | 90 | } |
173 | | |
174 | | bool hasFeature(StringRef Feature) const override; |
175 | | |
176 | 6 | CallingConvCheckResult checkCallingConvention(CallingConv CC) const override { |
177 | 6 | switch (CC) { |
178 | 0 | case CC_C: |
179 | 0 | case CC_Swift: |
180 | 0 | case CC_OpenCLKernel: |
181 | 0 | return CCCR_OK; |
182 | 6 | case CC_SwiftAsync: |
183 | 6 | return CCCR_Error; |
184 | 0 | default: |
185 | 0 | return CCCR_Warning; |
186 | 6 | } |
187 | 6 | } |
188 | | |
189 | 474 | StringRef getABI() const override { |
190 | 474 | if (HasVector) |
191 | 345 | return "vector"; |
192 | 129 | return ""; |
193 | 474 | } |
194 | | |
195 | 1 | const char *getLongDoubleMangling() const override { return "g"; } |
196 | | |
197 | 10 | bool hasBitIntType() const override { return true; } |
198 | | |
199 | 0 | int getEHDataRegisterNumber(unsigned RegNo) const override { |
200 | 0 | return RegNo < 4 ? 6 + RegNo : -1; |
201 | 0 | } |
202 | | }; |
203 | | } // namespace targets |
204 | | } // namespace clang |
205 | | #endif // LLVM_CLANG_LIB_BASIC_TARGETS_SYSTEMZ_H |