1 //===-- WebAssemblyMCTargetDesc.cpp - WebAssembly 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 /// \file
11 /// \brief This file provides WebAssembly-specific target descriptions.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "WebAssemblyMCTargetDesc.h"
16 #include "InstPrinter/WebAssemblyInstPrinter.h"
17 #include "WebAssemblyMCAsmInfo.h"
18 #include "WebAssemblyTargetStreamer.h"
19 #include "llvm/MC/MCCodeGenInfo.h"
20 #include "llvm/MC/MCInstrInfo.h"
21 #include "llvm/MC/MCRegisterInfo.h"
22 #include "llvm/MC/MCSubtargetInfo.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/TargetRegistry.h"
25 using namespace llvm;
26 
27 #define DEBUG_TYPE "wasm-mc-target-desc"
28 
29 #define GET_INSTRINFO_MC_DESC
30 #include "WebAssemblyGenInstrInfo.inc"
31 
32 #define GET_SUBTARGETINFO_MC_DESC
33 #include "WebAssemblyGenSubtargetInfo.inc"
34 
35 #define GET_REGINFO_MC_DESC
36 #include "WebAssemblyGenRegisterInfo.inc"
37 
38 static MCAsmInfo *createMCAsmInfo(const MCRegisterInfo & /*MRI*/,
39                                   const Triple &TT) {
40   return new WebAssemblyMCAsmInfo(TT);
41 }
42 
43 static MCCodeGenInfo *createMCCodeGenInfo(const Triple & /*TT*/,
44                                           Reloc::Model /*RM*/,
45                                           CodeModel::Model CM,
46                                           CodeGenOpt::Level OL) {
47   CodeModel::Model M = (CM == CodeModel::Default || CM == CodeModel::JITDefault)
48                            ? CodeModel::Large
49                            : CM;
50   if (M != CodeModel::Large)
51     report_fatal_error("Non-large code models are not supported yet");
52   MCCodeGenInfo *CGI = new MCCodeGenInfo();
53   CGI->initMCCodeGenInfo(Reloc::PIC_, CM, OL);
54   return CGI;
55 }
56 
57 static MCInstrInfo *createMCInstrInfo() {
58   MCInstrInfo *X = new MCInstrInfo();
59   InitWebAssemblyMCInstrInfo(X);
60   return X;
61 }
62 
63 static MCRegisterInfo *createMCRegisterInfo(const Triple & /*T*/) {
64   MCRegisterInfo *X = new MCRegisterInfo();
65   InitWebAssemblyMCRegisterInfo(X, 0);
66   return X;
67 }
68 
69 static MCInstPrinter *createMCInstPrinter(const Triple & /*T*/,
70                                           unsigned SyntaxVariant,
71                                           const MCAsmInfo &MAI,
72                                           const MCInstrInfo &MII,
73                                           const MCRegisterInfo &MRI) {
74   assert(SyntaxVariant == 0 && "WebAssembly only has one syntax variant");
75   return new WebAssemblyInstPrinter(MAI, MII, MRI);
76 }
77 
78 static MCCodeEmitter *createCodeEmitter(const MCInstrInfo &MCII,
79                                         const MCRegisterInfo & /*MRI*/,
80                                         MCContext & /*Ctx*/) {
81   return createWebAssemblyMCCodeEmitter(MCII);
82 }
83 
84 static MCAsmBackend *createAsmBackend(const Target & /*T*/,
85                                       const MCRegisterInfo & /*MRI*/,
86                                       const Triple &TT, StringRef /*CPU*/) {
87   return createWebAssemblyAsmBackend(TT);
88 }
89 
90 static MCSubtargetInfo *createMCSubtargetInfo(const Triple &TT, StringRef CPU,
91                                               StringRef FS) {
92   return createWebAssemblyMCSubtargetInfoImpl(TT, CPU, FS);
93 }
94 
95 static MCTargetStreamer *
96 createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo & /*STI*/) {
97   return new WebAssemblyTargetELFStreamer(S);
98 }
99 
100 static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
101                                                  formatted_raw_ostream &OS,
102                                                  MCInstPrinter * /*InstPrint*/,
103                                                  bool /*isVerboseAsm*/) {
104   return new WebAssemblyTargetAsmStreamer(S, OS);
105 }
106 
107 // Force static initialization.
108 extern "C" void LLVMInitializeWebAssemblyTargetMC() {
109   for (Target *T : {&TheWebAssemblyTarget32, &TheWebAssemblyTarget64}) {
110     // Register the MC asm info.
111     RegisterMCAsmInfoFn X(*T, createMCAsmInfo);
112 
113     // Register the MC instruction info.
114     TargetRegistry::RegisterMCInstrInfo(*T, createMCInstrInfo);
115 
116     // Register the MC codegen info.
117     TargetRegistry::RegisterMCCodeGenInfo(*T, createMCCodeGenInfo);
118 
119     // Register the MC register info.
120     TargetRegistry::RegisterMCRegInfo(*T, createMCRegisterInfo);
121 
122     // Register the MCInstPrinter.
123     TargetRegistry::RegisterMCInstPrinter(*T, createMCInstPrinter);
124 
125     // Register the MC code emitter.
126     TargetRegistry::RegisterMCCodeEmitter(*T, createCodeEmitter);
127 
128     // Register the ASM Backend.
129     TargetRegistry::RegisterMCAsmBackend(*T, createAsmBackend);
130 
131     // Register the MC subtarget info.
132     TargetRegistry::RegisterMCSubtargetInfo(*T, createMCSubtargetInfo);
133 
134     // Register the object target streamer.
135     TargetRegistry::RegisterObjectTargetStreamer(*T,
136                                                  createObjectTargetStreamer);
137     // Register the asm target streamer.
138     TargetRegistry::RegisterAsmTargetStreamer(*T, createAsmTargetStreamer);
139   }
140 }
141