1//===--- Hexagon.cpp - Implement Hexagon 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 Hexagon TargetInfo objects.
10//
11//===----------------------------------------------------------------------===//
12
13#include "Hexagon.h"
14#include "clang/Basic/MacroBuilder.h"
15#include "clang/Basic/TargetBuiltins.h"
16#include "llvm/ADT/StringSwitch.h"
17
18using namespace clang;
19using namespace clang::targets;
20
21void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
22 MacroBuilder &Builder) const {
23 Builder.defineMacro(Name: "__qdsp6__", Value: "1");
24 Builder.defineMacro(Name: "__hexagon__", Value: "1");
25
26 StringRef CPUSuffix = CPU;
27 CPUSuffix.consume_front(Prefix: "hexagonv");
28
29 StringRef ArchVersion = CPUSuffix;
30 ArchVersion.consume_back(Suffix: "t");
31
32 // The macro __HVXDBL__ is deprecated.
33 bool DefineHvxDbl = ArchVersion == "60" || ArchVersion == "62" ||
34 ArchVersion == "65" || ArchVersion == "66";
35
36 auto DefineArchMacros = [=, &Builder](StringRef Prefix) {
37 Builder.defineMacro(Name: Prefix + "V" + CPUSuffix.upper() + "__");
38 Builder.defineMacro(Name: Prefix + "ARCH__", Value: ArchVersion);
39 };
40
41 DefineArchMacros("__HEXAGON_");
42 if ((Opts.HexagonQdsp6Compat && ArchVersion == "5") || ArchVersion == "55" ||
43 ArchVersion == "60")
44 DefineArchMacros("__QDSP6_");
45
46 if (hasFeature(Feature: "hvx-length64b")) {
47 Builder.defineMacro(Name: "__HVX__");
48 Builder.defineMacro(Name: "__HVX_ARCH__", Value: HVXVersion);
49 Builder.defineMacro(Name: "__HVX_LENGTH__", Value: "64");
50 }
51
52 if (hasFeature(Feature: "hvx-length128b")) {
53 Builder.defineMacro(Name: "__HVX__");
54 Builder.defineMacro(Name: "__HVX_ARCH__", Value: HVXVersion);
55 Builder.defineMacro(Name: "__HVX_LENGTH__", Value: "128");
56 if (DefineHvxDbl)
57 Builder.defineMacro(Name: "__HVXDBL__");
58 }
59
60 if (HasHVXIeeeFp)
61 Builder.defineMacro(Name: "__HVX_IEEE_FP__");
62
63 if (hasFeature(Feature: "hmx")) {
64 Builder.defineMacro(Name: "__HMX__");
65 Builder.defineMacro(Name: "__HMX_ARCH__", Value: ArchVersion);
66 }
67
68 if (hasFeature(Feature: "hlx")) {
69 Builder.defineMacro(Name: "__HLX__");
70 Builder.defineMacro(Name: "__HLX_ARCH__", Value: "85");
71 Builder.defineMacro(Name: "__HLX_LENGTH__", Value: "2048");
72 }
73
74 if (hasFeature(Feature: "audio")) {
75 Builder.defineMacro(Name: "__HEXAGON_AUDIO__");
76 }
77
78 std::string NumPhySlots = isTinyCore() ? "3" : "4";
79 Builder.defineMacro(Name: "__HEXAGON_PHYSICAL_SLOTS__", Value: NumPhySlots);
80
81 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
82 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
83 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
84 Builder.defineMacro(Name: "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
85
86 if (Opts.CPlusPlus && getTriple().getOS() == llvm::Triple::UnknownOS)
87 Builder.defineMacro(Name: "_GNU_SOURCE");
88}
89
90bool HexagonTargetInfo::initFeatureMap(
91 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
92 const std::vector<std::string> &FeaturesVec) const {
93 if (isTinyCore())
94 Features["audio"] = true;
95
96 StringRef CPUFeature = CPU;
97 CPUFeature.consume_front(Prefix: "hexagon");
98 CPUFeature.consume_back(Suffix: "t");
99 if (!CPUFeature.empty())
100 Features[CPUFeature] = true;
101
102 Features["long-calls"] = false;
103
104 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeatureVec: FeaturesVec);
105}
106
107bool HexagonTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
108 DiagnosticsEngine &Diags) {
109 for (auto &F : Features) {
110 if (F == "+hvx-length64b")
111 HasHVX = HasHVX64B = true;
112 else if (F == "+hvx-length128b")
113 HasHVX = HasHVX128B = true;
114 else if (F.find(s: "+hvxv") != std::string::npos) {
115 HasHVX = true;
116 HVXVersion = F.substr(pos: std::string("+hvxv").length());
117 } else if (F == "-hvx")
118 HasHVX = HasHVX64B = HasHVX128B = false;
119 else if (F == "+long-calls")
120 UseLongCalls = true;
121 else if (F == "-long-calls")
122 UseLongCalls = false;
123 else if (F == "+hvx-ieee-fp")
124 HasHVXIeeeFp = true;
125 else if (F == "+audio")
126 HasAudio = true;
127 else if (F == "+hlx")
128 HasHLX = true;
129 else if (F == "-hlx")
130 HasHLX = false;
131 else if (F == "+hmx")
132 HasHMX = true;
133 else if (F == "-hmx")
134 HasHMX = false;
135 }
136 if (CPU.compare(s: "hexagonv68") >= 0) {
137 HasFastHalfType = true;
138 HasFloat16 = true;
139 }
140 if (CPU.compare(s: "hexagonv81") >= 0)
141 HasBFloat16 = true;
142
143 return true;
144}
145
146bool HexagonTargetInfo::hasBFloat16Type() const { return HasBFloat16; }
147
148const char *const HexagonTargetInfo::GCCRegNames[] = {
149 // Scalar registers:
150 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11",
151 "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21",
152 "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
153 "r1:0", "r3:2", "r5:4", "r7:6", "r9:8", "r11:10", "r13:12", "r15:14",
154 "r17:16", "r19:18", "r21:20", "r23:22", "r25:24", "r27:26", "r29:28",
155 "r31:30",
156 // Predicate registers:
157 "p0", "p1", "p2", "p3",
158 // Control registers:
159 "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11",
160 "c12", "c13", "c14", "c15", "c16", "c17", "c18", "c19", "c20", "c21",
161 "c22", "c23", "c24", "c25", "c26", "c27", "c28", "c29", "c30", "c31",
162 "c1:0", "c3:2", "c5:4", "c7:6", "c9:8", "c11:10", "c13:12", "c15:14",
163 "c17:16", "c19:18", "c21:20", "c23:22", "c25:24", "c27:26", "c29:28",
164 "c31:30",
165 // Control register aliases:
166 "sa0", "lc0", "sa1", "lc1", "p3:0", "m0", "m1", "usr", "pc", "ugp",
167 "gp", "cs0", "cs1", "upcyclelo", "upcyclehi", "framelimit", "framekey",
168 "pktcountlo", "pktcounthi", "utimerlo", "utimerhi",
169 "upcycle", "pktcount", "utimer",
170 // HVX vector registers:
171 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11",
172 "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
173 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
174 "v1:0", "v3:2", "v5:4", "v7:6", "v9:8", "v11:10", "v13:12", "v15:14",
175 "v17:16", "v19:18", "v21:20", "v23:22", "v25:24", "v27:26", "v29:28",
176 "v31:30",
177 "v3:0", "v7:4", "v11:8", "v15:12", "v19:16", "v23:20", "v27:24", "v31:28",
178 // HVX vector predicates:
179 "q0", "q1", "q2", "q3",
180};
181
182ArrayRef<const char *> HexagonTargetInfo::getGCCRegNames() const {
183 return llvm::ArrayRef(GCCRegNames);
184}
185
186const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
187 {.Aliases: {"sp"}, .Register: "r29"},
188 {.Aliases: {"fp"}, .Register: "r30"},
189 {.Aliases: {"lr"}, .Register: "r31"},
190};
191
192ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
193 return llvm::ArrayRef(GCCRegAliases);
194}
195
196static constexpr int NumBuiltins =
197 clang::Hexagon::LastTSBuiltin - Builtin::FirstTSBuiltin;
198
199#define GET_BUILTIN_STR_TABLE
200#include "clang/Basic/BuiltinsHexagon.inc"
201#undef GET_BUILTIN_STR_TABLE
202
203static constexpr Builtin::Info BuiltinInfos[] = {
204#define GET_BUILTIN_INFOS
205#include "clang/Basic/BuiltinsHexagon.inc"
206#undef GET_BUILTIN_INFOS
207};
208
209static constexpr Builtin::Info PrefixedBuiltinInfos[] = {
210#define GET_BUILTIN_PREFIXED_INFOS
211#include "clang/Basic/BuiltinsHexagon.inc"
212#undef GET_BUILTIN_PREFIXED_INFOS
213};
214static_assert((std::size(BuiltinInfos) + std::size(PrefixedBuiltinInfos)) ==
215 NumBuiltins);
216
217bool HexagonTargetInfo::hasFeature(StringRef Feature) const {
218 std::string VS = "hvxv" + HVXVersion;
219 if (Feature == VS)
220 return true;
221
222 return llvm::StringSwitch<bool>(Feature)
223 .Case(S: "hexagon", Value: true)
224 .Case(S: "hvx", Value: HasHVX)
225 .Case(S: "hvx-length64b", Value: HasHVX64B)
226 .Case(S: "hvx-length128b", Value: HasHVX128B)
227 .Case(S: "hvx-ieee-fp", Value: HasHVXIeeeFp)
228 .Case(S: "long-calls", Value: UseLongCalls)
229 .Case(S: "audio", Value: HasAudio)
230 .Case(S: "hmx", Value: HasHMX)
231 .Case(S: "hlx", Value: HasHLX)
232 .Default(Value: false);
233}
234
235struct CPUSuffix {
236 llvm::StringLiteral Name;
237 llvm::StringLiteral Suffix;
238};
239
240static constexpr CPUSuffix Suffixes[] = {
241 {.Name: {"hexagonv5"}, .Suffix: {"5"}}, {.Name: {"hexagonv55"}, .Suffix: {"55"}},
242 {.Name: {"hexagonv60"}, .Suffix: {"60"}}, {.Name: {"hexagonv62"}, .Suffix: {"62"}},
243 {.Name: {"hexagonv65"}, .Suffix: {"65"}}, {.Name: {"hexagonv66"}, .Suffix: {"66"}},
244 {.Name: {"hexagonv67"}, .Suffix: {"67"}}, {.Name: {"hexagonv67t"}, .Suffix: {"67t"}},
245 {.Name: {"hexagonv68"}, .Suffix: {"68"}}, {.Name: {"hexagonv69"}, .Suffix: {"69"}},
246 {.Name: {"hexagonv71"}, .Suffix: {"71"}}, {.Name: {"hexagonv71t"}, .Suffix: {"71t"}},
247 {.Name: {"hexagonv73"}, .Suffix: {"73"}}, {.Name: {"hexagonv75"}, .Suffix: {"75"}},
248 {.Name: {"hexagonv79"}, .Suffix: {"79"}}, {.Name: {"hexagonv81"}, .Suffix: {"81"}},
249 {.Name: {"hexagonv83"}, .Suffix: {"83"}}, {.Name: {"hexagonv85"}, .Suffix: {"85"}}};
250
251std::optional<unsigned> HexagonTargetInfo::getHexagonCPURev(StringRef Name) {
252 StringRef Arch = Name;
253 Arch.consume_front(Prefix: "hexagonv");
254 Arch.consume_back(Suffix: "t");
255
256 unsigned Val;
257 if (!Arch.getAsInteger(Radix: 0, Result&: Val))
258 return Val;
259
260 return std::nullopt;
261}
262
263const char *HexagonTargetInfo::getHexagonCPUSuffix(StringRef Name) {
264 const CPUSuffix *Item = llvm::find_if(
265 Range: Suffixes, P: [Name](const CPUSuffix &S) { return S.Name == Name; });
266 if (Item == std::end(arr: Suffixes))
267 return nullptr;
268 return Item->Suffix.data();
269}
270
271void HexagonTargetInfo::fillValidCPUList(
272 SmallVectorImpl<StringRef> &Values) const {
273 for (const CPUSuffix &Suffix : Suffixes)
274 Values.push_back(Elt: Suffix.Name);
275}
276
277llvm::SmallVector<Builtin::InfosShard>
278HexagonTargetInfo::getTargetBuiltins() const {
279 return {{.Strings: &BuiltinStrings, .Infos: BuiltinInfos},
280 {.Strings: &BuiltinStrings, .Infos: PrefixedBuiltinInfos, .NamePrefix: "__builtin_HEXAGON_"}};
281}
282