1 //===-- AVRMCTargetDesc.cpp - AVR Target Descriptions ---------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file provides AVR specific target descriptions.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "AVRMCTargetDesc.h"
15 #include "AVRELFStreamer.h"
16 #include "AVRMCAsmInfo.h"
17 #include "AVRTargetStreamer.h"
18 #include "InstPrinter/AVRInstPrinter.h"
19 
20 #include "llvm/MC/MCELFStreamer.h"
21 #include "llvm/MC/MCCodeEmitter.h"
22 #include "llvm/MC/MCInstrInfo.h"
23 #include "llvm/MC/MCRegisterInfo.h"
24 #include "llvm/MC/MCSubtargetInfo.h"
25 #include "llvm/Support/TargetRegistry.h"
26 
27 #define GET_INSTRINFO_MC_DESC
28 #include "AVRGenInstrInfo.inc"
29 
30 #define GET_SUBTARGETINFO_MC_DESC
31 #include "AVRGenSubtargetInfo.inc"
32 
33 #define GET_REGINFO_MC_DESC
34 #include "AVRGenRegisterInfo.inc"
35 
36 using namespace llvm;
37 
38 static MCInstrInfo *createAVRMCInstrInfo() {
39   MCInstrInfo *X = new MCInstrInfo();
40   InitAVRMCInstrInfo(X);
41 
42   return X;
43 }
44 
45 static MCRegisterInfo *createAVRMCRegisterInfo(const Triple &TT) {
46   MCRegisterInfo *X = new MCRegisterInfo();
47   InitAVRMCRegisterInfo(X, 0);
48 
49   return X;
50 }
51 
52 static MCSubtargetInfo *createAVRMCSubtargetInfo(const Triple &TT,
53                                                  StringRef CPU, StringRef FS) {
54   return createAVRMCSubtargetInfoImpl(TT, CPU, FS);
55 }
56 
57 static MCInstPrinter *createAVRMCInstPrinter(const Triple &T,
58                                              unsigned SyntaxVariant,
59                                              const MCAsmInfo &MAI,
60                                              const MCInstrInfo &MII,
61                                              const MCRegisterInfo &MRI) {
62   if (SyntaxVariant == 0) {
63     return new AVRInstPrinter(MAI, MII, MRI);
64   }
65 
66   return nullptr;
67 }
68 
69 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
70                                     std::unique_ptr<MCAsmBackend> &&MAB,
71                                     raw_pwrite_stream &OS,
72                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
73                                     bool RelaxAll) {
74   return createELFStreamer(Context, std::move(MAB), OS,
75       std::move(Emitter), RelaxAll);
76 }
77 
78 static MCTargetStreamer *
79 createAVRObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
80   return new AVRELFStreamer(S, STI);
81 }
82 
83 static MCTargetStreamer *createMCAsmTargetStreamer(MCStreamer &S,
84                                                    formatted_raw_ostream &OS,
85                                                    MCInstPrinter *InstPrint,
86                                                    bool isVerboseAsm) {
87   return new AVRTargetAsmStreamer(S);
88 }
89 
90 extern "C" void LLVMInitializeAVRTargetMC() {
91   // Register the MC asm info.
92   RegisterMCAsmInfo<AVRMCAsmInfo> X(getTheAVRTarget());
93 
94   // Register the MC instruction info.
95   TargetRegistry::RegisterMCInstrInfo(getTheAVRTarget(), createAVRMCInstrInfo);
96 
97   // Register the MC register info.
98   TargetRegistry::RegisterMCRegInfo(getTheAVRTarget(), createAVRMCRegisterInfo);
99 
100   // Register the MC subtarget info.
101   TargetRegistry::RegisterMCSubtargetInfo(getTheAVRTarget(),
102                                           createAVRMCSubtargetInfo);
103 
104   // Register the MCInstPrinter.
105   TargetRegistry::RegisterMCInstPrinter(getTheAVRTarget(),
106                                         createAVRMCInstPrinter);
107 
108   // Register the MC Code Emitter
109   TargetRegistry::RegisterMCCodeEmitter(getTheAVRTarget(), createAVRMCCodeEmitter);
110 
111   // Register the ELF streamer
112   TargetRegistry::RegisterELFStreamer(getTheAVRTarget(), createMCStreamer);
113 
114   // Register the obj target streamer.
115   TargetRegistry::RegisterObjectTargetStreamer(getTheAVRTarget(),
116                                                createAVRObjectTargetStreamer);
117 
118   // Register the asm target streamer.
119   TargetRegistry::RegisterAsmTargetStreamer(getTheAVRTarget(),
120                                             createMCAsmTargetStreamer);
121 
122   // Register the asm backend (as little endian).
123   TargetRegistry::RegisterMCAsmBackend(getTheAVRTarget(), createAVRAsmBackend);
124 }
125 
126