13#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_MIPS_H
14#define LLVM_CLANG_LIB_BASIC_TARGETS_MIPS_H
18#include "llvm/Support/Compiler.h"
19#include "llvm/TargetParser/Triple.h"
25 void setDataLayout() {
29 Layout =
"m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
30 else if (ABI ==
"n32")
31 Layout =
"m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
32 else if (ABI ==
"n64")
33 Layout =
"m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128";
35 llvm_unreachable(
"Invalid ABI");
38 resetDataLayout((
"E-" + Layout).str());
40 resetDataLayout((
"e-" + Layout).str());
50 bool CanUseBSDABICalls;
51 enum MipsFloatABI { HardFloat, SoftFloat } FloatABI;
52 enum DspRevEnum { NoDSP, DSP1, DSP2 } DspRev;
55 bool UseIndirectJumpHazard;
66 IsNoABICalls(
false), CanUseBSDABICalls(
false), FloatABI(HardFloat),
67 DspRev(NoDSP), HasMSA(
false), DisableMadd4(
false),
68 UseIndirectJumpHazard(
false), FPMode(FPXX) {
69 TheCXXABI.set(TargetCXXABI::GenericMIPS);
71 if (Triple.isMIPS32())
73 else if (Triple.getEnvironment() == llvm::Triple::GNUABIN32)
78 CPU = ABI ==
"o32" ?
"mips32r2" :
"mips64r2";
80 CanUseBSDABICalls = Triple.isOSFreeBSD() ||
85 return CPU ==
"mips32r6" || CPU ==
"mips64r6";
89 return CPU ==
"mips32r6" || ABI ==
"n32" || ABI ==
"n64" || ABI ==
"64";
92 bool isNan2008()
const override {
return IsNan2008; }
94 bool processorSupportsGPR64()
const;
96 StringRef
getABI()
const override {
return ABI; }
98 bool setABI(
const std::string &Name)
override {
119 Int64Type = SignedLongLong;
120 IntMaxType = Int64Type;
121 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
122 LongDoubleWidth = LongDoubleAlign = 64;
123 LongWidth = LongAlign = 32;
124 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
125 PointerWidth = PointerAlign = 32;
126 PtrDiffType = SignedInt;
127 SizeType = UnsignedInt;
132 LongDoubleWidth = LongDoubleAlign = 128;
133 LongDoubleFormat = &llvm::APFloat::IEEEquad();
134 if (getTriple().isOSFreeBSD()) {
135 LongDoubleWidth = LongDoubleAlign = 64;
136 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
138 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
144 if (getTriple().isOSOpenBSD()) {
145 Int64Type = SignedLongLong;
147 Int64Type = SignedLong;
149 IntMaxType = Int64Type;
150 LongWidth = LongAlign = 64;
151 PointerWidth = PointerAlign = 64;
152 PtrDiffType = SignedLong;
153 SizeType = UnsignedLong;
158 Int64Type = SignedLongLong;
159 IntMaxType = Int64Type;
160 LongWidth = LongAlign = 32;
161 PointerWidth = PointerAlign = 32;
162 PtrDiffType = SignedInt;
163 SizeType = UnsignedInt;
166 bool isValidCPUName(StringRef Name)
const override;
169 bool setCPU(
const std::string &Name)
override {
171 return isValidCPUName(Name);
174 const std::string &
getCPU()
const {
return CPU; }
178 const std::vector<std::string> &FeaturesVec)
const override {
182 Features[
"mips64r2"] = Features[
"cnmips"] =
true;
183 else if (CPU ==
"octeon+")
184 Features[
"mips64r2"] = Features[
"cnmips"] = Features[
"cnmipsp"] =
true;
186 Features[CPU] =
true;
187 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
190 unsigned getISARev()
const;
197 bool hasFeature(StringRef Feature)
const override;
200 return TargetInfo::VoidPtrBuiltinVaList;
204 static const char *
const GCCRegNames[] = {
207 "$0",
"$1",
"$2",
"$3",
"$4",
"$5",
"$6",
"$7",
"$8",
"$9",
"$10",
208 "$11",
"$12",
"$13",
"$14",
"$15",
"$16",
"$17",
"$18",
"$19",
"$20",
209 "$21",
"$22",
"$23",
"$24",
"$25",
"$26",
"$27",
"$28",
"$29",
"$30",
212 "$f0",
"$f1",
"$f2",
"$f3",
"$f4",
"$f5",
"$f6",
"$f7",
"$f8",
"$f9",
213 "$f10",
"$f11",
"$f12",
"$f13",
"$f14",
"$f15",
"$f16",
"$f17",
"$f18",
214 "$f19",
"$f20",
"$f21",
"$f22",
"$f23",
"$f24",
"$f25",
"$f26",
"$f27",
215 "$f28",
"$f29",
"$f30",
"$f31",
217 "hi",
"lo",
"",
"$fcc0",
"$fcc1",
"$fcc2",
"$fcc3",
"$fcc4",
"$fcc5",
218 "$fcc6",
"$fcc7",
"$ac1hi",
"$ac1lo",
"$ac2hi",
"$ac2lo",
"$ac3hi",
221 "$w0",
"$w1",
"$w2",
"$w3",
"$w4",
"$w5",
"$w6",
"$w7",
"$w8",
"$w9",
222 "$w10",
"$w11",
"$w12",
"$w13",
"$w14",
"$w15",
"$w16",
"$w17",
"$w18",
223 "$w19",
"$w20",
"$w21",
"$w22",
"$w23",
"$w24",
"$w25",
"$w26",
"$w27",
224 "$w28",
"$w29",
"$w30",
"$w31",
226 "$msair",
"$msacsr",
"$msaaccess",
"$msasave",
"$msamodify",
227 "$msarequest",
"$msamap",
"$msaunmap"
247 return FloatABI != SoftFloat;
261 if (Name[1] ==
'C') {
272 switch (*Constraint) {
274 if (Constraint[1] ==
'C') {
275 R = std::string(
"^") + std::string(Constraint, 2);
281 return TargetInfo::convertConstraint(Constraint);
313 IsNan2008 = isIEEE754_2008Default();
314 IsAbs2008 = isIEEE754_2008Default();
315 IsSingleFloat =
false;
316 FloatABI = HardFloat;
318 FPMode = isFP64Default() ? FP64 : FPXX;
320 bool OddSpregGiven =
false;
321 bool StrictAlign =
false;
323 for (
const auto &Feature : Features) {
324 if (Feature ==
"+single-float")
325 IsSingleFloat =
true;
326 else if (Feature ==
"+soft-float")
327 FloatABI = SoftFloat;
328 else if (Feature ==
"+mips16")
330 else if (Feature ==
"+micromips")
332 else if (Feature ==
"+mips32r6" || Feature ==
"+mips64r6")
333 HasUnalignedAccess =
true;
336 else if (Feature ==
"+strict-align")
338 else if (Feature ==
"+dsp")
339 DspRev = std::max(DspRev, DSP1);
340 else if (Feature ==
"+dspr2")
341 DspRev = std::max(DspRev, DSP2);
342 else if (Feature ==
"+msa")
344 else if (Feature ==
"+nomadd4")
346 else if (Feature ==
"+fp64")
348 else if (Feature ==
"-fp64")
350 else if (Feature ==
"+fpxx")
352 else if (Feature ==
"+nan2008")
354 else if (Feature ==
"-nan2008")
356 else if (Feature ==
"+abs2008")
358 else if (Feature ==
"-abs2008")
360 else if (Feature ==
"+noabicalls")
362 else if (Feature ==
"+use-indirect-jump-hazard")
363 UseIndirectJumpHazard =
true;
364 else if (Feature ==
"+nooddspreg") {
366 OddSpregGiven =
false;
367 }
else if (Feature ==
"-nooddspreg") {
369 OddSpregGiven =
true;
373 if (FPMode == FPXX && !OddSpregGiven)
377 HasUnalignedAccess =
false;
396 {{
"at"},
"$1"}, {{
"v0"},
"$2"}, {{
"v1"},
"$3"},
397 {{
"a0"},
"$4"}, {{
"a1"},
"$5"}, {{
"a2"},
"$6"},
398 {{
"a3"},
"$7"}, {{
"t0"},
"$8"}, {{
"t1"},
"$9"},
399 {{
"t2"},
"$10"}, {{
"t3"},
"$11"}, {{
"t4"},
"$12"},
400 {{
"t5"},
"$13"}, {{
"t6"},
"$14"}, {{
"t7"},
"$15"},
401 {{
"s0"},
"$16"}, {{
"s1"},
"$17"}, {{
"s2"},
"$18"},
402 {{
"s3"},
"$19"}, {{
"s4"},
"$20"}, {{
"s5"},
"$21"},
403 {{
"s6"},
"$22"}, {{
"s7"},
"$23"}, {{
"t8"},
"$24"},
404 {{
"t9"},
"$25"}, {{
"k0"},
"$26"}, {{
"k1"},
"$27"},
405 {{
"gp"},
"$28"}, {{
"sp",
"$sp"},
"$29"}, {{
"fp",
"$fp"},
"$30"},
409 {{
"at"},
"$1"}, {{
"v0"},
"$2"}, {{
"v1"},
"$3"},
410 {{
"a0"},
"$4"}, {{
"a1"},
"$5"}, {{
"a2"},
"$6"},
411 {{
"a3"},
"$7"}, {{
"a4"},
"$8"}, {{
"a5"},
"$9"},
412 {{
"a6"},
"$10"}, {{
"a7"},
"$11"}, {{
"t0"},
"$12"},
413 {{
"t1"},
"$13"}, {{
"t2"},
"$14"}, {{
"t3"},
"$15"},
414 {{
"s0"},
"$16"}, {{
"s1"},
"$17"}, {{
"s2"},
"$18"},
415 {{
"s3"},
"$19"}, {{
"s4"},
"$20"}, {{
"s5"},
"$21"},
416 {{
"s6"},
"$22"}, {{
"s7"},
"$23"}, {{
"t8"},
"$24"},
417 {{
"t9"},
"$25"}, {{
"k0"},
"$26"}, {{
"k1"},
"$27"},
418 {{
"gp"},
"$28"}, {{
"sp",
"$sp"},
"$29"}, {{
"fp",
"$fp"},
"$30"},
427 return (ABI ==
"n32" || ABI ==
"n64") || getTargetOpts().ForceEnableInt128;
430 unsigned getUnwindWordWidth()
const override;
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.
Defines the clang::TargetOptions class.
Concrete class used by the front-end to report problems and issues.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Exposes information about the current target.
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
Options for controlling the target.
bool hasBitIntType() const override
Determine whether the _BitInt type is supported on this target.
MipsTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
int getEHDataRegisterNumber(unsigned RegNo) const override
Return the register number that __builtin_eh_return_regno would return with the specified argument.
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeaturesVec) const override
Initialize the map with the default set of target features for the CPU this should include all legal ...
bool setCPU(const std::string &Name) override
Target the specified CPU.
StringRef getABI() const override
Get the ABI currently in use.
ArrayRef< const char * > getGCCRegNames() const override
bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override
Perform initialization based on the user configured set of features (e.g., +sse4).
bool hasInt128Type() const override
Determine whether the __int128 type is supported on this target.
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const override
bool isIEEE754_2008Default() const
bool isFP64Default() const
bool setABI(const std::string &Name) override
Use the specified ABI.
std::string_view getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
ArrayRef< TargetInfo::GCCRegAlias > getGCCRegAliases() const override
std::string convertConstraint(const char *&Constraint) const override
bool isCLZForZeroUndef() const override
The __builtin_clz* and __builtin_ctz* built-in functions are specified to have undefined results for ...
bool isNan2008() const override
Returns true if NaN encoding is IEEE 754-2008.
const std::string & getCPU() const
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.