1 //===-- HexagonMCTargetDesc.cpp - Hexagon Target Descriptions -------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file provides Hexagon specific target descriptions.
12 //===----------------------------------------------------------------------===//
14 #include "HexagonMCTargetDesc.h"
16 #include "HexagonMCAsmInfo.h"
17 #include "HexagonMCELFStreamer.h"
18 #include "MCTargetDesc/HexagonInstPrinter.h"
19 #include "llvm/MC/MCCodeGenInfo.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCELFStreamer.h"
22 #include "llvm/MC/MCInstrInfo.h"
23 #include "llvm/MC/MCObjectStreamer.h"
24 #include "llvm/MC/MCRegisterInfo.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/MC/MCSubtargetInfo.h"
27 #include "llvm/MC/MachineLocation.h"
28 #include "llvm/Support/ELF.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/TargetRegistry.h"
34 #define GET_INSTRINFO_MC_DESC
35 #include "HexagonGenInstrInfo.inc"
37 #define GET_SUBTARGETINFO_MC_DESC
38 #include "HexagonGenSubtargetInfo.inc"
40 #define GET_REGINFO_MC_DESC
41 #include "HexagonGenRegisterInfo.inc"
43 MCInstrInfo *llvm::createHexagonMCInstrInfo() {
44 MCInstrInfo *X = new MCInstrInfo();
45 InitHexagonMCInstrInfo(X);
49 static MCRegisterInfo *createHexagonMCRegisterInfo(StringRef TT) {
50 MCRegisterInfo *X = new MCRegisterInfo();
51 InitHexagonMCRegisterInfo(X, Hexagon::R0);
55 static MCSubtargetInfo *
56 createHexagonMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
57 MCSubtargetInfo *X = new MCSubtargetInfo();
58 InitHexagonMCSubtargetInfo(X, TT, CPU, FS);
63 class HexagonTargetAsmStreamer : public HexagonTargetStreamer {
65 HexagonTargetAsmStreamer(MCStreamer &S,
66 formatted_raw_ostream &, bool,
68 : HexagonTargetStreamer(S) {}
69 void prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
70 const MCInst &Inst, const MCSubtargetInfo &STI) override {
71 assert(HexagonMCInstrInfo::isBundle(Inst));
72 assert(HexagonMCInstrInfo::bundleSize(Inst) <= HEXAGON_PACKET_SIZE);
75 raw_string_ostream TempStream(Buffer);
76 InstPrinter.printInst(&Inst, TempStream, "", STI);
78 StringRef Contents(Buffer);
79 auto PacketBundle = Contents.rsplit('\n');
80 auto HeadTail = PacketBundle.first.split('\n');
81 auto Preamble = "\t{\n\t\t";
83 while(!HeadTail.first.empty()) {
86 auto Duplex = HeadTail.first.split('\v');
87 if(!Duplex.second.empty()){
88 OS << Duplex.first << "\n";
92 if(!HeadTail.first.startswith("immext"))
97 HeadTail = HeadTail.second.split('\n');
101 if(HexagonMCInstrInfo::bundleSize(Inst) != 0)
102 OS << "\n\t}" << PacketBundle.second;
108 class HexagonTargetELFStreamer : public HexagonTargetStreamer {
110 MCELFStreamer &getStreamer() {
111 return static_cast<MCELFStreamer &>(Streamer);
113 HexagonTargetELFStreamer(MCStreamer &S, MCSubtargetInfo const &STI)
114 : HexagonTargetStreamer(S) {
115 auto Bits = STI.getFeatureBits();
117 if (Bits.to_ullong() & llvm::Hexagon::ArchV5)
118 Flags = ELF::EF_HEXAGON_MACH_V5;
120 Flags = ELF::EF_HEXAGON_MACH_V4;
121 getStreamer().getAssembler().setELFHeaderEFlags(Flags);
123 void EmitCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size,
124 unsigned ByteAlignment,
125 unsigned AccessSize) override {
126 HexagonMCELFStreamer &HexagonELFStreamer =
127 static_cast<HexagonMCELFStreamer &>(getStreamer());
128 HexagonELFStreamer.HexagonMCEmitCommonSymbol(Symbol, Size, ByteAlignment,
131 void EmitLocalCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size,
132 unsigned ByteAlignment,
133 unsigned AccessSize) override {
134 HexagonMCELFStreamer &HexagonELFStreamer =
135 static_cast<HexagonMCELFStreamer &>(getStreamer());
136 HexagonELFStreamer.HexagonMCEmitLocalCommonSymbol(
137 Symbol, Size, ByteAlignment, AccessSize);
142 static MCAsmInfo *createHexagonMCAsmInfo(const MCRegisterInfo &MRI,
144 MCAsmInfo *MAI = new HexagonMCAsmInfo(TT);
146 // VirtualFP = (R30 + #0).
147 MCCFIInstruction Inst =
148 MCCFIInstruction::createDefCfa(nullptr, Hexagon::R30, 0);
149 MAI->addInitialFrameState(Inst);
154 static MCCodeGenInfo *createHexagonMCCodeGenInfo(StringRef TT, Reloc::Model RM,
156 CodeGenOpt::Level OL) {
157 MCCodeGenInfo *X = new MCCodeGenInfo();
158 // For the time being, use static relocations, since there's really no
159 // support for PIC yet.
160 X->initMCCodeGenInfo(Reloc::Static, CM, OL);
164 static MCInstPrinter *createHexagonMCInstPrinter(const Triple &T,
165 unsigned SyntaxVariant,
166 const MCAsmInfo &MAI,
167 const MCInstrInfo &MII,
168 const MCRegisterInfo &MRI) {
169 if (SyntaxVariant == 0)
170 return (new HexagonInstPrinter(MAI, MII, MRI));
175 MCTargetStreamer *createMCAsmTargetStreamer(
176 MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
178 return new HexagonTargetAsmStreamer(S, OS, IsVerboseAsm, *InstPrint);
181 static MCStreamer *createMCStreamer(Triple const &T, MCContext &Context,
182 MCAsmBackend &MAB, raw_pwrite_stream &OS,
183 MCCodeEmitter *Emitter, bool RelaxAll) {
184 return createHexagonELFStreamer(Context, MAB, OS, Emitter);
187 static MCTargetStreamer *
188 createHexagonObjectTargetStreamer(MCStreamer &S, MCSubtargetInfo const &STI) {
189 return new HexagonTargetELFStreamer(S, STI);
192 // Force static initialization.
193 extern "C" void LLVMInitializeHexagonTargetMC() {
194 // Register the MC asm info.
195 RegisterMCAsmInfoFn X(TheHexagonTarget, createHexagonMCAsmInfo);
197 // Register the MC codegen info.
198 TargetRegistry::RegisterMCCodeGenInfo(TheHexagonTarget,
199 createHexagonMCCodeGenInfo);
201 // Register the MC instruction info.
202 TargetRegistry::RegisterMCInstrInfo(TheHexagonTarget,
203 createHexagonMCInstrInfo);
205 // Register the MC register info.
206 TargetRegistry::RegisterMCRegInfo(TheHexagonTarget,
207 createHexagonMCRegisterInfo);
209 // Register the MC subtarget info.
210 TargetRegistry::RegisterMCSubtargetInfo(TheHexagonTarget,
211 createHexagonMCSubtargetInfo);
213 // Register the MC Code Emitter
214 TargetRegistry::RegisterMCCodeEmitter(TheHexagonTarget,
215 createHexagonMCCodeEmitter);
217 // Register the asm backend
218 TargetRegistry::RegisterMCAsmBackend(TheHexagonTarget,
219 createHexagonAsmBackend);
221 // Register the obj streamer
222 TargetRegistry::RegisterELFStreamer(TheHexagonTarget, createMCStreamer);
224 // Register the asm streamer
225 TargetRegistry::RegisterAsmTargetStreamer(TheHexagonTarget,
226 createMCAsmTargetStreamer);
228 // Register the MC Inst Printer
229 TargetRegistry::RegisterMCInstPrinter(TheHexagonTarget,
230 createHexagonMCInstPrinter);
232 TargetRegistry::RegisterObjectTargetStreamer(
233 TheHexagonTarget, createHexagonObjectTargetStreamer);