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 "HexagonMCAsmInfo.h"
15 #include "HexagonMCELFStreamer.h"
16 #include "HexagonMCTargetDesc.h"
17 #include "MCTargetDesc/HexagonInstPrinter.h"
18 #include "llvm/MC/MCCodeGenInfo.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCELFStreamer.h"
21 #include "llvm/MC/MCInstrInfo.h"
22 #include "llvm/MC/MCObjectStreamer.h"
23 #include "llvm/MC/MCRegisterInfo.h"
24 #include "llvm/MC/MCStreamer.h"
25 #include "llvm/MC/MCSubtargetInfo.h"
26 #include "llvm/MC/MachineLocation.h"
27 #include "llvm/Support/ELF.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/TargetRegistry.h"
33 #define GET_INSTRINFO_MC_DESC
34 #include "HexagonGenInstrInfo.inc"
36 #define GET_SUBTARGETINFO_MC_DESC
37 #include "HexagonGenSubtargetInfo.inc"
39 #define GET_REGINFO_MC_DESC
40 #include "HexagonGenRegisterInfo.inc"
42 MCInstrInfo *llvm::createHexagonMCInstrInfo() {
43 MCInstrInfo *X = new MCInstrInfo();
44 InitHexagonMCInstrInfo(X);
48 static MCRegisterInfo *createHexagonMCRegisterInfo(StringRef TT) {
49 MCRegisterInfo *X = new MCRegisterInfo();
50 InitHexagonMCRegisterInfo(X, Hexagon::R0);
54 static MCSubtargetInfo *
55 createHexagonMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
56 MCSubtargetInfo *X = new MCSubtargetInfo();
57 InitHexagonMCSubtargetInfo(X, TT, CPU, FS);
62 class HexagonTargetELFStreamer : public HexagonTargetStreamer {
64 MCELFStreamer &getStreamer() {
65 return static_cast<MCELFStreamer &>(Streamer);
67 HexagonTargetELFStreamer(MCStreamer &S, MCSubtargetInfo const &STI)
68 : HexagonTargetStreamer(S) {
69 auto Bits = STI.getFeatureBits();
71 if (Bits.to_ullong() & llvm::Hexagon::ArchV5)
72 Flags = ELF::EF_HEXAGON_MACH_V5;
74 Flags = ELF::EF_HEXAGON_MACH_V4;
75 getStreamer().getAssembler().setELFHeaderEFlags(Flags);
77 void EmitCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size,
78 unsigned ByteAlignment,
79 unsigned AccessSize) override {
80 HexagonMCELFStreamer &HexagonELFStreamer =
81 static_cast<HexagonMCELFStreamer &>(getStreamer());
82 HexagonELFStreamer.HexagonMCEmitCommonSymbol(Symbol, Size, ByteAlignment,
85 void EmitLocalCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size,
86 unsigned ByteAlignment,
87 unsigned AccessSize) override {
88 HexagonMCELFStreamer &HexagonELFStreamer =
89 static_cast<HexagonMCELFStreamer &>(getStreamer());
90 HexagonELFStreamer.HexagonMCEmitLocalCommonSymbol(
91 Symbol, Size, ByteAlignment, AccessSize);
96 static MCAsmInfo *createHexagonMCAsmInfo(const MCRegisterInfo &MRI,
98 MCAsmInfo *MAI = new HexagonMCAsmInfo(TT);
100 // VirtualFP = (R30 + #0).
101 MCCFIInstruction Inst =
102 MCCFIInstruction::createDefCfa(nullptr, Hexagon::R30, 0);
103 MAI->addInitialFrameState(Inst);
108 static MCCodeGenInfo *createHexagonMCCodeGenInfo(StringRef TT, Reloc::Model RM,
110 CodeGenOpt::Level OL) {
111 MCCodeGenInfo *X = new MCCodeGenInfo();
112 // For the time being, use static relocations, since there's really no
113 // support for PIC yet.
114 X->initMCCodeGenInfo(Reloc::Static, CM, OL);
118 static MCInstPrinter *createHexagonMCInstPrinter(const Triple &T,
119 unsigned SyntaxVariant,
120 const MCAsmInfo &MAI,
121 const MCInstrInfo &MII,
122 const MCRegisterInfo &MRI) {
123 if (SyntaxVariant == 0)
124 return (new HexagonInstPrinter(MAI, MII, MRI));
129 static MCStreamer *createMCStreamer(Triple const &T, MCContext &Context,
130 MCAsmBackend &MAB, raw_pwrite_stream &OS,
131 MCCodeEmitter *Emitter, bool RelaxAll) {
132 return createHexagonELFStreamer(Context, MAB, OS, Emitter);
135 static MCTargetStreamer *
136 createHexagonObjectTargetStreamer(MCStreamer &S, MCSubtargetInfo const &STI) {
137 return new HexagonTargetELFStreamer(S, STI);
140 // Force static initialization.
141 extern "C" void LLVMInitializeHexagonTargetMC() {
142 // Register the MC asm info.
143 RegisterMCAsmInfoFn X(TheHexagonTarget, createHexagonMCAsmInfo);
145 // Register the MC codegen info.
146 TargetRegistry::RegisterMCCodeGenInfo(TheHexagonTarget,
147 createHexagonMCCodeGenInfo);
149 // Register the MC instruction info.
150 TargetRegistry::RegisterMCInstrInfo(TheHexagonTarget,
151 createHexagonMCInstrInfo);
153 // Register the MC register info.
154 TargetRegistry::RegisterMCRegInfo(TheHexagonTarget,
155 createHexagonMCRegisterInfo);
157 // Register the MC subtarget info.
158 TargetRegistry::RegisterMCSubtargetInfo(TheHexagonTarget,
159 createHexagonMCSubtargetInfo);
161 // Register the MC Code Emitter
162 TargetRegistry::RegisterMCCodeEmitter(TheHexagonTarget,
163 createHexagonMCCodeEmitter);
165 // Register the asm backend
166 TargetRegistry::RegisterMCAsmBackend(TheHexagonTarget,
167 createHexagonAsmBackend);
169 // Register the obj streamer
170 TargetRegistry::RegisterELFStreamer(TheHexagonTarget, createMCStreamer);
172 // Register the MC Inst Printer
173 TargetRegistry::RegisterMCInstPrinter(TheHexagonTarget,
174 createHexagonMCInstPrinter);
176 TargetRegistry::RegisterObjectTargetStreamer(
177 TheHexagonTarget, createHexagonObjectTargetStreamer);