diff options
Diffstat (limited to 'src/binary-reader-logging.cc')
| -rw-r--r-- | src/binary-reader-logging.cc | 592 |
1 files changed, 592 insertions, 0 deletions
diff --git a/src/binary-reader-logging.cc b/src/binary-reader-logging.cc new file mode 100644 index 00000000..6657a3e5 --- /dev/null +++ b/src/binary-reader-logging.cc @@ -0,0 +1,592 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "binary-reader-logging.h" + +#include <inttypes.h> + +#include "stream.h" + +namespace wabt { + +#define INDENT_SIZE 2 + +#define LOGF_NOINDENT(...) writef(stream, __VA_ARGS__) + +#define LOGF(...) \ + do { \ + WriteIndent(); \ + LOGF_NOINDENT(__VA_ARGS__); \ + } while (0) + +namespace { + +void sprint_limits(char* dst, size_t size, const Limits* limits) { + int result; + if (limits->has_max) { + result = wabt_snprintf(dst, size, "initial: %" PRIu64 ", max: %" PRIu64, + limits->initial, limits->max); + } else { + result = wabt_snprintf(dst, size, "initial: %" PRIu64, limits->initial); + } + WABT_USE(result); + assert(static_cast<size_t>(result) < size); +} + +} // namespace + +BinaryReaderLogging::BinaryReaderLogging(Stream* stream, BinaryReader* forward) + : stream(stream), reader(forward), indent(0) {} + +void BinaryReaderLogging::Indent() { + indent += INDENT_SIZE; +} + +void BinaryReaderLogging::Dedent() { + indent -= INDENT_SIZE; + assert(indent >= 0); +} + +void BinaryReaderLogging::WriteIndent() { + static char s_indent[] = + " " + " "; + static size_t s_indent_len = sizeof(s_indent) - 1; + size_t i = indent; + while (i > s_indent_len) { + write_data(stream, s_indent, s_indent_len, nullptr); + i -= s_indent_len; + } + if (i > 0) { + write_data(stream, s_indent, indent, nullptr); + } +} + +void BinaryReaderLogging::LogTypes(uint32_t type_count, Type* types) { + LOGF_NOINDENT("["); + for (uint32_t i = 0; i < type_count; ++i) { + LOGF_NOINDENT("%s", get_type_name(types[i])); + if (i != type_count - 1) + LOGF_NOINDENT(", "); + } + LOGF_NOINDENT("]"); +} + +bool BinaryReaderLogging::OnError(const char* message) { + return reader->OnError(message); +} + +void BinaryReaderLogging::OnSetState(const State* s) { + BinaryReader::OnSetState(s); + reader->OnSetState(s); +} + +Result BinaryReaderLogging::BeginModule(uint32_t version) { + LOGF("BeginModule(version: %u)\n", version); + Indent(); + return reader->BeginModule(version); +} + +Result BinaryReaderLogging::BeginSection(BinarySection section_type, + uint32_t size) { + return reader->BeginSection(section_type, size); +} + +Result BinaryReaderLogging::BeginCustomSection(uint32_t size, + StringSlice section_name) { + LOGF("BeginCustomSection('" PRIstringslice "', size: %d)\n", + WABT_PRINTF_STRING_SLICE_ARG(section_name), size); + Indent(); + return reader->BeginCustomSection(size, section_name); +} + +Result BinaryReaderLogging::OnType(uint32_t index, + uint32_t param_count, + Type* param_types, + uint32_t result_count, + Type* result_types) { + LOGF("OnType(index: %u, params: ", index); + LogTypes(param_count, param_types); + LOGF_NOINDENT(", results: "); + LogTypes(result_count, result_types); + LOGF_NOINDENT(")\n"); + return reader->OnType(index, param_count, param_types, result_count, + result_types); +} + +Result BinaryReaderLogging::OnImport(uint32_t index, + StringSlice module_name, + StringSlice field_name) { + LOGF("OnImport(index: %u, module: \"" PRIstringslice + "\", field: \"" PRIstringslice "\")\n", + index, WABT_PRINTF_STRING_SLICE_ARG(module_name), + WABT_PRINTF_STRING_SLICE_ARG(field_name)); + return reader->OnImport(index, module_name, field_name); +} + +Result BinaryReaderLogging::OnImportFunc(uint32_t import_index, + StringSlice module_name, + StringSlice field_name, + uint32_t func_index, + uint32_t sig_index) { + LOGF("OnImportFunc(import_index: %u, func_index: %u, sig_index: %u)\n", + import_index, func_index, sig_index); + return reader->OnImportFunc(import_index, module_name, field_name, func_index, + sig_index); +} + +Result BinaryReaderLogging::OnImportTable(uint32_t import_index, + StringSlice module_name, + StringSlice field_name, + uint32_t table_index, + Type elem_type, + const Limits* elem_limits) { + char buf[100]; + sprint_limits(buf, sizeof(buf), elem_limits); + LOGF("OnImportTable(import_index: %u, table_index: %u, elem_type: %s, %s)\n", + import_index, table_index, get_type_name(elem_type), buf); + return reader->OnImportTable(import_index, module_name, field_name, + table_index, elem_type, elem_limits); +} + +Result BinaryReaderLogging::OnImportMemory(uint32_t import_index, + StringSlice module_name, + StringSlice field_name, + uint32_t memory_index, + const Limits* page_limits) { + char buf[100]; + sprint_limits(buf, sizeof(buf), page_limits); + LOGF("OnImportMemory(import_index: %u, memory_index: %u, %s)\n", import_index, + memory_index, buf); + return reader->OnImportMemory(import_index, module_name, field_name, + memory_index, page_limits); +} + +Result BinaryReaderLogging::OnImportGlobal(uint32_t import_index, + StringSlice module_name, + StringSlice field_name, + uint32_t global_index, + Type type, + bool mutable_) { + LOGF( + "OnImportGlobal(import_index: %u, global_index: %u, type: %s, mutable: " + "%s)\n", + import_index, global_index, get_type_name(type), + mutable_ ? "true" : "false"); + return reader->OnImportGlobal(import_index, module_name, field_name, + global_index, type, mutable_); +} + +Result BinaryReaderLogging::OnTable(uint32_t index, + Type elem_type, + const Limits* elem_limits) { + char buf[100]; + sprint_limits(buf, sizeof(buf), elem_limits); + LOGF("OnTable(index: %u, elem_type: %s, %s)\n", index, + get_type_name(elem_type), buf); + return reader->OnTable(index, elem_type, elem_limits); +} + +Result BinaryReaderLogging::OnMemory(uint32_t index, + const Limits* page_limits) { + char buf[100]; + sprint_limits(buf, sizeof(buf), page_limits); + LOGF("OnMemory(index: %u, %s)\n", index, buf); + return reader->OnMemory(index, page_limits); +} + +Result BinaryReaderLogging::BeginGlobal(uint32_t index, + Type type, + bool mutable_) { + LOGF("BeginGlobal(index: %u, type: %s, mutable: %s)\n", index, + get_type_name(type), mutable_ ? "true" : "false"); + return reader->BeginGlobal(index, type, mutable_); +} + +Result BinaryReaderLogging::OnExport(uint32_t index, + ExternalKind kind, + uint32_t item_index, + StringSlice name) { + LOGF("OnExport(index: %u, kind: %s, item_index: %u, name: \"" PRIstringslice + "\")\n", + index, get_kind_name(kind), item_index, + WABT_PRINTF_STRING_SLICE_ARG(name)); + return reader->OnExport(index, kind, item_index, name); +} + +Result BinaryReaderLogging::OnLocalDecl(uint32_t decl_index, + uint32_t count, + Type type) { + LOGF("OnLocalDecl(index: %u, count: %u, type: %s)\n", decl_index, count, + get_type_name(type)); + return reader->OnLocalDecl(decl_index, count, type); +} + +Result BinaryReaderLogging::OnBlockExpr(uint32_t num_types, Type* sig_types) { + LOGF("OnBlockExpr(sig: "); + LogTypes(num_types, sig_types); + LOGF_NOINDENT(")\n"); + return reader->OnBlockExpr(num_types, sig_types); +} + +Result BinaryReaderLogging::OnBrExpr(uint32_t depth) { + LOGF("OnBrExpr(depth: %u)\n", depth); + return reader->OnBrExpr(depth); +} + +Result BinaryReaderLogging::OnBrIfExpr(uint32_t depth) { + LOGF("OnBrIfExpr(depth: %u)\n", depth); + return reader->OnBrIfExpr(depth); +} + +Result BinaryReaderLogging::OnBrTableExpr(uint32_t num_targets, + uint32_t* target_depths, + uint32_t default_target_depth) { + LOGF("OnBrTableExpr(num_targets: %u, depths: [", num_targets); + for (uint32_t i = 0; i < num_targets; ++i) { + LOGF_NOINDENT("%u", target_depths[i]); + if (i != num_targets - 1) + LOGF_NOINDENT(", "); + } + LOGF_NOINDENT("], default: %u)\n", default_target_depth); + return reader->OnBrTableExpr(num_targets, target_depths, + default_target_depth); +} + +Result BinaryReaderLogging::OnF32ConstExpr(uint32_t value_bits) { + float value; + memcpy(&value, &value_bits, sizeof(value)); + LOGF("OnF32ConstExpr(%g (0x04%x))\n", value, value_bits); + return reader->OnF32ConstExpr(value_bits); +} + +Result BinaryReaderLogging::OnF64ConstExpr(uint64_t value_bits) { + double value; + memcpy(&value, &value_bits, sizeof(value)); + LOGF("OnF64ConstExpr(%g (0x08%" PRIx64 "))\n", value, value_bits); + return reader->OnF64ConstExpr(value_bits); +} + +Result BinaryReaderLogging::OnI32ConstExpr(uint32_t value) { + LOGF("OnI32ConstExpr(%u (0x%x))\n", value, value); + return reader->OnI32ConstExpr(value); +} + +Result BinaryReaderLogging::OnI64ConstExpr(uint64_t value) { + LOGF("OnI64ConstExpr(%" PRIu64 " (0x%" PRIx64 "))\n", value, value); + return reader->OnI64ConstExpr(value); +} + +Result BinaryReaderLogging::OnIfExpr(uint32_t num_types, Type* sig_types) { + LOGF("OnIfExpr(sig: "); + LogTypes(num_types, sig_types); + LOGF_NOINDENT(")\n"); + return reader->OnIfExpr(num_types, sig_types); +} + +Result BinaryReaderLogging::OnLoadExpr(Opcode opcode, + uint32_t alignment_log2, + uint32_t offset) { + LOGF("OnLoadExpr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n", + get_opcode_name(opcode), static_cast<unsigned>(opcode), alignment_log2, + offset); + return reader->OnLoadExpr(opcode, alignment_log2, offset); +} + +Result BinaryReaderLogging::OnLoopExpr(uint32_t num_types, Type* sig_types) { + LOGF("OnLoopExpr(sig: "); + LogTypes(num_types, sig_types); + LOGF_NOINDENT(")\n"); + return reader->OnLoopExpr(num_types, sig_types); +} + +Result BinaryReaderLogging::OnStoreExpr(Opcode opcode, + uint32_t alignment_log2, + uint32_t offset) { + LOGF("OnStoreExpr(opcode: \"%s\" (%u), align log2: %u, offset: %u)\n", + get_opcode_name(opcode), static_cast<unsigned>(opcode), alignment_log2, + offset); + return reader->OnStoreExpr(opcode, alignment_log2, offset); +} + +Result BinaryReaderLogging::OnDataSegmentData(uint32_t index, + const void* data, + uint32_t size) { + LOGF("OnDataSegmentData(index:%u, size:%u)\n", index, size); + return reader->OnDataSegmentData(index, data, size); +} + +Result BinaryReaderLogging::OnFunctionNameSubsection(uint32_t index, + uint32_t name_type, + uint32_t subsection_size) { + LOGF("OnFunctionNameSubsection(index:%u, nametype:%u, size:%u)\n", index, + name_type, subsection_size); + return reader->OnFunctionNameSubsection(index, name_type, subsection_size); +} + +Result BinaryReaderLogging::OnFunctionName(uint32_t index, StringSlice name) { + LOGF("OnFunctionName(index: %u, name: \"" PRIstringslice "\")\n", index, + WABT_PRINTF_STRING_SLICE_ARG(name)); + return reader->OnFunctionName(index, name); +} + +Result BinaryReaderLogging::OnLocalNameSubsection(uint32_t index, + uint32_t name_type, + uint32_t subsection_size) { + LOGF("OnLocalNameSubsection(index:%u, nametype:%u, size:%u)\n", index, + name_type, subsection_size); + return reader->OnLocalNameSubsection(index, name_type, subsection_size); +} + +Result BinaryReaderLogging::OnLocalName(uint32_t func_index, + uint32_t local_index, + StringSlice name) { + LOGF("OnLocalName(func_index: %u, local_index: %u, name: \"" PRIstringslice + "\")\n", + func_index, local_index, WABT_PRINTF_STRING_SLICE_ARG(name)); + return reader->OnLocalName(func_index, local_index, name); +} + +Result BinaryReaderLogging::OnInitExprF32ConstExpr(uint32_t index, + uint32_t value_bits) { + float value; + memcpy(&value, &value_bits, sizeof(value)); + LOGF("OnInitExprF32ConstExpr(index: %u, value: %g (0x04%x))\n", index, value, + value_bits); + return reader->OnInitExprF32ConstExpr(index, value_bits); +} + +Result BinaryReaderLogging::OnInitExprF64ConstExpr(uint32_t index, + uint64_t value_bits) { + double value; + memcpy(&value, &value_bits, sizeof(value)); + LOGF("OnInitExprF64ConstExpr(index: %u value: %g (0x08%" PRIx64 "))\n", index, + value, value_bits); + return reader->OnInitExprF64ConstExpr(index, value_bits); +} + +Result BinaryReaderLogging::OnInitExprI32ConstExpr(uint32_t index, + uint32_t value) { + LOGF("OnInitExprI32ConstExpr(index: %u, value: %u)\n", index, value); + return reader->OnInitExprI32ConstExpr(index, value); +} + +Result BinaryReaderLogging::OnInitExprI64ConstExpr(uint32_t index, + uint64_t value) { + LOGF("OnInitExprI64ConstExpr(index: %u, value: %" PRIu64 ")\n", index, value); + return reader->OnInitExprI64ConstExpr(index, value); +} + +Result BinaryReaderLogging::OnRelocCount(uint32_t count, + BinarySection section_code, + StringSlice section_name) { + LOGF("OnRelocCount(count: %d, section: %s, section_name: " PRIstringslice + ")\n", + count, get_section_name(section_code), + WABT_PRINTF_STRING_SLICE_ARG(section_name)); + return reader->OnRelocCount(count, section_code, section_name); +} + +Result BinaryReaderLogging::OnReloc(RelocType type, + uint32_t offset, + uint32_t index, + int32_t addend) { + LOGF("OnReloc(type: %s, offset: %u, index: %u, addend: %d)\n", + get_reloc_type_name(type), offset, index, addend); + return reader->OnReloc(type, offset, index, addend); +} + +#define DEFINE_BEGIN(name) \ + Result BinaryReaderLogging::name(uint32_t size) { \ + LOGF(#name "(%u)\n", size); \ + Indent(); \ + return reader->name(size); \ + } + +#define DEFINE_END(name) \ + Result BinaryReaderLogging::name() { \ + Dedent(); \ + LOGF(#name "\n"); \ + return reader->name(); \ + } + +#define DEFINE_UINT32(name) \ + Result BinaryReaderLogging::name(uint32_t value) { \ + LOGF(#name "(%u)\n", value); \ + return reader->name(value); \ + } + +#define DEFINE_UINT32_DESC(name, desc) \ + Result BinaryReaderLogging::name(uint32_t value) { \ + LOGF(#name "(" desc ": %u)\n", value); \ + return reader->name(value); \ + } + +#define DEFINE_UINT32_UINT32(name, desc0, desc1) \ + Result BinaryReaderLogging::name(uint32_t value0, uint32_t value1) { \ + LOGF(#name "(" desc0 ": %u, " desc1 ": %u)\n", value0, value1); \ + return reader->name(value0, value1); \ + } + +#define DEFINE_OPCODE(name) \ + Result BinaryReaderLogging::name(Opcode opcode) { \ + LOGF(#name "(\"%s\" (%u))\n", get_opcode_name(opcode), \ + static_cast<unsigned>(opcode)); \ + return reader->name(opcode); \ + } + +#define DEFINE0(name) \ + Result BinaryReaderLogging::name() { \ + LOGF(#name "\n"); \ + return reader->name(); \ + } + +DEFINE_END(EndModule) + +DEFINE_END(EndCustomSection) + +DEFINE_BEGIN(BeginTypeSection) +DEFINE_UINT32(OnTypeCount) +DEFINE_END(EndTypeSection) + +DEFINE_BEGIN(BeginImportSection) +DEFINE_UINT32(OnImportCount) +DEFINE_END(EndImportSection) + +DEFINE_BEGIN(BeginFunctionSection) +DEFINE_UINT32(OnFunctionCount) +DEFINE_UINT32_UINT32(OnFunction, "index", "sig_index") +DEFINE_END(EndFunctionSection) + +DEFINE_BEGIN(BeginTableSection) +DEFINE_UINT32(OnTableCount) +DEFINE_END(EndTableSection) + +DEFINE_BEGIN(BeginMemorySection) +DEFINE_UINT32(OnMemoryCount) +DEFINE_END(EndMemorySection) + +DEFINE_BEGIN(BeginGlobalSection) +DEFINE_UINT32(OnGlobalCount) +DEFINE_UINT32(BeginGlobalInitExpr) +DEFINE_UINT32(EndGlobalInitExpr) +DEFINE_UINT32(EndGlobal) +DEFINE_END(EndGlobalSection) + +DEFINE_BEGIN(BeginExportSection) +DEFINE_UINT32(OnExportCount) +DEFINE_END(EndExportSection) + +DEFINE_BEGIN(BeginStartSection) +DEFINE_UINT32(OnStartFunction) +DEFINE_END(EndStartSection) + +DEFINE_BEGIN(BeginCodeSection) +DEFINE_UINT32(OnFunctionBodyCount) +DEFINE_UINT32(BeginFunctionBody) +DEFINE_UINT32(EndFunctionBody) +DEFINE_UINT32(OnLocalDeclCount) +DEFINE_OPCODE(OnBinaryExpr) +DEFINE_UINT32_DESC(OnCallExpr, "func_index") +DEFINE_UINT32_DESC(OnCallIndirectExpr, "sig_index") +DEFINE_OPCODE(OnCompareExpr) +DEFINE_OPCODE(OnConvertExpr) +DEFINE0(OnCurrentMemoryExpr) +DEFINE0(OnDropExpr) +DEFINE0(OnElseExpr) +DEFINE0(OnEndExpr) +DEFINE_UINT32_DESC(OnGetGlobalExpr, "index") +DEFINE_UINT32_DESC(OnGetLocalExpr, "index") +DEFINE0(OnGrowMemoryExpr) +DEFINE0(OnNopExpr) +DEFINE0(OnReturnExpr) +DEFINE0(OnSelectExpr) +DEFINE_UINT32_DESC(OnSetGlobalExpr, "index") +DEFINE_UINT32_DESC(OnSetLocalExpr, "index") +DEFINE_UINT32_DESC(OnTeeLocalExpr, "index") +DEFINE0(OnUnreachableExpr) +DEFINE_OPCODE(OnUnaryExpr) +DEFINE_END(EndCodeSection) + +DEFINE_BEGIN(BeginElemSection) +DEFINE_UINT32(OnElemSegmentCount) +DEFINE_UINT32_UINT32(BeginElemSegment, "index", "table_index") +DEFINE_UINT32(BeginElemSegmentInitExpr) +DEFINE_UINT32(EndElemSegmentInitExpr) +DEFINE_UINT32_UINT32(OnElemSegmentFunctionIndexCount, "index", "count") +DEFINE_UINT32_UINT32(OnElemSegmentFunctionIndex, "index", "func_index") +DEFINE_UINT32(EndElemSegment) +DEFINE_END(EndElemSection) + +DEFINE_BEGIN(BeginDataSection) +DEFINE_UINT32(OnDataSegmentCount) +DEFINE_UINT32_UINT32(BeginDataSegment, "index", "memory_index") +DEFINE_UINT32(BeginDataSegmentInitExpr) +DEFINE_UINT32(EndDataSegmentInitExpr) +DEFINE_UINT32(EndDataSegment) +DEFINE_END(EndDataSection) + +DEFINE_BEGIN(BeginNamesSection) +DEFINE_UINT32(OnFunctionNamesCount) +DEFINE_UINT32(OnLocalNameFunctionCount) +DEFINE_UINT32_UINT32(OnLocalNameLocalCount, "index", "count") +DEFINE_END(EndNamesSection) + +DEFINE_BEGIN(BeginRelocSection) +DEFINE_END(EndRelocSection) +DEFINE_UINT32_UINT32(OnInitExprGetGlobalExpr, "index", "global_index") + +// We don't need to log these (the individual opcodes are logged instead), but +// we still need to forward the calls. +Result BinaryReaderLogging::OnOpcode(Opcode opcode) { + return reader->OnOpcode(opcode); +} + +Result BinaryReaderLogging::OnOpcodeBare() { + return reader->OnOpcodeBare(); +} + +Result BinaryReaderLogging::OnOpcodeUint32(uint32_t value) { + return reader->OnOpcodeUint32(value); +} + +Result BinaryReaderLogging::OnOpcodeUint32Uint32(uint32_t value, + uint32_t value2) { + return reader->OnOpcodeUint32Uint32(value, value2); +} + +Result BinaryReaderLogging::OnOpcodeUint64(uint64_t value) { + return reader->OnOpcodeUint64(value); +} + +Result BinaryReaderLogging::OnOpcodeF32(uint32_t value) { + return reader->OnOpcodeF32(value); +} + +Result BinaryReaderLogging::OnOpcodeF64(uint64_t value) { + return reader->OnOpcodeF64(value); +} + +Result BinaryReaderLogging::OnOpcodeBlockSig(uint32_t num_types, + Type* sig_types) { + return reader->OnOpcodeBlockSig(num_types, sig_types); +} + +Result BinaryReaderLogging::OnEndFunc() { + return reader->OnEndFunc(); +} + +} // namespace wabt |