LLVM  6.0.0svn
WebAssemblyTargetStreamer.cpp
Go to the documentation of this file.
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 
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCSectionELF.h"
21 #include "llvm/MC/MCSectionWasm.h"
23 #include "llvm/MC/MCSymbolELF.h"
24 #include "llvm/MC/MCSymbolWasm.h"
25 #include "llvm/Support/Casting.h"
28 using namespace llvm;
29 
31  : MCTargetStreamer(S) {}
32 
34  Streamer.EmitSLEB128IntValue(int32_t(Type));
35 }
36 
39  : WebAssemblyTargetStreamer(S), OS(OS) {}
40 
43 
46 
48  bool First = true;
49  for (MVT Type : Types) {
50  if (First)
51  First = false;
52  else
53  OS << ", ";
55  }
56  OS << '\n';
57 }
58 
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 
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 
84  if (!Types.empty()) {
85  OS << "\t.local \t";
86  PrintTypes(OS, Types);
87  }
88 }
89 
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 
112  OS << "\t.stack_pointer\t" << Index << '\n';
113 }
114 
115 void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
116 
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 
132  OS << "\t.import_global\t" << name << '\n';
133 }
134 
136  OS << "\t.indidx \t" << *Value << '\n';
137 }
138 
140  ArrayRef<MVT> Types) {
141  // Nothing to emit; params are declared as part of the function signature.
142 }
143 
145  ArrayRef<MVT> Types) {
146  // Nothing to emit; results are declared as part of the function signature.
147 }
148 
151  for (MVT Type : Types)
153 }
154 
156  ArrayRef<wasm::Global> Globals) {
157  llvm_unreachable(".globalvar encoding not yet implemented");
158 }
159 
161  uint32_t Index) {
162  llvm_unreachable(".stack_pointer encoding not yet implemented");
163 }
164 
167 }
168 
170  llvm_unreachable(".indidx encoding not yet implemented");
171 }
172 
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 
180 }
181 
183  ArrayRef<MVT> Types) {
185  for (MVT Ty : Types)
186  Params.push_back(WebAssembly::toValType(Ty));
187 
188  cast<MCSymbolWasm>(Symbol)->setParams(std::move(Params));
189 }
190 
192  ArrayRef<MVT> Types) {
194  for (MVT Ty : Types)
195  Returns.push_back(WebAssembly::toValType(Ty));
196 
197  cast<MCSymbolWasm>(Symbol)->setReturns(std::move(Returns));
198 }
199 
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);
213  }
214 }
215 
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.
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
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  }
239 }
240 
244  ".stack_pointer", SectionKind::getMetadata()));
245  Streamer.EmitIntValue(Index, 4);
247 }
248 
250  llvm_unreachable(".end_func is not needed for direct wasm output");
251 }
252 
254  llvm_unreachable(".indidx encoding not yet implemented");
255 }
256 
260  MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Symbol);
261  if (WasmSym->isFunction()) {
262  // Symbol already has its arguments and result set.
263  return;
264  }
265 
267  for (MVT Ty : Params)
268  ValParams.push_back(WebAssembly::toValType(Ty));
269 
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 
280 }
bool isFunction() const
Definition: MCSymbolWasm.h:42
void push_back(const T &Elt)
Definition: SmallVector.h:212
const char * TypeToString(MVT Ty)
void emitLocal(ArrayRef< MVT > Types) override
.local
void EmitSLEB128IntValue(int64_t Value)
Special case of EmitSLEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:116
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void emitIndirectFunctionType(MCSymbol *Symbol, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results) override
.functype
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
This class prints an WebAssembly MCInst to wasm file syntax.
virtual void EmitBytes(StringRef Data)
Emit the bytes in Data into the output.
Definition: MCStreamer.cpp:915
Target specific streamer interface.
Definition: MCStreamer.h:80
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K)
Definition: MCContext.h:444
Function Alias Analysis Results
void setParams(SmallVectorImpl< wasm::ValType > &&Pars)
Definition: MCSymbolWasm.h:65
void PushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:338
void emitGlobalImport(StringRef name) override
.import_global
void emitLocal(ArrayRef< MVT > Types) override
.local
MCContext & getContext() const
Definition: MCStreamer.h:234
void emitParam(MCSymbol *Symbol, ArrayRef< MVT > Types) override
.param
void emitIndirectFunctionType(MCSymbol *Symbol, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results) override
.functype
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
void emitGlobal(ArrayRef< wasm::Global > Globals) override
.globalvar
void emitIndIdx(const MCExpr *Value) override
.indidx
void emitGlobalImport(StringRef name) override
.import_global
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
virtual void EmitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers...
Definition: MCStreamer.cpp:88
wasm::ValType toValType(const MVT &Ty)
void emitGlobal(ArrayRef< wasm::Global > Globals) override
.globalvar
WebAssembly-specific streamer interface, to implement support WebAssembly-specific assembly directive...
void emitGlobal(ArrayRef< wasm::Global > Globals) override
.globalvar
Streaming machine code generation interface.
Definition: MCStreamer.h:169
Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
void emitIndIdx(const MCExpr *Value) override
.indidx
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
Definition: MCStreamer.cpp:937
This file provides WebAssembly-specific target descriptions.
static void PrintTypes(formatted_raw_ostream &OS, ArrayRef< MVT > Types)
void emitIndIdx(const MCExpr *Value) override
.indidx
void setReturns(SmallVectorImpl< wasm::ValType > &&Rets)
Definition: MCSymbolWasm.h:55
void emitStackPointer(uint32_t Index) override
.stack_pointer
static const unsigned End
void emitResult(MCSymbol *Symbol, ArrayRef< MVT > Types) override
.result
WebAssemblyTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This file declares WebAssembly-specific target streamer classes.
void setIsFunction(bool isFunc)
Definition: MCSymbolWasm.h:43
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
MCStreamer & Streamer
Definition: MCStreamer.h:82
static SectionKind getMetadata()
Definition: SectionKind.h:179
void emitStackPointer(uint32_t Index) override
.stack_pointer
void emitParam(MCSymbol *Symbol, ArrayRef< MVT > Types) override
.param
void emitIndirectFunctionType(MCSymbol *Symbol, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results) override
.functype
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
void emitParam(MCSymbol *Symbol, ArrayRef< MVT > Types) override
.param
void emitLocal(ArrayRef< MVT > Types) override
.local
void emitGlobalImport(StringRef name) override
.import_global
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:203
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void emitResult(MCSymbol *Symbol, ArrayRef< MVT > Types) override
.result
bool PopSection()
Restore the current and previous section from the section stack.
Definition: MCStreamer.h:347
LLVM Value Representation.
Definition: Value.h:73
static const char * name
void emitResult(MCSymbol *Symbol, ArrayRef< MVT > Types) override
.result
void emitStackPointer(uint32_t Index) override
.stack_pointer
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void EmitULEB128IntValue(uint64_t Value)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:110
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144