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