lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp

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