1//===-- HexagonMCTargetDesc.cpp - Hexagon Target Descriptions -------------===//
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 provides Hexagon specific target descriptions.
10//
11//===----------------------------------------------------------------------===//
12
13#include "MCTargetDesc/HexagonMCTargetDesc.h"
14#include "HexagonDepArch.h"
15#include "HexagonTargetStreamer.h"
16#include "MCTargetDesc/HexagonInstPrinter.h"
17#include "MCTargetDesc/HexagonMCAsmInfo.h"
18#include "MCTargetDesc/HexagonMCELFStreamer.h"
19#include "MCTargetDesc/HexagonMCInstrInfo.h"
20#include "TargetInfo/HexagonTargetInfo.h"
21#include "llvm/ADT/StringExtras.h"
22#include "llvm/ADT/StringMap.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/BinaryFormat/ELF.h"
25#include "llvm/MC/MCAsmBackend.h"
26#include "llvm/MC/MCAssembler.h"
27#include "llvm/MC/MCCodeEmitter.h"
28#include "llvm/MC/MCContext.h"
29#include "llvm/MC/MCDwarf.h"
30#include "llvm/MC/MCELFObjectWriter.h"
31#include "llvm/MC/MCELFStreamer.h"
32#include "llvm/MC/MCInstrAnalysis.h"
33#include "llvm/MC/MCInstrInfo.h"
34#include "llvm/MC/MCRegisterInfo.h"
35#include "llvm/MC/MCStreamer.h"
36#include "llvm/MC/MCSubtargetInfo.h"
37#include "llvm/MC/TargetRegistry.h"
38#include "llvm/Support/Compiler.h"
39#include "llvm/Support/ErrorHandling.h"
40#include "llvm/Support/HexagonAttributes.h"
41#include "llvm/Support/raw_ostream.h"
42#include <cassert>
43#include <cstdint>
44#include <mutex>
45#include <new>
46#include <string>
47
48using namespace llvm;
49
50#define GET_INSTRINFO_MC_DESC
51#define ENABLE_INSTR_PREDICATE_VERIFIER
52#include "HexagonGenInstrInfo.inc"
53
54#define GET_SUBTARGETINFO_MC_DESC
55#include "HexagonGenSubtargetInfo.inc"
56
57#define GET_REGINFO_MC_DESC
58#include "HexagonGenRegisterInfo.inc"
59
60cl::opt<bool> llvm::HexagonDisableCompound
61 ("mno-compound",
62 cl::desc("Disable looking for compound instructions for Hexagon"));
63
64cl::opt<bool> llvm::HexagonDisableDuplex
65 ("mno-pairing",
66 cl::desc("Disable looking for duplex instructions for Hexagon"));
67
68namespace { // These flags are to be deprecated
69cl::opt<bool> MV5("mv5", cl::Hidden, cl::desc("Build for Hexagon V5"),
70 cl::init(Val: false));
71cl::opt<bool> MV55("mv55", cl::Hidden, cl::desc("Build for Hexagon V55"),
72 cl::init(Val: false));
73cl::opt<bool> MV60("mv60", cl::Hidden, cl::desc("Build for Hexagon V60"),
74 cl::init(Val: false));
75cl::opt<bool> MV62("mv62", cl::Hidden, cl::desc("Build for Hexagon V62"),
76 cl::init(Val: false));
77cl::opt<bool> MV65("mv65", cl::Hidden, cl::desc("Build for Hexagon V65"),
78 cl::init(Val: false));
79cl::opt<bool> MV66("mv66", cl::Hidden, cl::desc("Build for Hexagon V66"),
80 cl::init(Val: false));
81cl::opt<bool> MV67("mv67", cl::Hidden, cl::desc("Build for Hexagon V67"),
82 cl::init(Val: false));
83cl::opt<bool> MV67T("mv67t", cl::Hidden, cl::desc("Build for Hexagon V67T"),
84 cl::init(Val: false));
85cl::opt<bool> MV68("mv68", cl::Hidden, cl::desc("Build for Hexagon V68"),
86 cl::init(Val: false));
87cl::opt<bool> MV69("mv69", cl::Hidden, cl::desc("Build for Hexagon V69"),
88 cl::init(Val: false));
89cl::opt<bool> MV71("mv71", cl::Hidden, cl::desc("Build for Hexagon V71"),
90 cl::init(Val: false));
91cl::opt<bool> MV71T("mv71t", cl::Hidden, cl::desc("Build for Hexagon V71T"),
92 cl::init(Val: false));
93cl::opt<bool> MV73("mv73", cl::Hidden, cl::desc("Build for Hexagon V73"),
94 cl::init(Val: false));
95cl::opt<bool> MV75("mv75", cl::Hidden, cl::desc("Build for Hexagon V75"),
96 cl::init(Val: false));
97cl::opt<bool> MV79("mv79", cl::Hidden, cl::desc("Build for Hexagon V79"),
98 cl::init(Val: false));
99cl::opt<bool> MV81("mv81", cl::Hidden, cl::desc("Build for Hexagon V81"),
100 cl::init(Val: false));
101cl::opt<bool> MV83("mv83", cl::Hidden, cl::desc("Build for Hexagon V83"),
102 cl::init(Val: false));
103cl::opt<bool> MV85("mv85", cl::Hidden, cl::desc("Build for Hexagon V85"),
104 cl::init(Val: false));
105} // namespace
106
107static cl::opt<Hexagon::ArchEnum> EnableHVX(
108 "mhvx", cl::desc("Enable Hexagon Vector eXtensions"),
109 cl::values(clEnumValN(Hexagon::ArchEnum::V60, "v60", "Build for HVX v60"),
110 clEnumValN(Hexagon::ArchEnum::V62, "v62", "Build for HVX v62"),
111 clEnumValN(Hexagon::ArchEnum::V65, "v65", "Build for HVX v65"),
112 clEnumValN(Hexagon::ArchEnum::V66, "v66", "Build for HVX v66"),
113 clEnumValN(Hexagon::ArchEnum::V67, "v67", "Build for HVX v67"),
114 clEnumValN(Hexagon::ArchEnum::V68, "v68", "Build for HVX v68"),
115 clEnumValN(Hexagon::ArchEnum::V69, "v69", "Build for HVX v69"),
116 clEnumValN(Hexagon::ArchEnum::V71, "v71", "Build for HVX v71"),
117 clEnumValN(Hexagon::ArchEnum::V73, "v73", "Build for HVX v73"),
118 clEnumValN(Hexagon::ArchEnum::V75, "v75", "Build for HVX v75"),
119 clEnumValN(Hexagon::ArchEnum::V79, "v79", "Build for HVX v79"),
120 clEnumValN(Hexagon::ArchEnum::V81, "v81", "Build for HVX v81"),
121 clEnumValN(Hexagon::ArchEnum::V83, "v83", "Build for HVX v83"),
122 clEnumValN(Hexagon::ArchEnum::V85, "v85", "Build for HVX v85"),
123 // Sentinel for no value specified.
124 clEnumValN(Hexagon::ArchEnum::Generic, "", "")),
125 // Sentinel for flag not present.
126 cl::init(Val: Hexagon::ArchEnum::NoArch), cl::ValueOptional);
127
128static cl::opt<bool>
129 DisableHVX("mno-hvx", cl::Hidden,
130 cl::desc("Disable Hexagon Vector eXtensions"));
131
132static cl::opt<bool> EnableHMX("mhmx",
133 cl::desc("Enable Hexagon Matrix eXtensions"));
134
135static cl::opt<bool>
136 EnableHvxIeeeFp("mhvx-ieee-fp", cl::Hidden,
137 cl::desc("Enable HVX IEEE floating point extensions"));
138static cl::opt<bool> EnableHexagonCabac
139 ("mcabac", cl::desc("tbd"), cl::init(Val: false));
140static cl::opt<bool> EnableHLX("mhlx", cl::desc("Enable Hexagon HLX"));
141
142static constexpr StringRef DefaultArch = "hexagonv68";
143
144static StringRef HexagonGetArchVariant() {
145 if (MV5)
146 return "hexagonv5";
147 if (MV55)
148 return "hexagonv55";
149 if (MV60)
150 return "hexagonv60";
151 if (MV62)
152 return "hexagonv62";
153 if (MV65)
154 return "hexagonv65";
155 if (MV66)
156 return "hexagonv66";
157 if (MV67)
158 return "hexagonv67";
159 if (MV67T)
160 return "hexagonv67t";
161 if (MV68)
162 return "hexagonv68";
163 if (MV69)
164 return "hexagonv69";
165 if (MV71)
166 return "hexagonv71";
167 if (MV71T)
168 return "hexagonv71t";
169 if (MV73)
170 return "hexagonv73";
171 if (MV75)
172 return "hexagonv75";
173 if (MV79)
174 return "hexagonv79";
175 if (MV81)
176 return "hexagonv81";
177 if (MV83)
178 return "hexagonv83";
179 if (MV85)
180 return "hexagonv85";
181
182 return "";
183}
184
185StringRef Hexagon_MC::selectHexagonCPU(StringRef CPU) {
186 StringRef ArchV = HexagonGetArchVariant();
187 if (!ArchV.empty() && !CPU.empty()) {
188 // Tiny cores have a "t" suffix that is discarded when creating a secondary
189 // non-tiny subtarget. See: addArchSubtarget
190 std::pair<StringRef, StringRef> ArchP = ArchV.split(Separator: 't');
191 std::pair<StringRef, StringRef> CPUP = CPU.split(Separator: 't');
192 if (ArchP.first != CPUP.first)
193 report_fatal_error(reason: "conflicting architectures specified.");
194 return CPU;
195 }
196 if (ArchV.empty()) {
197 if (CPU.empty())
198 CPU = DefaultArch;
199 return CPU;
200 }
201 return ArchV;
202}
203
204unsigned llvm::HexagonGetLastSlot() { return HexagonItinerariesV5FU::SLOT3; }
205
206unsigned llvm::HexagonConvertUnits(unsigned ItinUnits, unsigned *Lanes) {
207 enum {
208 CVI_NONE = 0,
209 CVI_XLANE = 1 << 0,
210 CVI_SHIFT = 1 << 1,
211 CVI_MPY0 = 1 << 2,
212 CVI_MPY1 = 1 << 3,
213 CVI_ZW = 1 << 4
214 };
215
216 if (ItinUnits == HexagonItinerariesV62FU::CVI_ALL ||
217 ItinUnits == HexagonItinerariesV62FU::CVI_ALL_NOMEM)
218 return (*Lanes = 4, CVI_XLANE);
219 else if (ItinUnits & HexagonItinerariesV62FU::CVI_MPY01 &&
220 ItinUnits & HexagonItinerariesV62FU::CVI_XLSHF)
221 return (*Lanes = 2, CVI_XLANE | CVI_MPY0);
222 else if (ItinUnits & HexagonItinerariesV62FU::CVI_MPY01)
223 return (*Lanes = 2, CVI_MPY0);
224 else if (ItinUnits & HexagonItinerariesV62FU::CVI_XLSHF)
225 return (*Lanes = 2, CVI_XLANE);
226 else if (ItinUnits & HexagonItinerariesV62FU::CVI_XLANE &&
227 ItinUnits & HexagonItinerariesV62FU::CVI_SHIFT &&
228 ItinUnits & HexagonItinerariesV62FU::CVI_MPY0 &&
229 ItinUnits & HexagonItinerariesV62FU::CVI_MPY1)
230 return (*Lanes = 1, CVI_XLANE | CVI_SHIFT | CVI_MPY0 | CVI_MPY1);
231 else if (ItinUnits & HexagonItinerariesV62FU::CVI_XLANE &&
232 ItinUnits & HexagonItinerariesV62FU::CVI_SHIFT)
233 return (*Lanes = 1, CVI_XLANE | CVI_SHIFT);
234 else if (ItinUnits & HexagonItinerariesV62FU::CVI_MPY0 &&
235 ItinUnits & HexagonItinerariesV62FU::CVI_MPY1)
236 return (*Lanes = 1, CVI_MPY0 | CVI_MPY1);
237 else if (ItinUnits == HexagonItinerariesV62FU::CVI_ZW)
238 return (*Lanes = 1, CVI_ZW);
239 else if (ItinUnits == HexagonItinerariesV62FU::CVI_XLANE)
240 return (*Lanes = 1, CVI_XLANE);
241 else if (ItinUnits == HexagonItinerariesV62FU::CVI_SHIFT)
242 return (*Lanes = 1, CVI_SHIFT);
243
244 return (*Lanes = 0, CVI_NONE);
245}
246
247
248namespace llvm {
249namespace HexagonFUnits {
250bool isSlot0Only(unsigned units) {
251 return HexagonItinerariesV62FU::SLOT0 == units;
252}
253} // namespace HexagonFUnits
254} // namespace llvm
255
256namespace {
257
258class HexagonTargetAsmStreamer : public HexagonTargetStreamer {
259 formatted_raw_ostream &OS;
260
261public:
262 HexagonTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS,
263 MCInstPrinter &IP)
264 : HexagonTargetStreamer(S), OS(OS) {}
265
266 void prettyPrintAsm(MCInstPrinter &InstPrinter, uint64_t Address,
267 const MCInst &Inst, const MCSubtargetInfo &STI,
268 raw_ostream &OS) override {
269 assert(HexagonMCInstrInfo::isBundle(Inst));
270 assert(HexagonMCInstrInfo::bundleSize(Inst) <= HEXAGON_PACKET_SIZE);
271 std::string Buffer;
272 {
273 raw_string_ostream TempStream(Buffer);
274 for (auto &I : HexagonMCInstrInfo::bundleInstructions(MCI: Inst)) {
275 InstPrinter.printInst(MI: I.getInst(), Address, Annot: "", STI, OS&: TempStream);
276 TempStream << "\n";
277 }
278 }
279
280 std::string LoopString = "";
281 bool IsLoop0 = HexagonMCInstrInfo::isInnerLoop(MCI: Inst);
282 bool IsLoop1 = HexagonMCInstrInfo::isOuterLoop(MCI: Inst);
283 if (IsLoop0) {
284 LoopString += (IsLoop1 ? " :endloop01" : " :endloop0");
285 } else if (IsLoop1) {
286 LoopString += " :endloop1";
287 }
288
289 StringRef Contents(Buffer);
290 auto PacketBundle = Contents.rsplit(Separator: '\n');
291 auto HeadTail = PacketBundle.first.split(Separator: '\n');
292 StringRef Separator = "\n";
293 StringRef Indent = "\t";
294 OS << "\t{\n";
295 while (!HeadTail.first.empty()) {
296 StringRef InstTxt;
297 auto Duplex = HeadTail.first.split(Separator: '\v');
298 if (!Duplex.second.empty()) {
299 OS << Indent << Duplex.first << Separator;
300 InstTxt = Duplex.second;
301 } else if (!HeadTail.first.trim().starts_with(Prefix: "immext")) {
302 InstTxt = Duplex.first;
303 }
304 if (!InstTxt.empty())
305 OS << Indent << InstTxt << Separator;
306 HeadTail = HeadTail.second.split(Separator: '\n');
307 }
308
309 if (HexagonMCInstrInfo::isMemReorderDisabled(MCI: Inst))
310 OS << "\n\t} :mem_noshuf" << LoopString;
311 else
312 OS << "\t}" << LoopString;
313 }
314
315 void finish() override { finishAttributeSection(); }
316
317 void finishAttributeSection() override {}
318
319 void emitAttribute(unsigned Attribute, unsigned Value) override {
320 OS << "\t.attribute\t" << Attribute << ", " << Twine(Value);
321 if (getStreamer().isVerboseAsm()) {
322 StringRef Name = ELFAttrs::attrTypeAsString(
323 attr: Attribute, tagNameMap: HexagonAttrs::getHexagonAttributeTags());
324 if (!Name.empty())
325 OS << "\t// " << Name;
326 }
327 OS << "\n";
328 }
329};
330
331class HexagonTargetELFStreamer : public HexagonTargetStreamer {
332public:
333 MCELFStreamer &getStreamer() {
334 return static_cast<MCELFStreamer &>(Streamer);
335 }
336 HexagonTargetELFStreamer(MCStreamer &S, MCSubtargetInfo const &STI)
337 : HexagonTargetStreamer(S) {
338 getStreamer().getWriter().setELFHeaderEFlags(Hexagon_MC::GetELFFlags(STI));
339 }
340
341 void emitCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size,
342 unsigned ByteAlignment,
343 unsigned AccessSize) override {
344 HexagonMCELFStreamer &HexagonELFStreamer =
345 static_cast<HexagonMCELFStreamer &>(getStreamer());
346 HexagonELFStreamer.HexagonMCEmitCommonSymbol(
347 Symbol, Size, ByteAlignment: Align(ByteAlignment), AccessSize);
348 }
349
350 void emitLocalCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size,
351 unsigned ByteAlignment,
352 unsigned AccessSize) override {
353 HexagonMCELFStreamer &HexagonELFStreamer =
354 static_cast<HexagonMCELFStreamer &>(getStreamer());
355 HexagonELFStreamer.HexagonMCEmitLocalCommonSymbol(
356 Symbol, Size, ByteAlignment: Align(ByteAlignment), AccessSize);
357 }
358
359 void finish() override { finishAttributeSection(); }
360
361 void reset() override { AttributeSection = nullptr; }
362
363private:
364 MCSection *AttributeSection = nullptr;
365
366 void finishAttributeSection() override {
367 MCELFStreamer &S = getStreamer();
368 if (S.Contents.empty())
369 return;
370
371 S.emitAttributesSection(Vendor: "hexagon", Section: ".hexagon.attributes",
372 Type: ELF::SHT_HEXAGON_ATTRIBUTES, AttributeSection);
373 }
374
375 void emitAttribute(uint32_t Attribute, uint32_t Value) override {
376 getStreamer().setAttributeItem(Attribute, Value,
377 /*OverwriteExisting=*/true);
378 }
379};
380
381} // end anonymous namespace
382
383llvm::MCInstrInfo *llvm::createHexagonMCInstrInfo() {
384 MCInstrInfo *X = new MCInstrInfo();
385 InitHexagonMCInstrInfo(II: X);
386 return X;
387}
388
389static MCRegisterInfo *createHexagonMCRegisterInfo(const Triple &TT) {
390 MCRegisterInfo *X = new MCRegisterInfo();
391 InitHexagonMCRegisterInfo(RI: X, RA: Hexagon::R31, /*DwarfFlavour=*/0,
392 /*EHFlavour=*/0, /*PC=*/Hexagon::PC);
393 return X;
394}
395
396static MCAsmInfo *createHexagonMCAsmInfo(const MCRegisterInfo &MRI,
397 const Triple &TT,
398 const MCTargetOptions &Options) {
399 MCAsmInfo *MAI = new HexagonMCAsmInfo(TT, Options);
400
401 // VirtualFP = (R30 + #0).
402 MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(
403 L: nullptr, Register: MRI.getDwarfRegNum(Reg: Hexagon::R30, isEH: true), Offset: 0);
404 MAI->addInitialFrameState(Inst);
405
406 return MAI;
407}
408
409static MCInstPrinter *createHexagonMCInstPrinter(const Triple &T,
410 unsigned SyntaxVariant,
411 const MCAsmInfo &MAI,
412 const MCInstrInfo &MII,
413 const MCRegisterInfo &MRI)
414{
415 if (SyntaxVariant == 0)
416 return new HexagonInstPrinter(MAI, MII, MRI);
417 else
418 return nullptr;
419}
420
421static MCTargetStreamer *createMCAsmTargetStreamer(MCStreamer &S,
422 formatted_raw_ostream &OS,
423 MCInstPrinter *IP) {
424 return new HexagonTargetAsmStreamer(S, OS, *IP);
425}
426
427static MCStreamer *createMCStreamer(Triple const &T, MCContext &Context,
428 std::unique_ptr<MCAsmBackend> &&MAB,
429 std::unique_ptr<MCObjectWriter> &&OW,
430 std::unique_ptr<MCCodeEmitter> &&Emitter) {
431 return createHexagonELFStreamer(TT: T, Context, MAB: std::move(MAB), OW: std::move(OW),
432 CE: std::move(Emitter));
433}
434
435static MCTargetStreamer *
436createHexagonObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
437 return new HexagonTargetELFStreamer(S, STI);
438}
439
440static MCTargetStreamer *createHexagonNullTargetStreamer(MCStreamer &S) {
441 return new HexagonTargetStreamer(S);
442}
443
444[[maybe_unused]] static void clearFeature(MCSubtargetInfo *STI, uint64_t F) {
445 if (STI->hasFeature(Feature: F))
446 STI->ToggleFeature(FB: F);
447}
448
449[[maybe_unused]] static bool checkFeature(MCSubtargetInfo *STI, uint64_t F) {
450 return STI->hasFeature(Feature: F);
451}
452
453namespace {
454std::string selectHexagonFS(StringRef CPU, StringRef FS) {
455 SmallVector<StringRef, 3> Result;
456 if (!FS.empty())
457 Result.push_back(Elt: FS);
458
459 if (EnableHMX)
460 Result.push_back(Elt: "+hmx");
461
462 switch (EnableHVX) {
463 case Hexagon::ArchEnum::V5:
464 case Hexagon::ArchEnum::V55:
465 break;
466 case Hexagon::ArchEnum::V60:
467 Result.push_back(Elt: "+hvxv60");
468 break;
469 case Hexagon::ArchEnum::V62:
470 Result.push_back(Elt: "+hvxv62");
471 break;
472 case Hexagon::ArchEnum::V65:
473 Result.push_back(Elt: "+hvxv65");
474 break;
475 case Hexagon::ArchEnum::V66:
476 Result.push_back(Elt: "+hvxv66");
477 break;
478 case Hexagon::ArchEnum::V67:
479 Result.push_back(Elt: "+hvxv67");
480 break;
481 case Hexagon::ArchEnum::V68:
482 Result.push_back(Elt: "+hvxv68");
483 break;
484 case Hexagon::ArchEnum::V69:
485 Result.push_back(Elt: "+hvxv69");
486 break;
487 case Hexagon::ArchEnum::V71:
488 Result.push_back(Elt: "+hvxv71");
489 break;
490 case Hexagon::ArchEnum::V73:
491 Result.push_back(Elt: "+hvxv73");
492 break;
493 case Hexagon::ArchEnum::V75:
494 Result.push_back(Elt: "+hvxv75");
495 break;
496 case Hexagon::ArchEnum::V79:
497 Result.push_back(Elt: "+hvxv79");
498 break;
499 case Hexagon::ArchEnum::V81:
500 Result.push_back(Elt: "+hvxv81");
501 break;
502 case Hexagon::ArchEnum::V83:
503 Result.push_back(Elt: "+hvxv83");
504 break;
505 case Hexagon::ArchEnum::V85:
506 Result.push_back(Elt: "+hvxv85");
507 break;
508
509 case Hexagon::ArchEnum::Generic: {
510 Result.push_back(Elt: StringSwitch<StringRef>(CPU)
511 .Case(S: "hexagonv60", Value: "+hvxv60")
512 .Case(S: "hexagonv62", Value: "+hvxv62")
513 .Case(S: "hexagonv65", Value: "+hvxv65")
514 .Case(S: "hexagonv66", Value: "+hvxv66")
515 .Case(S: "hexagonv67", Value: "+hvxv67")
516 .Case(S: "hexagonv67t", Value: "+hvxv67")
517 .Case(S: "hexagonv68", Value: "+hvxv68")
518 .Case(S: "hexagonv69", Value: "+hvxv69")
519 .Case(S: "hexagonv71", Value: "+hvxv71")
520 .Case(S: "hexagonv71t", Value: "+hvxv71")
521 .Case(S: "hexagonv73", Value: "+hvxv73")
522 .Case(S: "hexagonv75", Value: "+hvxv75")
523 .Case(S: "hexagonv79", Value: "+hvxv79")
524 .Case(S: "hexagonv81", Value: "+hvxv81")
525 .Case(S: "hexagonv83", Value: "+hvxv83")
526 .Case(S: "hexagonv85", Value: "+hvxv85"));
527 break;
528 }
529 case Hexagon::ArchEnum::NoArch:
530 // Sentinel if -mhvx isn't specified
531 break;
532 }
533 if (EnableHvxIeeeFp)
534 Result.push_back(Elt: "+hvx-ieee-fp");
535 if (EnableHexagonCabac)
536 Result.push_back(Elt: "+cabac");
537 if (EnableHLX)
538 Result.push_back(Elt: "+hlx");
539
540 return join(Begin: Result.begin(), End: Result.end(), Separator: ",");
541}
542}
543
544static bool isCPUValid(StringRef CPU) {
545 return Hexagon::getCpu(CPU).has_value();
546}
547
548namespace {
549std::pair<std::string, std::string> selectCPUAndFS(StringRef CPU,
550 StringRef FS) {
551 std::pair<std::string, std::string> Result;
552 Result.first = std::string(Hexagon_MC::selectHexagonCPU(CPU));
553 Result.second = selectHexagonFS(CPU: Result.first, FS);
554 return Result;
555}
556std::mutex ArchSubtargetMutex;
557StringMap<std::unique_ptr<MCSubtargetInfo const>> ArchSubtarget;
558} // namespace
559
560MCSubtargetInfo const *
561Hexagon_MC::getArchSubtarget(MCSubtargetInfo const *STI) {
562 std::lock_guard<std::mutex> Lock(ArchSubtargetMutex);
563 auto Existing = ArchSubtarget.find(Key: STI->getCPU());
564 if (Existing == ArchSubtarget.end())
565 return nullptr;
566 return Existing->second.get();
567}
568
569FeatureBitset Hexagon_MC::completeHVXFeatures(const FeatureBitset &S) {
570 using namespace Hexagon;
571 // Make sure that +hvx-length turns hvx on, and that "hvx" alone
572 // turns on hvxvNN, corresponding to the existing ArchVNN.
573 FeatureBitset FB = S;
574 unsigned CpuArch = ArchV5;
575 for (unsigned F : {ArchV85, ArchV83, ArchV81, ArchV79, ArchV75, ArchV73,
576 ArchV71, ArchV69, ArchV68, ArchV67, ArchV66, ArchV65,
577 ArchV62, ArchV60, ArchV55, ArchV5}) {
578 if (!FB.test(I: F))
579 continue;
580 CpuArch = F;
581 break;
582 }
583 bool UseHvx = false;
584 for (unsigned F : {ExtensionHVX, ExtensionHVX64B, ExtensionHVX128B}) {
585 if (!FB.test(I: F))
586 continue;
587 UseHvx = true;
588 break;
589 }
590 bool HasHvxVer = false;
591 for (unsigned F :
592 {ExtensionHVXV60, ExtensionHVXV62, ExtensionHVXV65, ExtensionHVXV66,
593 ExtensionHVXV67, ExtensionHVXV68, ExtensionHVXV69, ExtensionHVXV71,
594 ExtensionHVXV73, ExtensionHVXV75, ExtensionHVXV79, ExtensionHVXV81,
595 ExtensionHVXV83, ExtensionHVXV85}) {
596 if (!FB.test(I: F))
597 continue;
598 HasHvxVer = true;
599 UseHvx = true;
600 break;
601 }
602
603 if (!UseHvx || HasHvxVer)
604 return FB;
605
606 // HasHvxVer is false, and UseHvx is true.
607 switch (CpuArch) {
608 case ArchV85:
609 FB.set(ExtensionHVXV85);
610 [[fallthrough]];
611 case ArchV83:
612 FB.set(ExtensionHVXV83);
613 [[fallthrough]];
614 case ArchV81:
615 FB.set(ExtensionHVXV81);
616 [[fallthrough]];
617 case ArchV79:
618 FB.set(ExtensionHVXV79);
619 [[fallthrough]];
620 case ArchV75:
621 FB.set(ExtensionHVXV75);
622 [[fallthrough]];
623 case ArchV73:
624 FB.set(ExtensionHVXV73);
625 [[fallthrough]];
626 case ArchV71:
627 FB.set(ExtensionHVXV71);
628 [[fallthrough]];
629 case ArchV69:
630 FB.set(ExtensionHVXV69);
631 [[fallthrough]];
632 case ArchV68:
633 FB.set(ExtensionHVXV68);
634 [[fallthrough]];
635 case ArchV67:
636 FB.set(ExtensionHVXV67);
637 [[fallthrough]];
638 case ArchV66:
639 FB.set(ExtensionHVXV66);
640 [[fallthrough]];
641 case ArchV65:
642 FB.set(ExtensionHVXV65);
643 [[fallthrough]];
644 case ArchV62:
645 FB.set(ExtensionHVXV62);
646 [[fallthrough]];
647 case ArchV60:
648 FB.set(ExtensionHVXV60);
649 break;
650 }
651 return FB;
652}
653
654MCSubtargetInfo *Hexagon_MC::createHexagonMCSubtargetInfo(const Triple &TT,
655 StringRef CPU,
656 StringRef FS) {
657 std::pair<std::string, std::string> Features = selectCPUAndFS(CPU, FS);
658 StringRef CPUName = Features.first;
659 StringRef ArchFS = Features.second;
660
661 MCSubtargetInfo *X = createHexagonMCSubtargetInfoImpl(
662 TT, CPU: CPUName, /*TuneCPU*/ CPUName, FS: ArchFS);
663 if (X != nullptr && (CPUName == "hexagonv67t" || CPUName == "hexagon71t"))
664 addArchSubtarget(STI: X, FS: ArchFS);
665
666 if (CPU == "help")
667 exit(status: 0);
668
669 if (!isCPUValid(CPU: CPUName.str())) {
670 errs() << "error: invalid CPU \"" << CPUName.str().c_str()
671 << "\" specified\n";
672 return nullptr;
673 }
674
675 // Add qfloat subtarget feature by default to v68 and above
676 // unless explicitly disabled
677 if (checkFeature(STI: X, F: Hexagon::ExtensionHVXV68) &&
678 !ArchFS.contains(Other: "-hvx-qfloat")) {
679 llvm::FeatureBitset Features = X->getFeatureBits();
680 X->setFeatureBits(Features.set(Hexagon::ExtensionHVXQFloat));
681 }
682
683 if (HexagonDisableDuplex) {
684 llvm::FeatureBitset Features = X->getFeatureBits();
685 X->setFeatureBits(Features.reset(I: Hexagon::FeatureDuplex));
686 }
687
688 X->setFeatureBits(completeHVXFeatures(S: X->getFeatureBits()));
689
690 // The Z-buffer instructions are grandfathered in for current
691 // architectures but omitted for new ones. Future instruction
692 // sets may introduce new/conflicting z-buffer instructions.
693 const bool ZRegOnDefault =
694 (CPUName == "hexagonv67") || (CPUName == "hexagonv66");
695 if (ZRegOnDefault) {
696 llvm::FeatureBitset Features = X->getFeatureBits();
697 X->setFeatureBits(Features.set(Hexagon::ExtensionZReg));
698 }
699
700 return X;
701}
702
703void Hexagon_MC::addArchSubtarget(MCSubtargetInfo const *STI, StringRef FS) {
704 assert(STI != nullptr);
705 if (STI->getCPU().contains(Other: "t")) {
706 auto ArchSTI = createHexagonMCSubtargetInfo(TT: STI->getTargetTriple(),
707 CPU: STI->getCPU().drop_back(), FS);
708 std::lock_guard<std::mutex> Lock(ArchSubtargetMutex);
709 ArchSubtarget[STI->getCPU()] =
710 std::unique_ptr<MCSubtargetInfo const>(ArchSTI);
711 }
712}
713
714std::optional<unsigned>
715Hexagon_MC::getHVXVersion(const FeatureBitset &Features) {
716 for (auto Arch : {Hexagon::ExtensionHVXV85, Hexagon::ExtensionHVXV83,
717 Hexagon::ExtensionHVXV81, Hexagon::ExtensionHVXV79,
718 Hexagon::ExtensionHVXV75, Hexagon::ExtensionHVXV73,
719 Hexagon::ExtensionHVXV71, Hexagon::ExtensionHVXV69,
720 Hexagon::ExtensionHVXV68, Hexagon::ExtensionHVXV67,
721 Hexagon::ExtensionHVXV66, Hexagon::ExtensionHVXV65,
722 Hexagon::ExtensionHVXV62, Hexagon::ExtensionHVXV60})
723 if (Features.test(I: Arch))
724 return Arch;
725 return {};
726}
727
728unsigned Hexagon_MC::getArchVersion(const FeatureBitset &Features) {
729 for (auto Arch :
730 {Hexagon::ArchV85, Hexagon::ArchV83, Hexagon::ArchV81, Hexagon::ArchV79,
731 Hexagon::ArchV75, Hexagon::ArchV73, Hexagon::ArchV71, Hexagon::ArchV69,
732 Hexagon::ArchV68, Hexagon::ArchV67, Hexagon::ArchV66, Hexagon::ArchV65,
733 Hexagon::ArchV62, Hexagon::ArchV60, Hexagon::ArchV55, Hexagon::ArchV5})
734 if (Features.test(I: Arch))
735 return Arch;
736 llvm_unreachable("Expected arch v5-v85");
737 return 0;
738}
739
740unsigned Hexagon_MC::GetELFFlags(const MCSubtargetInfo &STI) {
741 return StringSwitch<unsigned>(STI.getCPU())
742 .Case(S: "generic", Value: llvm::ELF::EF_HEXAGON_MACH_V5)
743 .Case(S: "hexagonv5", Value: llvm::ELF::EF_HEXAGON_MACH_V5)
744 .Case(S: "hexagonv55", Value: llvm::ELF::EF_HEXAGON_MACH_V55)
745 .Case(S: "hexagonv60", Value: llvm::ELF::EF_HEXAGON_MACH_V60)
746 .Case(S: "hexagonv62", Value: llvm::ELF::EF_HEXAGON_MACH_V62)
747 .Case(S: "hexagonv65", Value: llvm::ELF::EF_HEXAGON_MACH_V65)
748 .Case(S: "hexagonv66", Value: llvm::ELF::EF_HEXAGON_MACH_V66)
749 .Case(S: "hexagonv67", Value: llvm::ELF::EF_HEXAGON_MACH_V67)
750 .Case(S: "hexagonv67t", Value: llvm::ELF::EF_HEXAGON_MACH_V67T)
751 .Case(S: "hexagonv68", Value: llvm::ELF::EF_HEXAGON_MACH_V68)
752 .Case(S: "hexagonv69", Value: llvm::ELF::EF_HEXAGON_MACH_V69)
753 .Case(S: "hexagonv71", Value: llvm::ELF::EF_HEXAGON_MACH_V71)
754 .Case(S: "hexagonv71t", Value: llvm::ELF::EF_HEXAGON_MACH_V71T)
755 .Case(S: "hexagonv73", Value: llvm::ELF::EF_HEXAGON_MACH_V73)
756 .Case(S: "hexagonv75", Value: llvm::ELF::EF_HEXAGON_MACH_V75)
757 .Case(S: "hexagonv79", Value: llvm::ELF::EF_HEXAGON_MACH_V79)
758 .Case(S: "hexagonv81", Value: llvm::ELF::EF_HEXAGON_MACH_V81)
759 .Case(S: "hexagonv83", Value: llvm::ELF::EF_HEXAGON_MACH_V83)
760 .Case(S: "hexagonv85", Value: llvm::ELF::EF_HEXAGON_MACH_V85);
761}
762
763llvm::ArrayRef<MCPhysReg> Hexagon_MC::GetVectRegRev() {
764 const auto &RC = getHexagonMCRegisterClass(RC: Hexagon::VectRegRevRegClassID);
765 return ArrayRef(RC.begin(), RC.end());
766}
767
768namespace {
769class HexagonMCInstrAnalysis : public MCInstrAnalysis {
770public:
771 HexagonMCInstrAnalysis(MCInstrInfo const *Info) : MCInstrAnalysis(Info) {}
772
773 bool isUnconditionalBranch(MCInst const &Inst) const override {
774 //assert(!HexagonMCInstrInfo::isBundle(Inst));
775 return MCInstrAnalysis::isUnconditionalBranch(Inst);
776 }
777
778 bool isConditionalBranch(MCInst const &Inst) const override {
779 //assert(!HexagonMCInstrInfo::isBundle(Inst));
780 return MCInstrAnalysis::isConditionalBranch(Inst);
781 }
782
783 bool evaluateBranch(MCInst const &Inst, uint64_t Addr,
784 uint64_t Size, uint64_t &Target) const override {
785 if (!(isCall(Inst) || isUnconditionalBranch(Inst) ||
786 isConditionalBranch(Inst)))
787 return false;
788
789 //assert(!HexagonMCInstrInfo::isBundle(Inst));
790 if (!HexagonMCInstrInfo::isExtendable(MCII: *Info, MCI: Inst))
791 return false;
792 auto const &Extended(HexagonMCInstrInfo::getExtendableOperand(MCII: *Info, MCI: Inst));
793 assert(Extended.isExpr());
794 int64_t Value;
795 if (!Extended.getExpr()->evaluateAsAbsolute(Res&: Value))
796 return false;
797 Target = Value;
798 return true;
799 }
800
801 uint32_t getValueFromMask(uint32_t Instruction, uint32_t Mask) const {
802 uint32_t Result = 0;
803 uint32_t Offset = 0;
804 while (Mask) {
805 if (Instruction & (Mask & -Mask))
806 Result |= (1 << Offset);
807 Mask &= (Mask - 1);
808 ++Offset;
809 }
810 return Result;
811 }
812
813 std::vector<std::pair<uint64_t, uint64_t>>
814 findPltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents,
815 const MCSubtargetInfo &STI) const override {
816 // Do a lightweight parsing of PLT entries.
817 std::vector<std::pair<uint64_t, uint64_t>> Result;
818 for (uint64_t Byte = 0x0, End = PltContents.size(); Byte < End; Byte += 4) {
819 // Recognize immext(##gotpltn)
820 uint32_t ImmExt = support::endian::read32le(P: PltContents.data() + Byte);
821 if ((ImmExt & 0x00004000) != 0x00004000)
822 continue;
823 uint32_t LoadGotPlt =
824 support::endian::read32le(P: PltContents.data() + Byte + 4);
825 if ((LoadGotPlt & 0x6a49c00c) != 0x6a49c00c)
826 continue;
827 uint32_t Address = (getValueFromMask(Instruction: ImmExt, Mask: 0xfff3fff) << 6) +
828 getValueFromMask(Instruction: LoadGotPlt, Mask: 0x1f80) + PltSectionVA +
829 Byte;
830 Result.emplace_back(args: PltSectionVA + Byte, args&: Address);
831 }
832 return Result;
833 }
834};
835} // namespace
836
837static MCInstrAnalysis *createHexagonMCInstrAnalysis(const MCInstrInfo *Info) {
838 return new HexagonMCInstrAnalysis(Info);
839}
840
841// Force static initialization.
842extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
843LLVMInitializeHexagonTargetMC() {
844 // Register the MC asm info.
845 RegisterMCAsmInfoFn X(getTheHexagonTarget(), createHexagonMCAsmInfo);
846
847 // Register the MC instruction info.
848 TargetRegistry::RegisterMCInstrInfo(T&: getTheHexagonTarget(),
849 Fn: createHexagonMCInstrInfo);
850
851 // Register the MC register info.
852 TargetRegistry::RegisterMCRegInfo(T&: getTheHexagonTarget(),
853 Fn: createHexagonMCRegisterInfo);
854
855 // Register the MC subtarget info.
856 TargetRegistry::RegisterMCSubtargetInfo(
857 T&: getTheHexagonTarget(), Fn: Hexagon_MC::createHexagonMCSubtargetInfo);
858
859 // Register the MC Code Emitter
860 TargetRegistry::RegisterMCCodeEmitter(T&: getTheHexagonTarget(),
861 Fn: createHexagonMCCodeEmitter);
862
863 // Register the asm backend
864 TargetRegistry::RegisterMCAsmBackend(T&: getTheHexagonTarget(),
865 Fn: createHexagonAsmBackend);
866
867 // Register the MC instruction analyzer.
868 TargetRegistry::RegisterMCInstrAnalysis(T&: getTheHexagonTarget(),
869 Fn: createHexagonMCInstrAnalysis);
870
871 // Register the obj streamer
872 TargetRegistry::RegisterELFStreamer(T&: getTheHexagonTarget(), Fn: createMCStreamer);
873
874 // Register the obj target streamer
875 TargetRegistry::RegisterObjectTargetStreamer(
876 T&: getTheHexagonTarget(), Fn: createHexagonObjectTargetStreamer);
877
878 // Register the asm streamer
879 TargetRegistry::RegisterAsmTargetStreamer(T&: getTheHexagonTarget(),
880 Fn: createMCAsmTargetStreamer);
881
882 // Register the null streamer
883 TargetRegistry::RegisterNullTargetStreamer(T&: getTheHexagonTarget(),
884 Fn: createHexagonNullTargetStreamer);
885
886 // Register the MC Inst Printer
887 TargetRegistry::RegisterMCInstPrinter(T&: getTheHexagonTarget(),
888 Fn: createHexagonMCInstPrinter);
889}
890