87af0b1911
A TYPE_INDEX operand (as used by call_indirect) used to be represented by the InstPrinter as a symbol (e.g. .Ltype_index0@TYPE_INDEX) which was a bit of a mismatch with the WasmObjectWriter which expects an unnamed symbol, to receive the signature from and then turn into a reloc. There was really no good way to round-trip this information. An earlier version of this patch tried to attach the signature information using a .functype, but that ran into trouble when the symbol was re-emitted without a name. Removing the name was a giant hack also. The current version changes the assembly syntax to have an inline signature spec for TYPEINDEX operands that is always unnamed, which is much more elegant both in syntax and in implementation (as now the assembler is able to follow the same path as the regular backend) Reviewers: sbc100, dschuff, aheejin, jgravelle-google, sunfish, tlively Subscribers: arphaman, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64758 llvm-svn: 367590
124 lines
4.1 KiB
C++
124 lines
4.1 KiB
C++
//==-- WebAssemblyTargetStreamer.cpp - WebAssembly Target Streamer Methods --=//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file defines WebAssembly-specific target streamer classes.
|
|
/// These are for implementing support for target-specific assembly directives.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "MCTargetDesc/WebAssemblyTargetStreamer.h"
|
|
#include "MCTargetDesc/WebAssemblyInstPrinter.h"
|
|
#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCSectionWasm.h"
|
|
#include "llvm/MC/MCSubtargetInfo.h"
|
|
#include "llvm/MC/MCSymbolWasm.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/FormattedStream.h"
|
|
using namespace llvm;
|
|
|
|
WebAssemblyTargetStreamer::WebAssemblyTargetStreamer(MCStreamer &S)
|
|
: MCTargetStreamer(S) {}
|
|
|
|
void WebAssemblyTargetStreamer::emitValueType(wasm::ValType Type) {
|
|
Streamer.EmitIntValue(uint8_t(Type), 1);
|
|
}
|
|
|
|
WebAssemblyTargetAsmStreamer::WebAssemblyTargetAsmStreamer(
|
|
MCStreamer &S, formatted_raw_ostream &OS)
|
|
: WebAssemblyTargetStreamer(S), OS(OS) {}
|
|
|
|
WebAssemblyTargetWasmStreamer::WebAssemblyTargetWasmStreamer(MCStreamer &S)
|
|
: WebAssemblyTargetStreamer(S) {}
|
|
|
|
static void printTypes(formatted_raw_ostream &OS,
|
|
ArrayRef<wasm::ValType> Types) {
|
|
bool First = true;
|
|
for (auto Type : Types) {
|
|
if (First)
|
|
First = false;
|
|
else
|
|
OS << ", ";
|
|
OS << WebAssembly::typeToString(Type);
|
|
}
|
|
OS << '\n';
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitLocal(ArrayRef<wasm::ValType> Types) {
|
|
if (!Types.empty()) {
|
|
OS << "\t.local \t";
|
|
printTypes(OS, Types);
|
|
}
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitFunctionType(const MCSymbolWasm *Sym) {
|
|
assert(Sym->isFunction());
|
|
OS << "\t.functype\t" << Sym->getName() << " ";
|
|
OS << WebAssembly::signatureToString(Sym->getSignature());
|
|
OS << "\n";
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitGlobalType(const MCSymbolWasm *Sym) {
|
|
assert(Sym->isGlobal());
|
|
OS << "\t.globaltype\t" << Sym->getName() << ", "
|
|
<< WebAssembly::typeToString(
|
|
static_cast<wasm::ValType>(Sym->getGlobalType().Type))
|
|
<< '\n';
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitEventType(const MCSymbolWasm *Sym) {
|
|
assert(Sym->isEvent());
|
|
OS << "\t.eventtype\t" << Sym->getName() << " ";
|
|
OS << WebAssembly::typeListToString(Sym->getSignature()->Params);
|
|
OS << "\n";
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitImportModule(const MCSymbolWasm *Sym,
|
|
StringRef ImportModule) {
|
|
OS << "\t.import_module\t" << Sym->getName() << ", "
|
|
<< ImportModule << '\n';
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitImportName(const MCSymbolWasm *Sym,
|
|
StringRef ImportName) {
|
|
OS << "\t.import_name\t" << Sym->getName() << ", "
|
|
<< ImportName << '\n';
|
|
}
|
|
|
|
void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {
|
|
OS << "\t.indidx \t" << *Value << '\n';
|
|
}
|
|
|
|
void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<wasm::ValType> Types) {
|
|
SmallVector<std::pair<wasm::ValType, uint32_t>, 4> Grouped;
|
|
for (auto Type : Types) {
|
|
if (Grouped.empty() || Grouped.back().first != Type)
|
|
Grouped.push_back(std::make_pair(Type, 1));
|
|
else
|
|
++Grouped.back().second;
|
|
}
|
|
|
|
Streamer.EmitULEB128IntValue(Grouped.size());
|
|
for (auto Pair : Grouped) {
|
|
Streamer.EmitULEB128IntValue(Pair.second);
|
|
emitValueType(Pair.first);
|
|
}
|
|
}
|
|
|
|
void WebAssemblyTargetWasmStreamer::emitEndFunc() {
|
|
llvm_unreachable(".end_func is not needed for direct wasm output");
|
|
}
|
|
|
|
void WebAssemblyTargetWasmStreamer::emitIndIdx(const MCExpr *Value) {
|
|
llvm_unreachable(".indidx encoding not yet implemented");
|
|
}
|