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/ErrorHandling.h"
26 #include "llvm/Support/FormattedStream.h"
27 using namespace llvm;
28 
29 WebAssemblyTargetStreamer::WebAssemblyTargetStreamer(MCStreamer &S)
30     : MCTargetStreamer(S) {}
31 
32 WebAssemblyTargetAsmStreamer::WebAssemblyTargetAsmStreamer(
33     MCStreamer &S, formatted_raw_ostream &OS)
34     : WebAssemblyTargetStreamer(S), OS(OS) {}
35 
36 WebAssemblyTargetELFStreamer::WebAssemblyTargetELFStreamer(MCStreamer &S)
37     : WebAssemblyTargetStreamer(S) {}
38 
39 WebAssemblyTargetWasmStreamer::WebAssemblyTargetWasmStreamer(MCStreamer &S)
40     : WebAssemblyTargetStreamer(S) {}
41 
42 static void PrintTypes(formatted_raw_ostream &OS, ArrayRef<MVT> Types) {
43   bool First = true;
44   for (MVT Type : Types) {
45     if (First)
46       First = false;
47     else
48       OS << ", ";
49     OS << WebAssembly::TypeToString(Type);
50   }
51   OS << '\n';
52 }
53 
54 void WebAssemblyTargetAsmStreamer::emitParam(ArrayRef<MVT> Types) {
55   OS << "\t.param  \t";
56   PrintTypes(OS, Types);
57 }
58 
59 void WebAssemblyTargetAsmStreamer::emitResult(ArrayRef<MVT> Types) {
60   OS << "\t.result \t";
61   PrintTypes(OS, Types);
62 }
63 
64 void WebAssemblyTargetAsmStreamer::emitLocal(ArrayRef<MVT> Types) {
65   if (!Types.empty()) {
66     OS << "\t.local  \t";
67     PrintTypes(OS, Types);
68   }
69 }
70 
71 void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
72 
73 void WebAssemblyTargetAsmStreamer::emitIndirectFunctionType(
74     StringRef name, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
75   OS << "\t.functype\t" << name;
76   if (Results.empty())
77     OS << ", void";
78   else {
79     assert(Results.size() == 1);
80     OS << ", " << WebAssembly::TypeToString(Results.front());
81   }
82   for (auto Ty : Params)
83     OS << ", " << WebAssembly::TypeToString(Ty);
84   OS << '\n';
85 }
86 
87 void WebAssemblyTargetAsmStreamer::emitGlobalImport(StringRef name) {
88   OS << "\t.import_global\t" << name << '\n';
89 }
90 
91 void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {
92   OS << "\t.indidx  \t" << *Value << '\n';
93 }
94 
95 void WebAssemblyTargetELFStreamer::emitParam(ArrayRef<MVT> Types) {
96   // Nothing to emit; params are declared as part of the function signature.
97 }
98 
99 void WebAssemblyTargetELFStreamer::emitResult(ArrayRef<MVT> Types) {
100   // Nothing to emit; results are declared as part of the function signature.
101 }
102 
103 void WebAssemblyTargetELFStreamer::emitLocal(ArrayRef<MVT> Types) {
104   Streamer.EmitULEB128IntValue(Types.size());
105   for (MVT Type : Types)
106     Streamer.EmitIntValue(int64_t(WebAssembly::toValType(Type)), 1);
107 }
108 
109 void WebAssemblyTargetELFStreamer::emitEndFunc() {
110   Streamer.EmitIntValue(WebAssembly::End, 1);
111 }
112 
113 void WebAssemblyTargetELFStreamer::emitIndIdx(const MCExpr *Value) {
114   llvm_unreachable(".indidx encoding not yet implemented");
115 }
116 
117 void WebAssemblyTargetELFStreamer::emitIndirectFunctionType(
118     StringRef name, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
119   // Nothing to emit here. TODO: Re-design how linking works and re-evaluate
120   // whether it's necessary for .o files to declare indirect function types.
121 }
122 
123 void WebAssemblyTargetELFStreamer::emitGlobalImport(StringRef name) {
124 }
125 
126 void WebAssemblyTargetWasmStreamer::emitParam(ArrayRef<MVT> Types) {
127   // Nothing to emit; params are declared as part of the function signature.
128 }
129 
130 void WebAssemblyTargetWasmStreamer::emitResult(ArrayRef<MVT> Types) {
131   // Nothing to emit; results are declared as part of the function signature.
132 }
133 
134 void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<MVT> Types) {
135   Streamer.EmitULEB128IntValue(Types.size());
136   for (MVT Type : Types)
137     Streamer.EmitIntValue(int64_t(WebAssembly::toValType(Type)), 1);
138 }
139 
140 void WebAssemblyTargetWasmStreamer::emitEndFunc() {
141   Streamer.EmitIntValue(WebAssembly::End, 1);
142 }
143 
144 void WebAssemblyTargetWasmStreamer::emitIndIdx(const MCExpr *Value) {
145   llvm_unreachable(".indidx encoding not yet implemented");
146 }
147 
148 void WebAssemblyTargetWasmStreamer::emitIndirectFunctionType(
149     StringRef name, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
150   // Nothing to emit here. TODO: Re-design how linking works and re-evaluate
151   // whether it's necessary for .o files to declare indirect function types.
152 }
153 
154 void WebAssemblyTargetWasmStreamer::emitGlobalImport(StringRef name) {
155 }
156