1 //===--- RISCV.cpp - Implement RISCV target feature support ---------------===//
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 implements RISCV TargetInfo objects.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "RISCV.h"
14 #include "clang/Basic/Diagnostic.h"
15 #include "clang/Basic/MacroBuilder.h"
16 #include "clang/Basic/TargetBuiltins.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/Support/TargetParser.h"
19 #include "llvm/Support/raw_ostream.h"
20 
21 using namespace clang;
22 using namespace clang::targets;
23 
24 ArrayRef<const char *> RISCVTargetInfo::getGCCRegNames() const {
25   static const char *const GCCRegNames[] = {
26       // Integer registers
27       "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
28       "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
29       "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
30       "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
31 
32       // Floating point registers
33       "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
34       "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
35       "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
36       "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
37 
38       // Vector registers
39       "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
40       "v8",  "v9",  "v10", "v11", "v12", "v13", "v14", "v15",
41       "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
42       "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"};
43   return llvm::makeArrayRef(GCCRegNames);
44 }
45 
46 ArrayRef<TargetInfo::GCCRegAlias> RISCVTargetInfo::getGCCRegAliases() const {
47   static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
48       {{"zero"}, "x0"}, {{"ra"}, "x1"},   {{"sp"}, "x2"},    {{"gp"}, "x3"},
49       {{"tp"}, "x4"},   {{"t0"}, "x5"},   {{"t1"}, "x6"},    {{"t2"}, "x7"},
50       {{"s0"}, "x8"},   {{"s1"}, "x9"},   {{"a0"}, "x10"},   {{"a1"}, "x11"},
51       {{"a2"}, "x12"},  {{"a3"}, "x13"},  {{"a4"}, "x14"},   {{"a5"}, "x15"},
52       {{"a6"}, "x16"},  {{"a7"}, "x17"},  {{"s2"}, "x18"},   {{"s3"}, "x19"},
53       {{"s4"}, "x20"},  {{"s5"}, "x21"},  {{"s6"}, "x22"},   {{"s7"}, "x23"},
54       {{"s8"}, "x24"},  {{"s9"}, "x25"},  {{"s10"}, "x26"},  {{"s11"}, "x27"},
55       {{"t3"}, "x28"},  {{"t4"}, "x29"},  {{"t5"}, "x30"},   {{"t6"}, "x31"},
56       {{"ft0"}, "f0"},  {{"ft1"}, "f1"},  {{"ft2"}, "f2"},   {{"ft3"}, "f3"},
57       {{"ft4"}, "f4"},  {{"ft5"}, "f5"},  {{"ft6"}, "f6"},   {{"ft7"}, "f7"},
58       {{"fs0"}, "f8"},  {{"fs1"}, "f9"},  {{"fa0"}, "f10"},  {{"fa1"}, "f11"},
59       {{"fa2"}, "f12"}, {{"fa3"}, "f13"}, {{"fa4"}, "f14"},  {{"fa5"}, "f15"},
60       {{"fa6"}, "f16"}, {{"fa7"}, "f17"}, {{"fs2"}, "f18"},  {{"fs3"}, "f19"},
61       {{"fs4"}, "f20"}, {{"fs5"}, "f21"}, {{"fs6"}, "f22"},  {{"fs7"}, "f23"},
62       {{"fs8"}, "f24"}, {{"fs9"}, "f25"}, {{"fs10"}, "f26"}, {{"fs11"}, "f27"},
63       {{"ft8"}, "f28"}, {{"ft9"}, "f29"}, {{"ft10"}, "f30"}, {{"ft11"}, "f31"}};
64   return llvm::makeArrayRef(GCCRegAliases);
65 }
66 
67 bool RISCVTargetInfo::validateAsmConstraint(
68     const char *&Name, TargetInfo::ConstraintInfo &Info) const {
69   switch (*Name) {
70   default:
71     return false;
72   case 'I':
73     // A 12-bit signed immediate.
74     Info.setRequiresImmediate(-2048, 2047);
75     return true;
76   case 'J':
77     // Integer zero.
78     Info.setRequiresImmediate(0);
79     return true;
80   case 'K':
81     // A 5-bit unsigned immediate for CSR access instructions.
82     Info.setRequiresImmediate(0, 31);
83     return true;
84   case 'f':
85     // A floating-point register.
86     Info.setAllowsRegister();
87     return true;
88   case 'A':
89     // An address that is held in a general-purpose register.
90     Info.setAllowsMemory();
91     return true;
92   case 'S': // A symbolic address
93     Info.setAllowsRegister();
94     return true;
95   case 'v':
96     // A vector register.
97     if (Name[1] == 'r' || Name[1] == 'm') {
98       Info.setAllowsRegister();
99       Name += 1;
100       return true;
101     }
102     return false;
103   }
104 }
105 
106 std::string RISCVTargetInfo::convertConstraint(const char *&Constraint) const {
107   std::string R;
108   switch (*Constraint) {
109   case 'v':
110     R = std::string("^") + std::string(Constraint, 2);
111     Constraint += 1;
112     break;
113   default:
114     R = TargetInfo::convertConstraint(Constraint);
115     break;
116   }
117   return R;
118 }
119 
120 void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts,
121                                        MacroBuilder &Builder) const {
122   Builder.defineMacro("__ELF__");
123   Builder.defineMacro("__riscv");
124   bool Is64Bit = getTriple().getArch() == llvm::Triple::riscv64;
125   Builder.defineMacro("__riscv_xlen", Is64Bit ? "64" : "32");
126   StringRef CodeModel = getTargetOpts().CodeModel;
127   unsigned FLen = ISAInfo->getFLen();
128   if (CodeModel == "default")
129     CodeModel = "small";
130 
131   if (CodeModel == "small")
132     Builder.defineMacro("__riscv_cmodel_medlow");
133   else if (CodeModel == "medium")
134     Builder.defineMacro("__riscv_cmodel_medany");
135 
136   StringRef ABIName = getABI();
137   if (ABIName == "ilp32f" || ABIName == "lp64f")
138     Builder.defineMacro("__riscv_float_abi_single");
139   else if (ABIName == "ilp32d" || ABIName == "lp64d")
140     Builder.defineMacro("__riscv_float_abi_double");
141   else
142     Builder.defineMacro("__riscv_float_abi_soft");
143 
144   if (ABIName == "ilp32e")
145     Builder.defineMacro("__riscv_abi_rve");
146 
147   Builder.defineMacro("__riscv_arch_test");
148 
149   for (auto &Extension : ISAInfo->getExtensions()) {
150     auto ExtName = Extension.first;
151     auto ExtInfo = Extension.second;
152     unsigned Version =
153         (ExtInfo.MajorVersion * 1000000) + (ExtInfo.MinorVersion * 1000);
154 
155     Builder.defineMacro(Twine("__riscv_", ExtName), Twine(Version));
156   }
157 
158   if (ISAInfo->hasExtension("m")) {
159     Builder.defineMacro("__riscv_mul");
160     Builder.defineMacro("__riscv_div");
161     Builder.defineMacro("__riscv_muldiv");
162   }
163 
164   if (ISAInfo->hasExtension("a")) {
165     Builder.defineMacro("__riscv_atomic");
166     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
167     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
168     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
169     if (Is64Bit)
170       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
171   }
172 
173   if (FLen) {
174     Builder.defineMacro("__riscv_flen", Twine(FLen));
175     Builder.defineMacro("__riscv_fdiv");
176     Builder.defineMacro("__riscv_fsqrt");
177   }
178 
179   if (ISAInfo->hasExtension("c"))
180     Builder.defineMacro("__riscv_compressed");
181 
182   if (ISAInfo->hasExtension("v"))
183     Builder.defineMacro("__riscv_vector");
184 }
185 
186 const Builtin::Info RISCVTargetInfo::BuiltinInfo[] = {
187 #define BUILTIN(ID, TYPE, ATTRS)                                               \
188   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
189 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
190     {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE},
191 #include "clang/Basic/BuiltinsRISCV.def"
192 };
193 
194 ArrayRef<Builtin::Info> RISCVTargetInfo::getTargetBuiltins() const {
195   return llvm::makeArrayRef(BuiltinInfo, clang::RISCV::LastTSBuiltin -
196                                              Builtin::FirstTSBuiltin);
197 }
198 
199 bool RISCVTargetInfo::initFeatureMap(
200     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
201     const std::vector<std::string> &FeaturesVec) const {
202 
203   if (getTriple().getArch() == llvm::Triple::riscv64)
204     Features["64bit"] = true;
205 
206   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
207 }
208 
209 /// Return true if has this feature, need to sync with handleTargetFeatures.
210 bool RISCVTargetInfo::hasFeature(StringRef Feature) const {
211   bool Is64Bit = getTriple().getArch() == llvm::Triple::riscv64;
212   auto Result = llvm::StringSwitch<Optional<bool>>(Feature)
213                     .Case("riscv", true)
214                     .Case("riscv32", !Is64Bit)
215                     .Case("riscv64", Is64Bit)
216                     .Case("64bit", Is64Bit)
217                     .Default(None);
218   if (Result.hasValue())
219     return Result.getValue();
220 
221   if (ISAInfo->isSupportedExtensionFeature(Feature))
222     return ISAInfo->hasExtension(Feature);
223 
224   return false;
225 }
226 
227 /// Perform initialization based on the user configured set of features.
228 bool RISCVTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
229                                            DiagnosticsEngine &Diags) {
230   unsigned XLen = getTriple().isArch64Bit() ? 64 : 32;
231   auto ParseResult = llvm::RISCVISAInfo::parseFeatures(XLen, Features);
232   if (!ParseResult) {
233     std::string Buffer;
234     llvm::raw_string_ostream OutputErrMsg(Buffer);
235     handleAllErrors(ParseResult.takeError(), [&](llvm::StringError &ErrMsg) {
236       OutputErrMsg << ErrMsg.getMessage();
237     });
238     Diags.Report(diag::err_invalid_feature_combination) << OutputErrMsg.str();
239     return false;
240   } else {
241     ISAInfo = std::move(*ParseResult);
242   }
243 
244   return true;
245 }
246 
247 bool RISCV32TargetInfo::isValidCPUName(StringRef Name) const {
248   return llvm::RISCV::checkCPUKind(llvm::RISCV::parseCPUKind(Name),
249                                    /*Is64Bit=*/false);
250 }
251 
252 void RISCV32TargetInfo::fillValidCPUList(
253     SmallVectorImpl<StringRef> &Values) const {
254   llvm::RISCV::fillValidCPUArchList(Values, false);
255 }
256 
257 bool RISCV32TargetInfo::isValidTuneCPUName(StringRef Name) const {
258   return llvm::RISCV::checkTuneCPUKind(
259       llvm::RISCV::parseTuneCPUKind(Name, false),
260       /*Is64Bit=*/false);
261 }
262 
263 void RISCV32TargetInfo::fillValidTuneCPUList(
264     SmallVectorImpl<StringRef> &Values) const {
265   llvm::RISCV::fillValidTuneCPUArchList(Values, false);
266 }
267 
268 bool RISCV64TargetInfo::isValidCPUName(StringRef Name) const {
269   return llvm::RISCV::checkCPUKind(llvm::RISCV::parseCPUKind(Name),
270                                    /*Is64Bit=*/true);
271 }
272 
273 void RISCV64TargetInfo::fillValidCPUList(
274     SmallVectorImpl<StringRef> &Values) const {
275   llvm::RISCV::fillValidCPUArchList(Values, true);
276 }
277 
278 bool RISCV64TargetInfo::isValidTuneCPUName(StringRef Name) const {
279   return llvm::RISCV::checkTuneCPUKind(
280       llvm::RISCV::parseTuneCPUKind(Name, true),
281       /*Is64Bit=*/true);
282 }
283 
284 void RISCV64TargetInfo::fillValidTuneCPUList(
285     SmallVectorImpl<StringRef> &Values) const {
286   llvm::RISCV::fillValidTuneCPUArchList(Values, true);
287 }
288