1 //===-- CSKYMCTargetDesc.cpp - CSKY 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 CSKY specific target descriptions.
10 ///
11 //===----------------------------------------------------------------------===//
12 
13 #include "CSKYMCTargetDesc.h"
14 #include "CSKYAsmBackend.h"
15 #include "CSKYELFStreamer.h"
16 #include "CSKYInstPrinter.h"
17 #include "CSKYMCAsmInfo.h"
18 #include "CSKYMCCodeEmitter.h"
19 #include "CSKYTargetStreamer.h"
20 #include "TargetInfo/CSKYTargetInfo.h"
21 #include "llvm/MC/MCAssembler.h"
22 #include "llvm/MC/MCInstrInfo.h"
23 #include "llvm/MC/MCRegisterInfo.h"
24 #include "llvm/MC/MCSubtargetInfo.h"
25 #include "llvm/MC/TargetRegistry.h"
26 
27 #define GET_INSTRINFO_MC_DESC
28 #include "CSKYGenInstrInfo.inc"
29 
30 #define GET_REGINFO_MC_DESC
31 #include "CSKYGenRegisterInfo.inc"
32 
33 #define GET_SUBTARGETINFO_MC_DESC
34 #include "CSKYGenSubtargetInfo.inc"
35 
36 using namespace llvm;
37 
38 static MCAsmInfo *createCSKYMCAsmInfo(const MCRegisterInfo &MRI,
39                                       const Triple &TT,
40                                       const MCTargetOptions &Options) {
41   MCAsmInfo *MAI = new CSKYMCAsmInfo(TT);
42 
43   // Initial state of the frame pointer is SP.
44   unsigned Reg = MRI.getDwarfRegNum(CSKY::R14, true);
45   MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(nullptr, Reg, 0);
46   MAI->addInitialFrameState(Inst);
47   return MAI;
48 }
49 
50 static MCInstrInfo *createCSKYMCInstrInfo() {
51   MCInstrInfo *Info = new MCInstrInfo();
52   InitCSKYMCInstrInfo(Info);
53   return Info;
54 }
55 
56 static MCInstPrinter *createCSKYMCInstPrinter(const Triple &T,
57                                               unsigned SyntaxVariant,
58                                               const MCAsmInfo &MAI,
59                                               const MCInstrInfo &MII,
60                                               const MCRegisterInfo &MRI) {
61   return new CSKYInstPrinter(MAI, MII, MRI);
62 }
63 
64 static MCRegisterInfo *createCSKYMCRegisterInfo(const Triple &TT) {
65   MCRegisterInfo *Info = new MCRegisterInfo();
66   InitCSKYMCRegisterInfo(Info, CSKY::R15);
67   return Info;
68 }
69 
70 static MCSubtargetInfo *createCSKYMCSubtargetInfo(const Triple &TT,
71                                                   StringRef CPU, StringRef FS) {
72   std::string CPUName = std::string(CPU);
73   if (CPUName.empty())
74     CPUName = "generic";
75   return createCSKYMCSubtargetInfoImpl(TT, CPUName, /*TuneCPU=*/CPUName, FS);
76 }
77 
78 static MCTargetStreamer *
79 createCSKYObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
80   const Triple &TT = STI.getTargetTriple();
81   if (TT.isOSBinFormatELF())
82     return new CSKYTargetELFStreamer(S, STI);
83   return nullptr;
84 }
85 
86 static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
87                                      std::unique_ptr<MCAsmBackend> &&MAB,
88                                      std::unique_ptr<MCObjectWriter> &&OW,
89                                      std::unique_ptr<MCCodeEmitter> &&Emitter,
90                                      bool RelaxAll) {
91   CSKYELFStreamer *S = new CSKYELFStreamer(Ctx, std::move(MAB), std::move(OW),
92                                            std::move(Emitter));
93 
94   if (RelaxAll)
95     S->getAssembler().setRelaxAll(true);
96   return S;
97 }
98 
99 static MCTargetStreamer *createCSKYAsmTargetStreamer(MCStreamer &S,
100                                                      formatted_raw_ostream &OS,
101                                                      MCInstPrinter *InstPrinter,
102                                                      bool isVerboseAsm) {
103   return new CSKYTargetAsmStreamer(S, OS);
104 }
105 
106 static MCTargetStreamer *createCSKYNullTargetStreamer(MCStreamer &S) {
107   return new CSKYTargetStreamer(S);
108 }
109 
110 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeCSKYTargetMC() {
111   auto &CSKYTarget = getTheCSKYTarget();
112   TargetRegistry::RegisterMCAsmBackend(CSKYTarget, createCSKYAsmBackend);
113   TargetRegistry::RegisterMCAsmInfo(CSKYTarget, createCSKYMCAsmInfo);
114   TargetRegistry::RegisterMCInstrInfo(CSKYTarget, createCSKYMCInstrInfo);
115   TargetRegistry::RegisterMCRegInfo(CSKYTarget, createCSKYMCRegisterInfo);
116   TargetRegistry::RegisterMCCodeEmitter(CSKYTarget, createCSKYMCCodeEmitter);
117   TargetRegistry::RegisterMCInstPrinter(CSKYTarget, createCSKYMCInstPrinter);
118   TargetRegistry::RegisterMCSubtargetInfo(CSKYTarget,
119                                           createCSKYMCSubtargetInfo);
120   TargetRegistry::RegisterELFStreamer(CSKYTarget, createELFStreamer);
121   TargetRegistry::RegisterObjectTargetStreamer(CSKYTarget,
122                                                createCSKYObjectTargetStreamer);
123   TargetRegistry::RegisterAsmTargetStreamer(CSKYTarget,
124                                             createCSKYAsmTargetStreamer);
125   // Register the null target streamer.
126   TargetRegistry::RegisterNullTargetStreamer(CSKYTarget,
127                                              createCSKYNullTargetStreamer);
128 }
129