blob: 599b42b2217cd5983489f674836a845ca8e420c7 [file] [log] [blame]
//===- WriterUtils.cpp ----------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "WriterUtils.h"
#include "lld/Common/ErrorHandler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/LEB128.h"
#define DEBUG_TYPE "lld"
using namespace llvm;
using namespace llvm::wasm;
namespace lld {
void wasm::debugWrite(uint64_t Offset, const Twine &Msg) {
LLVM_DEBUG(dbgs() << format(" | %08lld: ", Offset) << Msg << "\n");
}
void wasm::writeUleb128(raw_ostream &OS, uint32_t Number, const Twine &Msg) {
debugWrite(OS.tell(), Msg + "[" + utohexstr(Number) + "]");
encodeULEB128(Number, OS);
}
void wasm::writeSleb128(raw_ostream &OS, int32_t Number, const Twine &Msg) {
debugWrite(OS.tell(), Msg + "[" + utohexstr(Number) + "]");
encodeSLEB128(Number, OS);
}
void wasm::writeBytes(raw_ostream &OS, const char *Bytes, size_t Count,
const Twine &Msg) {
debugWrite(OS.tell(), Msg + " [data[" + Twine(Count) + "]]");
OS.write(Bytes, Count);
}
void wasm::writeStr(raw_ostream &OS, StringRef String, const Twine &Msg) {
debugWrite(OS.tell(),
Msg + " [str[" + Twine(String.size()) + "]: " + String + "]");
encodeULEB128(String.size(), OS);
OS.write(String.data(), String.size());
}
void wasm::writeU8(raw_ostream &OS, uint8_t Byte, const Twine &Msg) {
debugWrite(OS.tell(), Msg + " [0x" + utohexstr(Byte) + "]");
OS << Byte;
}
void wasm::writeU32(raw_ostream &OS, uint32_t Number, const Twine &Msg) {
debugWrite(OS.tell(), Msg + "[0x" + utohexstr(Number) + "]");
support::endian::write(OS, Number, support::little);
}
void wasm::writeValueType(raw_ostream &OS, ValType Type, const Twine &Msg) {
writeU8(OS, static_cast<uint8_t>(Type),
Msg + "[type: " + toString(Type) + "]");
}
void wasm::writeSig(raw_ostream &OS, const WasmSignature &Sig) {
writeU8(OS, WASM_TYPE_FUNC, "signature type");
writeUleb128(OS, Sig.Params.size(), "param Count");
for (ValType ParamType : Sig.Params) {
writeValueType(OS, ParamType, "param type");
}
writeUleb128(OS, Sig.Returns.size(), "result Count");
if (Sig.Returns.size()) {
writeValueType(OS, Sig.Returns[0], "result type");
}
}
void wasm::writeInitExpr(raw_ostream &OS, const WasmInitExpr &InitExpr) {
writeU8(OS, InitExpr.Opcode, "opcode");
switch (InitExpr.Opcode) {
case WASM_OPCODE_I32_CONST:
writeSleb128(OS, InitExpr.Value.Int32, "literal (i32)");
break;
case WASM_OPCODE_I64_CONST:
writeSleb128(OS, InitExpr.Value.Int64, "literal (i64)");
break;
case WASM_OPCODE_GLOBAL_GET:
writeUleb128(OS, InitExpr.Value.Global, "literal (global index)");
break;
default:
fatal("unknown opcode in init expr: " + Twine(InitExpr.Opcode));
}
writeU8(OS, WASM_OPCODE_END, "opcode:end");
}
void wasm::writeLimits(raw_ostream &OS, const WasmLimits &Limits) {
writeU8(OS, Limits.Flags, "limits flags");
writeUleb128(OS, Limits.Initial, "limits initial");
if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
writeUleb128(OS, Limits.Maximum, "limits max");
}
void wasm::writeGlobalType(raw_ostream &OS, const WasmGlobalType &Type) {
// TODO: Update WasmGlobalType to use ValType and remove this cast.
writeValueType(OS, ValType(Type.Type), "global type");
writeU8(OS, Type.Mutable, "global mutable");
}
void wasm::writeGlobal(raw_ostream &OS, const WasmGlobal &Global) {
writeGlobalType(OS, Global.Type);
writeInitExpr(OS, Global.InitExpr);
}
void wasm::writeEventType(raw_ostream &OS, const WasmEventType &Type) {
writeUleb128(OS, Type.Attribute, "event attribute");
writeUleb128(OS, Type.SigIndex, "sig index");
}
void wasm::writeEvent(raw_ostream &OS, const WasmEvent &Event) {
writeEventType(OS, Event.Type);
}
void wasm::writeTableType(raw_ostream &OS, const llvm::wasm::WasmTable &Type) {
writeU8(OS, WASM_TYPE_FUNCREF, "table type");
writeLimits(OS, Type.Limits);
}
void wasm::writeImport(raw_ostream &OS, const WasmImport &Import) {
writeStr(OS, Import.Module, "import module name");
writeStr(OS, Import.Field, "import field name");
writeU8(OS, Import.Kind, "import kind");
switch (Import.Kind) {
case WASM_EXTERNAL_FUNCTION:
writeUleb128(OS, Import.SigIndex, "import sig index");
break;
case WASM_EXTERNAL_GLOBAL:
writeGlobalType(OS, Import.Global);
break;
case WASM_EXTERNAL_EVENT:
writeEventType(OS, Import.Event);
break;
case WASM_EXTERNAL_MEMORY:
writeLimits(OS, Import.Memory);
break;
case WASM_EXTERNAL_TABLE:
writeTableType(OS, Import.Table);
break;
default:
fatal("unsupported import type: " + Twine(Import.Kind));
}
}
void wasm::writeExport(raw_ostream &OS, const WasmExport &Export) {
writeStr(OS, Export.Name, "export name");
writeU8(OS, Export.Kind, "export kind");
switch (Export.Kind) {
case WASM_EXTERNAL_FUNCTION:
writeUleb128(OS, Export.Index, "function index");
break;
case WASM_EXTERNAL_GLOBAL:
writeUleb128(OS, Export.Index, "global index");
break;
case WASM_EXTERNAL_MEMORY:
writeUleb128(OS, Export.Index, "memory index");
break;
case WASM_EXTERNAL_TABLE:
writeUleb128(OS, Export.Index, "table index");
break;
default:
fatal("unsupported export type: " + Twine(Export.Kind));
}
}
} // namespace lld
std::string lld::toString(ValType Type) {
switch (Type) {
case ValType::I32:
return "i32";
case ValType::I64:
return "i64";
case ValType::F32:
return "f32";
case ValType::F64:
return "f64";
case ValType::V128:
return "v128";
case ValType::EXCEPT_REF:
return "except_ref";
}
llvm_unreachable("Invalid wasm::ValType");
}
std::string lld::toString(const WasmSignature &Sig) {
SmallString<128> S("(");
for (ValType Type : Sig.Params) {
if (S.size() != 1)
S += ", ";
S += toString(Type);
}
S += ") -> ";
if (Sig.Returns.size() == 0)
S += "void";
else
S += toString(Sig.Returns[0]);
return S.str();
}
std::string lld::toString(const WasmGlobalType &Type) {
return (Type.Mutable ? "var " : "const ") +
toString(static_cast<ValType>(Type.Type));
}
std::string lld::toString(const WasmEventType &Type) {
if (Type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
return "exception";
return "unknown";
}