clang 19.0.0git
Sparc.h
Go to the documentation of this file.
1//===--- Sparc.h - declare sparc 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 Sparc TargetInfo objects.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_SPARC_H
14#define LLVM_CLANG_LIB_BASIC_TARGETS_SPARC_H
17#include "llvm/Support/Compiler.h"
18#include "llvm/TargetParser/Triple.h"
19namespace clang {
20namespace targets {
21// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
22class LLVM_LIBRARY_VISIBILITY SparcTargetInfo : public TargetInfo {
23 static const TargetInfo::GCCRegAlias GCCRegAliases[];
24 static const char *const GCCRegNames[];
25 bool SoftFloat;
26
27public:
28 SparcTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
29 : TargetInfo(Triple), SoftFloat(false) {}
30
31 int getEHDataRegisterNumber(unsigned RegNo) const override {
32 if (RegNo == 0)
33 return 24;
34 if (RegNo == 1)
35 return 25;
36 return -1;
37 }
38
39 bool handleTargetFeatures(std::vector<std::string> &Features,
40 DiagnosticsEngine &Diags) override {
41 // Check if software floating point is enabled
42 if (llvm::is_contained(Features, "+soft-float"))
43 SoftFloat = true;
44 return true;
45 }
46 void getTargetDefines(const LangOptions &Opts,
47 MacroBuilder &Builder) const override;
48
49 bool hasFeature(StringRef Feature) const override;
50
52 // FIXME: Implement!
53 return std::nullopt;
54 }
56 return TargetInfo::VoidPtrBuiltinVaList;
57 }
58 ArrayRef<const char *> getGCCRegNames() const override;
59 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
60 bool validateAsmConstraint(const char *&Name,
61 TargetInfo::ConstraintInfo &info) const override {
62 // FIXME: Implement!
63 switch (*Name) {
64 case 'I': // Signed 13-bit constant
65 case 'J': // Zero
66 case 'K': // 32-bit constant with the low 12 bits clear
67 case 'L': // A constant in the range supported by movcc (11-bit signed imm)
68 case 'M': // A constant in the range supported by movrcc (19-bit signed imm)
69 case 'N': // Same as 'K' but zext (required for SIMode)
70 case 'O': // The constant 4096
71 return true;
72
73 case 'f':
74 case 'e':
75 info.setAllowsRegister();
76 return true;
77 }
78 return false;
79 }
80 std::string_view getClobbers() const override {
81 // FIXME: Implement!
82 return "";
83 }
84
85 // No Sparc V7 for now, the backend doesn't support it anyway.
86 enum CPUKind {
121 CK_LEON4_GR740
122 } CPU = CK_GENERIC;
123
127 };
128
129 CPUGeneration getCPUGeneration(CPUKind Kind) const;
130
131 CPUKind getCPUKind(StringRef Name) const;
132
133 bool isValidCPUName(StringRef Name) const override {
134 return getCPUKind(Name) != CK_GENERIC;
135 }
136
137 void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
138
139 bool setCPU(const std::string &Name) override {
140 CPU = getCPUKind(Name);
141 return CPU != CK_GENERIC;
142 }
143
144 std::pair<unsigned, unsigned> hardwareInterferenceSizes() const override {
145 return std::make_pair(32, 32);
146 }
147};
148
149// SPARC v8 is the 32-bit mode selected by Triple::sparc.
150class LLVM_LIBRARY_VISIBILITY SparcV8TargetInfo : public SparcTargetInfo {
151public:
152 SparcV8TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
153 : SparcTargetInfo(Triple, Opts) {
154 resetDataLayout("E-m:e-p:32:32-i64:64-f128:64-n32-S64");
155 // NetBSD / OpenBSD use long (same as llvm default); everyone else uses int.
156 switch (getTriple().getOS()) {
157 default:
158 SizeType = UnsignedInt;
159 IntPtrType = SignedInt;
160 PtrDiffType = SignedInt;
161 break;
162 case llvm::Triple::NetBSD:
163 case llvm::Triple::OpenBSD:
164 SizeType = UnsignedLong;
165 IntPtrType = SignedLong;
166 PtrDiffType = SignedLong;
167 break;
168 }
169 // Up to 32 bits (V8) or 64 bits (V9) are lock-free atomic, but we're
170 // willing to do atomic ops on up to 64 bits.
171 MaxAtomicPromoteWidth = 64;
172 if (getCPUGeneration(CPU) == CG_V9)
173 MaxAtomicInlineWidth = 64;
174 else
175 // FIXME: This isn't correct for plain V8 which lacks CAS,
176 // only for LEON 3+ and Myriad.
177 MaxAtomicInlineWidth = 32;
178 }
179
180 void getTargetDefines(const LangOptions &Opts,
181 MacroBuilder &Builder) const override;
182
183 bool hasBitIntType() const override { return true; }
184};
185
186// SPARCV8el is the 32-bit little-endian mode selected by Triple::sparcel.
187class LLVM_LIBRARY_VISIBILITY SparcV8elTargetInfo : public SparcV8TargetInfo {
188public:
189 SparcV8elTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
190 : SparcV8TargetInfo(Triple, Opts) {
191 resetDataLayout("e-m:e-p:32:32-i64:64-f128:64-n32-S64");
192 }
193};
194
195// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
196class LLVM_LIBRARY_VISIBILITY SparcV9TargetInfo : public SparcTargetInfo {
197public:
198 SparcV9TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
199 : SparcTargetInfo(Triple, Opts) {
200 // FIXME: Support Sparc quad-precision long double?
201 resetDataLayout("E-m:e-i64:64-n32:64-S128");
202 // This is an LP64 platform.
203 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
204
205 // OpenBSD uses long long for int64_t and intmax_t.
206 if (getTriple().isOSOpenBSD())
207 IntMaxType = SignedLongLong;
208 else
209 IntMaxType = SignedLong;
210 Int64Type = IntMaxType;
211
212 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
213 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
214 LongDoubleWidth = 128;
215 LongDoubleAlign = 128;
216 SuitableAlign = 128;
217 LongDoubleFormat = &llvm::APFloat::IEEEquad();
218 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
219 }
220
221 void getTargetDefines(const LangOptions &Opts,
222 MacroBuilder &Builder) const override;
223
224 bool isValidCPUName(StringRef Name) const override {
225 return getCPUGeneration(SparcTargetInfo::getCPUKind(Name)) == CG_V9;
226 }
227
228 void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
229
230 bool setCPU(const std::string &Name) override {
231 if (!SparcTargetInfo::setCPU(Name))
232 return false;
233 return getCPUGeneration(CPU) == CG_V9;
234 }
235
236 bool hasBitIntType() const override { return true; }
237};
238} // namespace targets
239} // namespace clang
240#endif // LLVM_CLANG_LIB_BASIC_TARGETS_SPARC_H
enum clang::sema::@1648::IndirectLocalPathEntry::EntryKind Kind
static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)
Determine whether a translation unit built using the current language options has the given feature.
Definition: Module.cpp:100
Defines the clang::TargetOptions class.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:461
Exposes information about the current target.
Definition: TargetInfo.h:218
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
Definition: TargetInfo.h:319
Options for controlling the target.
Definition: TargetOptions.h:26
bool isValidCPUName(StringRef Name) const override
Determine whether this TargetInfo supports the given CPU name.
Definition: Sparc.h:133
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
Definition: Sparc.h:51
int getEHDataRegisterNumber(unsigned RegNo) const override
Return the register number that __builtin_eh_return_regno would return with the specified argument.
Definition: Sparc.h:31
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
Definition: Sparc.h:55
bool setCPU(const std::string &Name) override
Target the specified CPU.
Definition: Sparc.h:139
bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override
Perform initialization based on the user configured set of features (e.g., +sse4).
Definition: Sparc.h:39
std::string_view getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
Definition: Sparc.h:80
std::pair< unsigned, unsigned > hardwareInterferenceSizes() const override
The first value in the pair is the minimum offset between two objects to avoid false sharing (destruc...
Definition: Sparc.h:144
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &info) const override
Definition: Sparc.h:60
SparcTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
Definition: Sparc.h:28
bool hasBitIntType() const override
Determine whether the _BitInt type is supported on this target.
Definition: Sparc.h:183
SparcV8TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: Sparc.h:152
SparcV8elTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: Sparc.h:189
SparcV9TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: Sparc.h:198
bool isValidCPUName(StringRef Name) const override
Determine whether this TargetInfo supports the given CPU name.
Definition: Sparc.h:224
bool hasBitIntType() const override
Determine whether the _BitInt type is supported on this target.
Definition: Sparc.h:236
bool setCPU(const std::string &Name) override
Target the specified CPU.
Definition: Sparc.h:230
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
#define false
Definition: stdbool.h:26