1 //==-- WebAssemblyTargetStreamer.cpp - WebAssembly Target Streamer Methods --=//
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 defines WebAssembly-specific target streamer classes.
12 /// These are for implementing support for target-specific assembly directives.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "WebAssemblyTargetStreamer.h"
17 #include "InstPrinter/WebAssemblyInstPrinter.h"
18 #include "WebAssemblyMCTargetDesc.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCSectionELF.h"
21 #include "llvm/MC/MCSubtargetInfo.h"
22 #include "llvm/MC/MCSymbolELF.h"
23 #include "llvm/Support/ELF.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/FormattedStream.h"
26 using namespace llvm;
27 
28 WebAssemblyTargetStreamer::WebAssemblyTargetStreamer(MCStreamer &S)
29     : MCTargetStreamer(S) {}
30 
31 WebAssemblyTargetAsmStreamer::WebAssemblyTargetAsmStreamer(
32     MCStreamer &S, formatted_raw_ostream &OS)
33     : WebAssemblyTargetStreamer(S), OS(OS) {}
34 
35 WebAssemblyTargetELFStreamer::WebAssemblyTargetELFStreamer(MCStreamer &S)
36     : WebAssemblyTargetStreamer(S) {}
37 
38 static void PrintTypes(formatted_raw_ostream &OS, ArrayRef<MVT> Types) {
39   bool First = true;
40   for (MVT Type : Types) {
41     if (First)
42       First = false;
43     else
44       OS << ", ";
45     OS << WebAssembly::TypeToString(Type);
46   }
47   OS << '\n';
48 }
49 
50 void WebAssemblyTargetAsmStreamer::emitParam(ArrayRef<MVT> Types) {
51   OS << "\t.param  \t";
52   PrintTypes(OS, Types);
53 }
54 
55 void WebAssemblyTargetAsmStreamer::emitResult(ArrayRef<MVT> Types) {
56   OS << "\t.result \t";
57   PrintTypes(OS, Types);
58 }
59 
60 void WebAssemblyTargetAsmStreamer::emitLocal(ArrayRef<MVT> Types) {
61   OS << "\t.local  \t";
62   PrintTypes(OS, Types);
63 }
64 
65 void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
66 
67 void WebAssemblyTargetAsmStreamer::emitIndirectFunctionType(
68     StringRef name, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
69   OS << "\t.functype\t" << name;
70   if (Results.empty())
71     OS << ", void";
72   else {
73     assert(Results.size() == 1);
74     OS << ", " << WebAssembly::TypeToString(Results.front());
75   }
76   for (auto Ty : Params)
77     OS << ", " << WebAssembly::TypeToString(Ty);
78   OS << '\n';
79 }
80 
81 void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {
82   OS << "\t.indidx  \t" << *Value << '\n';
83 }
84 
85 // FIXME: What follows is not the real binary encoding.
86 
87 static void EncodeTypes(MCStreamer &Streamer, ArrayRef<MVT> Types) {
88   Streamer.EmitIntValue(Types.size(), sizeof(uint64_t));
89   for (MVT Type : Types)
90     Streamer.EmitIntValue(Type.SimpleTy, sizeof(uint64_t));
91 }
92 
93 void WebAssemblyTargetELFStreamer::emitParam(ArrayRef<MVT> Types) {
94   Streamer.EmitIntValue(WebAssembly::DotParam, sizeof(uint64_t));
95   EncodeTypes(Streamer, Types);
96 }
97 
98 void WebAssemblyTargetELFStreamer::emitResult(ArrayRef<MVT> Types) {
99   Streamer.EmitIntValue(WebAssembly::DotResult, sizeof(uint64_t));
100   EncodeTypes(Streamer, Types);
101 }
102 
103 void WebAssemblyTargetELFStreamer::emitLocal(ArrayRef<MVT> Types) {
104   Streamer.EmitIntValue(WebAssembly::DotLocal, sizeof(uint64_t));
105   EncodeTypes(Streamer, Types);
106 }
107 
108 void WebAssemblyTargetELFStreamer::emitEndFunc() {
109   Streamer.EmitIntValue(WebAssembly::DotEndFunc, sizeof(uint64_t));
110 }
111 
112 void WebAssemblyTargetELFStreamer::emitIndIdx(const MCExpr *Value) {
113   Streamer.EmitIntValue(WebAssembly::DotIndIdx, sizeof(uint64_t));
114   Streamer.EmitValue(Value, sizeof(uint64_t));
115 }
116