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.EmitSLEB128IntValue(int32_t(Type));
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::emitGlobal(
91     ArrayRef<wasm::Global> Globals) {
92   if (!Globals.empty()) {
93     OS << "\t.globalvar  \t";
94 
95     bool First = true;
96     for (const wasm::Global &G : Globals) {
97       if (First)
98         First = false;
99       else
100         OS << ", ";
101       OS << WebAssembly::TypeToString(G.Type);
102       if (!G.InitialModule.empty())
103         OS << '=' << G.InitialModule << ':' << G.InitialName;
104       else
105         OS << '=' << G.InitialValue;
106     }
107     OS << '\n';
108   }
109 }
110 
111 void WebAssemblyTargetAsmStreamer::emitStackPointer(uint32_t Index) {
112   OS << "\t.stack_pointer\t" << Index << '\n';
113 }
114 
115 void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
116 
117 void WebAssemblyTargetAsmStreamer::emitIndirectFunctionType(
118     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
119   OS << "\t.functype\t" << Symbol->getName();
120   if (Results.empty())
121     OS << ", void";
122   else {
123     assert(Results.size() == 1);
124     OS << ", " << WebAssembly::TypeToString(Results.front());
125   }
126   for (auto Ty : Params)
127     OS << ", " << WebAssembly::TypeToString(Ty);
128   OS << '\n';
129 }
130 
131 void WebAssemblyTargetAsmStreamer::emitGlobalImport(StringRef name) {
132   OS << "\t.import_global\t" << name << '\n';
133 }
134 
135 void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {
136   OS << "\t.indidx  \t" << *Value << '\n';
137 }
138 
139 void WebAssemblyTargetELFStreamer::emitParam(MCSymbol *Symbol,
140                                              ArrayRef<MVT> Types) {
141   // Nothing to emit; params are declared as part of the function signature.
142 }
143 
144 void WebAssemblyTargetELFStreamer::emitResult(MCSymbol *Symbol,
145                                               ArrayRef<MVT> Types) {
146   // Nothing to emit; results are declared as part of the function signature.
147 }
148 
149 void WebAssemblyTargetELFStreamer::emitLocal(ArrayRef<MVT> Types) {
150   Streamer.EmitULEB128IntValue(Types.size());
151   for (MVT Type : Types)
152     emitValueType(WebAssembly::toValType(Type));
153 }
154 
155 void WebAssemblyTargetELFStreamer::emitGlobal(
156     ArrayRef<wasm::Global> Globals) {
157   llvm_unreachable(".globalvar encoding not yet implemented");
158 }
159 
160 void WebAssemblyTargetELFStreamer::emitStackPointer(
161     uint32_t Index) {
162   llvm_unreachable(".stack_pointer encoding not yet implemented");
163 }
164 
165 void WebAssemblyTargetELFStreamer::emitEndFunc() {
166   Streamer.EmitIntValue(WebAssembly::End, 1);
167 }
168 
169 void WebAssemblyTargetELFStreamer::emitIndIdx(const MCExpr *Value) {
170   llvm_unreachable(".indidx encoding not yet implemented");
171 }
172 
173 void WebAssemblyTargetELFStreamer::emitIndirectFunctionType(
174     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
175   // Nothing to emit here. TODO: Re-design how linking works and re-evaluate
176   // whether it's necessary for .o files to declare indirect function types.
177 }
178 
179 void WebAssemblyTargetELFStreamer::emitGlobalImport(StringRef name) {
180 }
181 
182 void WebAssemblyTargetWasmStreamer::emitParam(MCSymbol *Symbol,
183                                               ArrayRef<MVT> Types) {
184   SmallVector<wasm::ValType, 4> Params;
185   for (MVT Ty : Types)
186     Params.push_back(WebAssembly::toValType(Ty));
187 
188   cast<MCSymbolWasm>(Symbol)->setParams(std::move(Params));
189 }
190 
191 void WebAssemblyTargetWasmStreamer::emitResult(MCSymbol *Symbol,
192                                                ArrayRef<MVT> Types) {
193   SmallVector<wasm::ValType, 4> Returns;
194   for (MVT Ty : Types)
195     Returns.push_back(WebAssembly::toValType(Ty));
196 
197   cast<MCSymbolWasm>(Symbol)->setReturns(std::move(Returns));
198 }
199 
200 void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<MVT> Types) {
201   SmallVector<std::pair<MVT, uint32_t>, 4> Grouped;
202   for (MVT Type : Types) {
203     if (Grouped.empty() || Grouped.back().first != Type)
204       Grouped.push_back(std::make_pair(Type, 1));
205     else
206       ++Grouped.back().second;
207   }
208 
209   Streamer.EmitULEB128IntValue(Grouped.size());
210   for (auto Pair : Grouped) {
211     Streamer.EmitULEB128IntValue(Pair.second);
212     emitValueType(WebAssembly::toValType(Pair.first));
213   }
214 }
215 
216 void WebAssemblyTargetWasmStreamer::emitGlobal(
217     ArrayRef<wasm::Global> Globals) {
218   // Encode the globals use by the funciton into the special .global_variables
219   // section. This will later be decoded and turned into contents for the
220   // Globals Section.
221   Streamer.PushSection();
222   Streamer.SwitchSection(Streamer.getContext().getWasmSection(
223       ".global_variables", SectionKind::getMetadata()));
224   for (const wasm::Global &G : Globals) {
225     Streamer.EmitIntValue(int32_t(G.Type), 1);
226     Streamer.EmitIntValue(G.Mutable, 1);
227     if (G.InitialModule.empty()) {
228       Streamer.EmitIntValue(0, 1); // indicate that we have an int value
229       Streamer.EmitSLEB128IntValue(0);
230     } else {
231       Streamer.EmitIntValue(1, 1); // indicate that we have a module import
232       Streamer.EmitBytes(G.InitialModule);
233       Streamer.EmitIntValue(0, 1); // nul-terminate
234       Streamer.EmitBytes(G.InitialName);
235       Streamer.EmitIntValue(0, 1); // nul-terminate
236     }
237   }
238   Streamer.PopSection();
239 }
240 
241 void WebAssemblyTargetWasmStreamer::emitStackPointer(uint32_t Index) {
242   Streamer.PushSection();
243   Streamer.SwitchSection(Streamer.getContext().getWasmSection(
244       ".stack_pointer", SectionKind::getMetadata()));
245   Streamer.EmitIntValue(Index, 4);
246   Streamer.PopSection();
247 }
248 
249 void WebAssemblyTargetWasmStreamer::emitEndFunc() {
250   llvm_unreachable(".end_func is not needed for direct wasm output");
251 }
252 
253 void WebAssemblyTargetWasmStreamer::emitIndIdx(const MCExpr *Value) {
254   llvm_unreachable(".indidx encoding not yet implemented");
255 }
256 
257 void WebAssemblyTargetWasmStreamer::emitIndirectFunctionType(
258     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params,
259     SmallVectorImpl<MVT> &Results) {
260   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Symbol);
261   if (WasmSym->isFunction()) {
262     // Symbol already has its arguments and result set.
263     return;
264   }
265 
266   SmallVector<wasm::ValType, 4> ValParams;
267   for (MVT Ty : Params)
268     ValParams.push_back(WebAssembly::toValType(Ty));
269 
270   SmallVector<wasm::ValType, 1> ValResults;
271   for (MVT Ty : Results)
272     ValResults.push_back(WebAssembly::toValType(Ty));
273 
274   WasmSym->setParams(std::move(ValParams));
275   WasmSym->setReturns(std::move(ValResults));
276   WasmSym->setIsFunction(true);
277 }
278 
279 void WebAssemblyTargetWasmStreamer::emitGlobalImport(StringRef name) {
280 }
281