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/MCSectionWasm.h"
22 #include "llvm/MC/MCSubtargetInfo.h"
23 #include "llvm/MC/MCSymbolELF.h"
24 #include "llvm/MC/MCSymbolWasm.h"
25 #include "llvm/Support/Casting.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/FormattedStream.h"
28 using namespace llvm;
29 
30 WebAssemblyTargetStreamer::WebAssemblyTargetStreamer(MCStreamer &S)
31     : MCTargetStreamer(S) {}
32 
33 void WebAssemblyTargetStreamer::emitValueType(wasm::ValType Type) {
34   Streamer.EmitIntValue(uint8_t(Type), 1);
35 }
36 
37 WebAssemblyTargetAsmStreamer::WebAssemblyTargetAsmStreamer(
38     MCStreamer &S, formatted_raw_ostream &OS)
39     : WebAssemblyTargetStreamer(S), OS(OS) {}
40 
41 WebAssemblyTargetELFStreamer::WebAssemblyTargetELFStreamer(MCStreamer &S)
42     : WebAssemblyTargetStreamer(S) {}
43 
44 WebAssemblyTargetWasmStreamer::WebAssemblyTargetWasmStreamer(MCStreamer &S)
45     : WebAssemblyTargetStreamer(S) {}
46 
47 static void PrintTypes(formatted_raw_ostream &OS, ArrayRef<MVT> Types) {
48   bool First = true;
49   for (MVT Type : Types) {
50     if (First)
51       First = false;
52     else
53       OS << ", ";
54     OS << WebAssembly::TypeToString(Type);
55   }
56   OS << '\n';
57 }
58 
59 void WebAssemblyTargetAsmStreamer::emitParam(MCSymbol *Symbol,
60                                              ArrayRef<MVT> Types) {
61   if (!Types.empty()) {
62     OS << "\t.param  \t";
63 
64     // FIXME: Currently this applies to the "current" function; it may
65     // be cleaner to specify an explicit symbol as part of the directive.
66 
67     PrintTypes(OS, Types);
68   }
69 }
70 
71 void WebAssemblyTargetAsmStreamer::emitResult(MCSymbol *Symbol,
72                                               ArrayRef<MVT> Types) {
73   if (!Types.empty()) {
74     OS << "\t.result \t";
75 
76     // FIXME: Currently this applies to the "current" function; it may
77     // be cleaner to specify an explicit symbol as part of the directive.
78 
79     PrintTypes(OS, Types);
80   }
81 }
82 
83 void WebAssemblyTargetAsmStreamer::emitLocal(ArrayRef<MVT> Types) {
84   if (!Types.empty()) {
85     OS << "\t.local  \t";
86     PrintTypes(OS, Types);
87   }
88 }
89 
90 void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
91 
92 void WebAssemblyTargetAsmStreamer::emitIndirectFunctionType(
93     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
94   OS << "\t.functype\t" << Symbol->getName();
95   if (Results.empty())
96     OS << ", void";
97   else {
98     assert(Results.size() == 1);
99     OS << ", " << WebAssembly::TypeToString(Results.front());
100   }
101   for (auto Ty : Params)
102     OS << ", " << WebAssembly::TypeToString(Ty);
103   OS << '\n';
104 }
105 
106 void WebAssemblyTargetAsmStreamer::emitGlobalImport(StringRef name) {
107   OS << "\t.import_global\t" << name << '\n';
108 }
109 
110 void WebAssemblyTargetAsmStreamer::emitImportModule(MCSymbolWasm *Sym,
111                                                     StringRef ModuleName) {
112   OS << "\t.import_module\t" << Sym->getName() << ", " << ModuleName << '\n';
113 }
114 
115 void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {
116   OS << "\t.indidx  \t" << *Value << '\n';
117 }
118 
119 void WebAssemblyTargetELFStreamer::emitParam(MCSymbol *Symbol,
120                                              ArrayRef<MVT> Types) {
121   // Nothing to emit; params are declared as part of the function signature.
122 }
123 
124 void WebAssemblyTargetELFStreamer::emitResult(MCSymbol *Symbol,
125                                               ArrayRef<MVT> Types) {
126   // Nothing to emit; results are declared as part of the function signature.
127 }
128 
129 void WebAssemblyTargetELFStreamer::emitLocal(ArrayRef<MVT> Types) {
130   Streamer.EmitULEB128IntValue(Types.size());
131   for (MVT Type : Types)
132     emitValueType(WebAssembly::toValType(Type));
133 }
134 
135 void WebAssemblyTargetELFStreamer::emitEndFunc() {
136   Streamer.EmitIntValue(WebAssembly::End, 1);
137 }
138 
139 void WebAssemblyTargetELFStreamer::emitIndIdx(const MCExpr *Value) {
140   llvm_unreachable(".indidx encoding not yet implemented");
141 }
142 
143 void WebAssemblyTargetELFStreamer::emitIndirectFunctionType(
144     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
145   // Nothing to emit here. TODO: Re-design how linking works and re-evaluate
146   // whether it's necessary for .o files to declare indirect function types.
147 }
148 
149 void WebAssemblyTargetELFStreamer::emitGlobalImport(StringRef name) {
150 }
151 
152 void WebAssemblyTargetELFStreamer::emitImportModule(MCSymbolWasm *Sym,
153                                                     StringRef ModuleName) {
154   llvm_unreachable(".import_module encoding not yet implemented");
155 }
156 
157 void WebAssemblyTargetWasmStreamer::emitParam(MCSymbol *Symbol,
158                                               ArrayRef<MVT> Types) {
159   SmallVector<wasm::ValType, 4> Params;
160   for (MVT Ty : Types)
161     Params.push_back(WebAssembly::toValType(Ty));
162 
163   cast<MCSymbolWasm>(Symbol)->setParams(std::move(Params));
164 }
165 
166 void WebAssemblyTargetWasmStreamer::emitResult(MCSymbol *Symbol,
167                                                ArrayRef<MVT> Types) {
168   SmallVector<wasm::ValType, 4> Returns;
169   for (MVT Ty : Types)
170     Returns.push_back(WebAssembly::toValType(Ty));
171 
172   cast<MCSymbolWasm>(Symbol)->setReturns(std::move(Returns));
173 }
174 
175 void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<MVT> Types) {
176   SmallVector<std::pair<MVT, uint32_t>, 4> Grouped;
177   for (MVT Type : Types) {
178     if (Grouped.empty() || Grouped.back().first != Type)
179       Grouped.push_back(std::make_pair(Type, 1));
180     else
181       ++Grouped.back().second;
182   }
183 
184   Streamer.EmitULEB128IntValue(Grouped.size());
185   for (auto Pair : Grouped) {
186     Streamer.EmitULEB128IntValue(Pair.second);
187     emitValueType(WebAssembly::toValType(Pair.first));
188   }
189 }
190 
191 void WebAssemblyTargetWasmStreamer::emitEndFunc() {
192   llvm_unreachable(".end_func is not needed for direct wasm output");
193 }
194 
195 void WebAssemblyTargetWasmStreamer::emitIndIdx(const MCExpr *Value) {
196   llvm_unreachable(".indidx encoding not yet implemented");
197 }
198 
199 void WebAssemblyTargetWasmStreamer::emitIndirectFunctionType(
200     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params,
201     SmallVectorImpl<MVT> &Results) {
202   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Symbol);
203   if (WasmSym->isFunction()) {
204     // Symbol already has its arguments and result set.
205     return;
206   }
207 
208   SmallVector<wasm::ValType, 4> ValParams;
209   for (MVT Ty : Params)
210     ValParams.push_back(WebAssembly::toValType(Ty));
211 
212   SmallVector<wasm::ValType, 1> ValResults;
213   for (MVT Ty : Results)
214     ValResults.push_back(WebAssembly::toValType(Ty));
215 
216   WasmSym->setParams(std::move(ValParams));
217   WasmSym->setReturns(std::move(ValResults));
218   WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
219 }
220 
221 void WebAssemblyTargetWasmStreamer::emitGlobalImport(StringRef name) {
222   llvm_unreachable(".global_import is not needed for direct wasm output");
223 }
224 
225 void WebAssemblyTargetWasmStreamer::emitImportModule(MCSymbolWasm *Sym,
226                                                      StringRef ModuleName) {
227   Sym->setModuleName(ModuleName);
228 }
229