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::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::emitIndIdx(const MCExpr *Value) {
111   OS << "\t.indidx  \t" << *Value << '\n';
112 }
113 
114 void WebAssemblyTargetELFStreamer::emitParam(MCSymbol *Symbol,
115                                              ArrayRef<MVT> Types) {
116   // Nothing to emit; params are declared as part of the function signature.
117 }
118 
119 void WebAssemblyTargetELFStreamer::emitResult(MCSymbol *Symbol,
120                                               ArrayRef<MVT> Types) {
121   // Nothing to emit; results are declared as part of the function signature.
122 }
123 
124 void WebAssemblyTargetELFStreamer::emitLocal(ArrayRef<MVT> Types) {
125   Streamer.EmitULEB128IntValue(Types.size());
126   for (MVT Type : Types)
127     emitValueType(WebAssembly::toValType(Type));
128 }
129 
130 void WebAssemblyTargetELFStreamer::emitEndFunc() {
131   Streamer.EmitIntValue(WebAssembly::End, 1);
132 }
133 
134 void WebAssemblyTargetELFStreamer::emitIndIdx(const MCExpr *Value) {
135   llvm_unreachable(".indidx encoding not yet implemented");
136 }
137 
138 void WebAssemblyTargetELFStreamer::emitIndirectFunctionType(
139     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
140   // Nothing to emit here. TODO: Re-design how linking works and re-evaluate
141   // whether it's necessary for .o files to declare indirect function types.
142 }
143 
144 void WebAssemblyTargetELFStreamer::emitGlobalImport(StringRef name) {
145 }
146 
147 void WebAssemblyTargetWasmStreamer::emitParam(MCSymbol *Symbol,
148                                               ArrayRef<MVT> Types) {
149   SmallVector<wasm::ValType, 4> Params;
150   for (MVT Ty : Types)
151     Params.push_back(WebAssembly::toValType(Ty));
152 
153   cast<MCSymbolWasm>(Symbol)->setParams(std::move(Params));
154 }
155 
156 void WebAssemblyTargetWasmStreamer::emitResult(MCSymbol *Symbol,
157                                                ArrayRef<MVT> Types) {
158   SmallVector<wasm::ValType, 4> Returns;
159   for (MVT Ty : Types)
160     Returns.push_back(WebAssembly::toValType(Ty));
161 
162   cast<MCSymbolWasm>(Symbol)->setReturns(std::move(Returns));
163 }
164 
165 void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<MVT> Types) {
166   SmallVector<std::pair<MVT, uint32_t>, 4> Grouped;
167   for (MVT Type : Types) {
168     if (Grouped.empty() || Grouped.back().first != Type)
169       Grouped.push_back(std::make_pair(Type, 1));
170     else
171       ++Grouped.back().second;
172   }
173 
174   Streamer.EmitULEB128IntValue(Grouped.size());
175   for (auto Pair : Grouped) {
176     Streamer.EmitULEB128IntValue(Pair.second);
177     emitValueType(WebAssembly::toValType(Pair.first));
178   }
179 }
180 
181 void WebAssemblyTargetWasmStreamer::emitEndFunc() {
182   llvm_unreachable(".end_func is not needed for direct wasm output");
183 }
184 
185 void WebAssemblyTargetWasmStreamer::emitIndIdx(const MCExpr *Value) {
186   llvm_unreachable(".indidx encoding not yet implemented");
187 }
188 
189 void WebAssemblyTargetWasmStreamer::emitIndirectFunctionType(
190     MCSymbol *Symbol, SmallVectorImpl<MVT> &Params,
191     SmallVectorImpl<MVT> &Results) {
192   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Symbol);
193   if (WasmSym->isFunction()) {
194     // Symbol already has its arguments and result set.
195     return;
196   }
197 
198   SmallVector<wasm::ValType, 4> ValParams;
199   for (MVT Ty : Params)
200     ValParams.push_back(WebAssembly::toValType(Ty));
201 
202   SmallVector<wasm::ValType, 1> ValResults;
203   for (MVT Ty : Results)
204     ValResults.push_back(WebAssembly::toValType(Ty));
205 
206   WasmSym->setParams(std::move(ValParams));
207   WasmSym->setReturns(std::move(ValResults));
208   WasmSym->setIsFunction(true);
209 }
210 
211 void WebAssemblyTargetWasmStreamer::emitGlobalImport(StringRef name) {
212   llvm_unreachable(".global_import is not needed for direct wasm output");
213 }
214