1 //===-- WebAssemblyMCTargetDesc.cpp - WebAssembly 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 /// \file
10 /// This file provides WebAssembly-specific target descriptions.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "WebAssemblyMCTargetDesc.h"
15 #include "InstPrinter/WebAssemblyInstPrinter.h"
16 #include "WebAssemblyMCAsmInfo.h"
17 #include "WebAssemblyTargetStreamer.h"
18 #include "llvm/MC/MCInstrInfo.h"
19 #include "llvm/MC/MCRegisterInfo.h"
20 #include "llvm/MC/MCSubtargetInfo.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/Support/TargetRegistry.h"
23 using namespace llvm;
24 
25 #define DEBUG_TYPE "wasm-mc-target-desc"
26 
27 #define GET_INSTRINFO_MC_DESC
28 #include "WebAssemblyGenInstrInfo.inc"
29 
30 #define GET_SUBTARGETINFO_MC_DESC
31 #include "WebAssemblyGenSubtargetInfo.inc"
32 
33 #define GET_REGINFO_MC_DESC
34 #include "WebAssemblyGenRegisterInfo.inc"
35 
36 static MCAsmInfo *createMCAsmInfo(const MCRegisterInfo & /*MRI*/,
37                                   const Triple &TT) {
38   return new WebAssemblyMCAsmInfo(TT);
39 }
40 
41 static MCInstrInfo *createMCInstrInfo() {
42   auto *X = new MCInstrInfo();
43   InitWebAssemblyMCInstrInfo(X);
44   return X;
45 }
46 
47 static MCRegisterInfo *createMCRegisterInfo(const Triple & /*T*/) {
48   auto *X = new MCRegisterInfo();
49   InitWebAssemblyMCRegisterInfo(X, 0);
50   return X;
51 }
52 
53 static MCInstPrinter *createMCInstPrinter(const Triple & /*T*/,
54                                           unsigned SyntaxVariant,
55                                           const MCAsmInfo &MAI,
56                                           const MCInstrInfo &MII,
57                                           const MCRegisterInfo &MRI) {
58   assert(SyntaxVariant == 0 && "WebAssembly only has one syntax variant");
59   return new WebAssemblyInstPrinter(MAI, MII, MRI);
60 }
61 
62 static MCCodeEmitter *createCodeEmitter(const MCInstrInfo &MCII,
63                                         const MCRegisterInfo & /*MRI*/,
64                                         MCContext &Ctx) {
65   return createWebAssemblyMCCodeEmitter(MCII);
66 }
67 
68 static MCAsmBackend *createAsmBackend(const Target & /*T*/,
69                                       const MCSubtargetInfo &STI,
70                                       const MCRegisterInfo & /*MRI*/,
71                                       const MCTargetOptions & /*Options*/) {
72   return createWebAssemblyAsmBackend(STI.getTargetTriple());
73 }
74 
75 static MCSubtargetInfo *createMCSubtargetInfo(const Triple &TT, StringRef CPU,
76                                               StringRef FS) {
77   return createWebAssemblyMCSubtargetInfoImpl(TT, CPU, FS);
78 }
79 
80 static MCTargetStreamer *
81 createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
82   return new WebAssemblyTargetWasmStreamer(S);
83 }
84 
85 static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
86                                                  formatted_raw_ostream &OS,
87                                                  MCInstPrinter * /*InstPrint*/,
88                                                  bool /*isVerboseAsm*/) {
89   return new WebAssemblyTargetAsmStreamer(S, OS);
90 }
91 
92 static MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) {
93   return new WebAssemblyTargetNullStreamer(S);
94 }
95 
96 // Force static initialization.
97 extern "C" void LLVMInitializeWebAssemblyTargetMC() {
98   for (Target *T :
99        {&getTheWebAssemblyTarget32(), &getTheWebAssemblyTarget64()}) {
100     // Register the MC asm info.
101     RegisterMCAsmInfoFn X(*T, createMCAsmInfo);
102 
103     // Register the MC instruction info.
104     TargetRegistry::RegisterMCInstrInfo(*T, createMCInstrInfo);
105 
106     // Register the MC register info.
107     TargetRegistry::RegisterMCRegInfo(*T, createMCRegisterInfo);
108 
109     // Register the MCInstPrinter.
110     TargetRegistry::RegisterMCInstPrinter(*T, createMCInstPrinter);
111 
112     // Register the MC code emitter.
113     TargetRegistry::RegisterMCCodeEmitter(*T, createCodeEmitter);
114 
115     // Register the ASM Backend.
116     TargetRegistry::RegisterMCAsmBackend(*T, createAsmBackend);
117 
118     // Register the MC subtarget info.
119     TargetRegistry::RegisterMCSubtargetInfo(*T, createMCSubtargetInfo);
120 
121     // Register the object target streamer.
122     TargetRegistry::RegisterObjectTargetStreamer(*T,
123                                                  createObjectTargetStreamer);
124     // Register the asm target streamer.
125     TargetRegistry::RegisterAsmTargetStreamer(*T, createAsmTargetStreamer);
126     // Register the null target streamer.
127     TargetRegistry::RegisterNullTargetStreamer(*T, createNullTargetStreamer);
128   }
129 }
130 
131 wasm::ValType WebAssembly::toValType(const MVT &Ty) {
132   switch (Ty.SimpleTy) {
133   case MVT::i32:
134     return wasm::ValType::I32;
135   case MVT::i64:
136     return wasm::ValType::I64;
137   case MVT::f32:
138     return wasm::ValType::F32;
139   case MVT::f64:
140     return wasm::ValType::F64;
141   case MVT::v16i8:
142   case MVT::v8i16:
143   case MVT::v4i32:
144   case MVT::v2i64:
145   case MVT::v4f32:
146   case MVT::v2f64:
147     return wasm::ValType::V128;
148   case MVT::ExceptRef:
149     return wasm::ValType::EXCEPT_REF;
150   default:
151     llvm_unreachable("unexpected type");
152   }
153 }
154