Line data    Source code

       1             : //==-- WebAssemblyTargetStreamer.h - WebAssembly Target Streamer -*- C++ -*-==//
       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             : /// This file declares WebAssembly-specific target streamer classes.
      12             : /// These are for implementing support for target-specific assembly directives.
      13             : ///
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYTARGETSTREAMER_H
      17             : #define LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYTARGETSTREAMER_H
      18             : 
      19             : #include "llvm/BinaryFormat/Wasm.h"
      20             : #include "llvm/MC/MCStreamer.h"
      21             : #include "llvm/Support/MachineValueType.h"
      22             : 
      23             : namespace llvm {
      24             : 
      25             : class MCELFStreamer;
      26             : class MCWasmStreamer;
      27             : class MCSymbolWasm;
      28             : 
      29             : /// WebAssembly-specific streamer interface, to implement support
      30             : /// WebAssembly-specific assembly directives.
      31         262 : class WebAssemblyTargetStreamer : public MCTargetStreamer {
      32             : public:
      33             :   explicit WebAssemblyTargetStreamer(MCStreamer &S);
      34             : 
      35             :   /// .param
      36             :   virtual void emitParam(MCSymbol *Symbol, ArrayRef<MVT> Types) = 0;
      37             :   /// .result
      38             :   virtual void emitResult(MCSymbol *Symbol, ArrayRef<MVT> Types) = 0;
      39             :   /// .local
      40             :   virtual void emitLocal(ArrayRef<MVT> Types) = 0;
      41             :   /// .endfunc
      42             :   virtual void emitEndFunc() = 0;
      43             :   /// .functype
      44             :   virtual void emitIndirectFunctionType(MCSymbol *Symbol,
      45             :                                         SmallVectorImpl<MVT> &Params,
      46             :                                         SmallVectorImpl<MVT> &Results) = 0;
      47             :   /// .indidx
      48             :   virtual void emitIndIdx(const MCExpr *Value) = 0;
      49             :   /// .import_global
      50             :   virtual void emitGlobalImport(StringRef name) = 0;
      51             :   /// .import_module
      52             :   virtual void emitImportModule(MCSymbolWasm *Sym, StringRef ModuleName) = 0;
      53             : 
      54             : protected:
      55             :   void emitValueType(wasm::ValType Type);
      56             : };
      57             : 
      58             : /// This part is for ascii assembly output
      59         248 : class WebAssemblyTargetAsmStreamer final : public WebAssemblyTargetStreamer {
      60             :   formatted_raw_ostream &OS;
      61             : 
      62             : public:
      63             :   WebAssemblyTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
      64             : 
      65             :   void emitParam(MCSymbol *Symbol, ArrayRef<MVT> Types) override;
      66             :   void emitResult(MCSymbol *Symbol, ArrayRef<MVT> Types) override;
      67             :   void emitLocal(ArrayRef<MVT> Types) override;
      68             :   void emitEndFunc() override;
      69             :   void emitIndirectFunctionType(MCSymbol *Symbol,
      70             :                                 SmallVectorImpl<MVT> &Params,
      71             :                                 SmallVectorImpl<MVT> &Results) override;
      72             :   void emitIndIdx(const MCExpr *Value) override;
      73             :   void emitGlobalImport(StringRef name) override;
      74             :   void emitImportModule(MCSymbolWasm *Sym, StringRef ModuleName) override;
      75             : };
      76             : 
      77             : /// This part is for ELF object output
      78           0 : class WebAssemblyTargetELFStreamer final : public WebAssemblyTargetStreamer {
      79             : public:
      80             :   explicit WebAssemblyTargetELFStreamer(MCStreamer &S);
      81             : 
      82             :   void emitParam(MCSymbol *Symbol, ArrayRef<MVT> Types) override;
      83             :   void emitResult(MCSymbol *Symbol, ArrayRef<MVT> Types) override;
      84             :   void emitLocal(ArrayRef<MVT> Types) override;
      85             :   void emitEndFunc() override;
      86             :   void emitIndirectFunctionType(MCSymbol *Symbol,
      87             :                                 SmallVectorImpl<MVT> &Params,
      88             :                                 SmallVectorImpl<MVT> &Results) override;
      89             :   void emitIndIdx(const MCExpr *Value) override;
      90             :   void emitGlobalImport(StringRef name) override;
      91             :   void emitImportModule(MCSymbolWasm *Sym, StringRef ModuleName) override;
      92             : };
      93             : 
      94             : /// This part is for Wasm object output
      95         276 : class WebAssemblyTargetWasmStreamer final : public WebAssemblyTargetStreamer {
      96             : public:
      97             :   explicit WebAssemblyTargetWasmStreamer(MCStreamer &S);
      98             : 
      99             :   void emitParam(MCSymbol *Symbol, ArrayRef<MVT> Types) override;
     100             :   void emitResult(MCSymbol *Symbol, ArrayRef<MVT> Types) override;
     101             :   void emitLocal(ArrayRef<MVT> Types) override;
     102             :   void emitEndFunc() override;
     103             :   void emitIndirectFunctionType(MCSymbol *Symbol,
     104             :                                 SmallVectorImpl<MVT> &Params,
     105             :                                 SmallVectorImpl<MVT> &Results) override;
     106             :   void emitIndIdx(const MCExpr *Value) override;
     107             :   void emitGlobalImport(StringRef name) override;
     108             :   void emitImportModule(MCSymbolWasm *Sym, StringRef ModuleName) override;
     109             : };
     110             : 
     111             : } // end namespace llvm
     112             : 
     113             : #endif