mirror of
https://github.com/bytecodealliance/wasm-micro-runtime.git
synced 2025-05-28 12:37:25 +00:00
666 lines
22 KiB
C++
666 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2024 Xiaomi Corporation. All rights reserved.
|
|
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
*/
|
|
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
|
|
#include "aot_file.h"
|
|
#include "common.h"
|
|
#include "option_parser.h"
|
|
#include "wasm_file.h"
|
|
|
|
using namespace analyzer;
|
|
|
|
static const char s_description[] =
|
|
R"( Print information about the contents of AoT binaries.
|
|
|
|
examples:
|
|
$ aot-analyzer example.aot
|
|
)";
|
|
|
|
struct func_info {
|
|
uint32_t idx;
|
|
void *ptr;
|
|
};
|
|
|
|
static int
|
|
compare_func_ptrs(const void *f1, const void *f2)
|
|
{
|
|
return (intptr_t)((struct func_info *)f1)->ptr
|
|
- (intptr_t)((struct func_info *)f2)->ptr;
|
|
}
|
|
|
|
static struct func_info *
|
|
sort_func_ptrs(const AOTModule *module)
|
|
{
|
|
uint64_t content_len;
|
|
struct func_info *sorted_func_ptrs;
|
|
unsigned i;
|
|
|
|
content_len = (uint64_t)sizeof(struct func_info) * module->func_count;
|
|
sorted_func_ptrs = (struct func_info *)wasm_runtime_malloc(content_len);
|
|
if (!sorted_func_ptrs) {
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < module->func_count; i++) {
|
|
sorted_func_ptrs[i].idx = i;
|
|
sorted_func_ptrs[i].ptr = module->func_ptrs[i];
|
|
}
|
|
|
|
qsort(sorted_func_ptrs, module->func_count, sizeof(struct func_info),
|
|
compare_func_ptrs);
|
|
return sorted_func_ptrs;
|
|
}
|
|
|
|
static ObjdumpOptions s_objdump_options;
|
|
|
|
static std::vector<const char *> s_infiles;
|
|
|
|
static void
|
|
ParseOptions(int argc, char **argv)
|
|
{
|
|
OptionParser parser("aot-analyzer", s_description);
|
|
|
|
parser.AddOption('i', "info", "Print basic information about AoT",
|
|
[]() { s_objdump_options.info = true; });
|
|
parser.AddOption('t', "text-size", "Print text size",
|
|
[]() { s_objdump_options.text_size = true; });
|
|
parser.AddOption('x', "details", "Show AoT details",
|
|
[]() { s_objdump_options.details = true; });
|
|
parser.AddOption('c', "compare",
|
|
"Show the differences between AoT and WASM",
|
|
[]() { s_objdump_options.compare = true; });
|
|
parser.AddArgument(
|
|
"filename", OptionParser::ArgumentCount::OneOrMore,
|
|
[](const char *argument) { s_infiles.push_back(argument); });
|
|
parser.Parse(argc, argv);
|
|
}
|
|
|
|
void
|
|
InitStdio()
|
|
{
|
|
#if COMPILER_IS_MSVC
|
|
int result = _setmode(_fileno(stdout), _O_BINARY);
|
|
if (result == -1) {
|
|
perror("Cannot set mode binary to stdout");
|
|
}
|
|
result = _setmode(_fileno(stderr), _O_BINARY);
|
|
if (result == -1) {
|
|
perror("Cannot set mode binary to stderr");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
dump_value_type(uint8 type)
|
|
{
|
|
switch (type) {
|
|
case VALUE_TYPE_I32:
|
|
printf("i32");
|
|
break;
|
|
case VALUE_TYPE_I64:
|
|
printf("i64");
|
|
break;
|
|
case VALUE_TYPE_F32:
|
|
printf("f32");
|
|
break;
|
|
case VALUE_TYPE_F64:
|
|
printf("f64");
|
|
break;
|
|
case VALUE_TYPE_V128:
|
|
printf("v128");
|
|
break;
|
|
case PACKED_TYPE_I8:
|
|
printf("i8");
|
|
break;
|
|
case PACKED_TYPE_I16:
|
|
printf("i16");
|
|
break;
|
|
case REF_TYPE_FUNCREF:
|
|
printf("funcref");
|
|
break;
|
|
case REF_TYPE_EXTERNREF:
|
|
printf("externref");
|
|
break;
|
|
case REF_TYPE_ANYREF:
|
|
printf("anyref");
|
|
break;
|
|
case REF_TYPE_EQREF:
|
|
printf("eqref");
|
|
break;
|
|
case REF_TYPE_I31REF:
|
|
printf("i31ref");
|
|
break;
|
|
case REF_TYPE_STRUCTREF:
|
|
printf("structref");
|
|
break;
|
|
case REF_TYPE_ARRAYREF:
|
|
printf("arrayref");
|
|
break;
|
|
case REF_TYPE_NULLREF:
|
|
printf("nullref");
|
|
break;
|
|
case REF_TYPE_NULLFUNCREF:
|
|
printf("nullfuncref");
|
|
break;
|
|
case REF_TYPE_NULLEXTERNREF:
|
|
printf("nullexternref");
|
|
break;
|
|
default:
|
|
printf("unknown");
|
|
}
|
|
}
|
|
|
|
void
|
|
DumpInfo(AoTFile *aot)
|
|
{
|
|
const AOTTargetInfo target_info = aot->GetTargetInfo();
|
|
printf("AOT File Information:\n\n");
|
|
printf("Binary type: %s\n",
|
|
aot->GetBinTypeName(target_info.bin_type).c_str());
|
|
printf("ABI type: %d\n", target_info.abi_type);
|
|
printf("Exectuion type: %s\n",
|
|
aot->GetExectuionTypeName(target_info.e_type).c_str());
|
|
printf("Exectuion machine: %s\n",
|
|
aot->GetExectuionMachineName(target_info.e_machine).c_str());
|
|
printf("Exectuion version: %u\n", target_info.e_version);
|
|
printf("Exectuion flags: %u\n", target_info.e_flags);
|
|
printf("Feature flags: %" PRId64 "\n", target_info.feature_flags);
|
|
printf("Reserved: %" PRId64 "\n", target_info.reserved);
|
|
printf("Arch: %s\n", target_info.arch);
|
|
}
|
|
|
|
void
|
|
DumpTextSize(AoTFile *aot)
|
|
{
|
|
const AOTTargetInfo target_info = aot->GetTargetInfo();
|
|
printf("%s: file format <%s>\n\n", aot->GetFileName(),
|
|
aot->GetBinTypeName(target_info.bin_type).c_str());
|
|
printf("Text size:\n");
|
|
|
|
const uint32_t literal_size =
|
|
((AOTModule *)(aot->GetModule()))->literal_size;
|
|
const uint32_t code_size = ((AOTModule *)(aot->GetModule()))->code_size;
|
|
printf(" literal size= %u Bytes\n", literal_size);
|
|
printf(" code size= %u Bytes\n", code_size);
|
|
}
|
|
|
|
void
|
|
DumpDetails(AoTFile *aot)
|
|
{
|
|
const AOTTargetInfo target_info = aot->GetTargetInfo();
|
|
printf("%s: file format <%s>\n\n", aot->GetFileName(),
|
|
aot->GetBinTypeName(target_info.bin_type).c_str());
|
|
printf("Details:\n\n");
|
|
|
|
// Types
|
|
const uint32_t type_count = ((AOTModule *)(aot->GetModule()))->type_count;
|
|
AOTType **types = ((AOTModule *)(aot->GetModule()))->types;
|
|
printf("Types[%u]\n", type_count);
|
|
#if WASM_ENABLE_GC != 0
|
|
const char *wasm_type[] = { "function", "struct", "array" };
|
|
for (uint32_t index = 0; index < type_count; index++) {
|
|
AOTType *type = types[index];
|
|
const uint16_t type_flag = type->type_flag;
|
|
printf(" -[%u] ", index);
|
|
if (type_flag == WASM_TYPE_FUNC) {
|
|
wasm_dump_func_type(((AOTFuncType *)type));
|
|
}
|
|
else if (type_flag == WASM_TYPE_STRUCT) {
|
|
wasm_dump_struct_type(((AOTStructType *)type));
|
|
}
|
|
else if (type_flag == WASM_TYPE_ARRAY) {
|
|
wasm_dump_array_type(((AOTArrayType *)type));
|
|
}
|
|
else {
|
|
printf(" -[%u] unknown type\n", index);
|
|
}
|
|
}
|
|
#else
|
|
for (uint32_t index = 0; index < type_count; index++) {
|
|
printf(" -[%u] ", index);
|
|
AOTType *type = types[index];
|
|
uint32_t i = 0;
|
|
printf("func [");
|
|
|
|
for (i = 0; i < type->param_count; i++) {
|
|
dump_value_type(type->types[i]);
|
|
if (i < (uint32)type->param_count - 1)
|
|
printf(" ");
|
|
}
|
|
|
|
printf("] -> [");
|
|
|
|
for (; i < (uint32)(type->param_count + type->result_count); i++) {
|
|
dump_value_type(type->types[i]);
|
|
if (i < (uint32)type->param_count + type->result_count - 1)
|
|
printf(" ");
|
|
}
|
|
|
|
printf("]\n");
|
|
}
|
|
#endif
|
|
printf("\n\n");
|
|
|
|
// Imports
|
|
const uint32_t import_memory_count =
|
|
((AOTModule *)(aot->GetModule()))->import_memory_count;
|
|
AOTImportMemory *import_memories =
|
|
((AOTModule *)(aot->GetModule()))->import_memories;
|
|
const uint32_t import_table_count =
|
|
((AOTModule *)(aot->GetModule()))->import_table_count;
|
|
AOTImportTable *import_tables =
|
|
((AOTModule *)(aot->GetModule()))->import_tables;
|
|
const uint32_t import_global_count =
|
|
((AOTModule *)(aot->GetModule()))->import_global_count;
|
|
AOTImportGlobal *import_globals =
|
|
((AOTModule *)(aot->GetModule()))->import_globals;
|
|
const uint32_t import_func_count =
|
|
((AOTModule *)(aot->GetModule()))->import_func_count;
|
|
AOTImportFunc *import_funcs =
|
|
((AOTModule *)(aot->GetModule()))->import_funcs;
|
|
printf("Imports[%u]\n", import_memory_count + import_table_count
|
|
+ import_global_count + import_func_count);
|
|
|
|
// import memories
|
|
printf(" -import_memories[%u]\n", import_memory_count);
|
|
for (uint32_t index = 0; index < import_memory_count; index++) {
|
|
AOTImportMemory memory = import_memories[index];
|
|
printf(" -[%u] num_bytes_per_page:%5u init_page_count:%5u "
|
|
"max_page_count:%5u module_name: %s memory_name: %s\n",
|
|
index, memory.mem_type.num_bytes_per_page,
|
|
memory.mem_type.init_page_count, memory.mem_type.max_page_count,
|
|
memory.module_name, memory.memory_name);
|
|
}
|
|
printf("\n");
|
|
|
|
// import tables
|
|
printf(" -import_tables[%u]\n", import_table_count);
|
|
for (uint32_t index = 0; index < import_table_count; index++) {
|
|
AOTImportTable table = import_tables[index];
|
|
printf(" -[%u] ", index);
|
|
printf("elem_type: ");
|
|
#if WASM_ENABLE_GC != 0
|
|
wasm_dump_value_type(table.table_type.elem_type,
|
|
table.table_type.elem_ref_type);
|
|
#else
|
|
dump_value_type(table.table_type.elem_type);
|
|
#endif
|
|
printf(" init_size:%5u max_size:%5u "
|
|
"module_name: %s table_name: %s\n",
|
|
table.table_type.init_size, table.table_type.max_size,
|
|
table.module_name, table.table_name);
|
|
}
|
|
printf("\n");
|
|
|
|
// import globals
|
|
printf(" -import_globals[%u]\n", import_global_count);
|
|
for (uint32_t index = 0; index < import_global_count; index++) {
|
|
AOTImportGlobal global = import_globals[index];
|
|
printf(" -[%u] ", index);
|
|
printf("type: ");
|
|
dump_value_type(global.type.val_type);
|
|
printf(" module_name: %s global_name: %s\n", global.module_name,
|
|
global.global_name);
|
|
}
|
|
printf("\n");
|
|
|
|
// import functions
|
|
printf(" -import_functions[%u]\n", import_func_count);
|
|
for (uint32_t index = 0; index < import_func_count; index++) {
|
|
AOTImportFunc func = import_funcs[index];
|
|
printf(" -[%u] module_name: %s function_name: %s\n", index,
|
|
func.module_name, func.func_name);
|
|
}
|
|
printf("\n\n");
|
|
|
|
// Functions
|
|
const uint32_t func_count = ((AOTModule *)(aot->GetModule()))->func_count;
|
|
const uint32_t code_size = ((AOTModule *)(aot->GetModule()))->code_size;
|
|
struct func_info *sorted_func_ptrs = NULL;
|
|
sorted_func_ptrs = sort_func_ptrs(((AOTModule *)(aot->GetModule())));
|
|
|
|
if (sorted_func_ptrs) {
|
|
printf("Function[%u]\n", func_count);
|
|
for (uint32_t index = 0; index < func_count; index++) {
|
|
const uint32_t func_size =
|
|
index + 1 < func_count
|
|
? (uintptr_t)(sorted_func_ptrs[index + 1].ptr)
|
|
- (uintptr_t)(sorted_func_ptrs[index].ptr)
|
|
: code_size
|
|
+ (uintptr_t)(((AOTModule *)(aot->GetModule()))->code)
|
|
- (uintptr_t)(sorted_func_ptrs[index].ptr);
|
|
printf(" -[%u] code_size= %u Bytes\n", index, func_size);
|
|
}
|
|
wasm_runtime_free(sorted_func_ptrs);
|
|
printf("\n\n");
|
|
}
|
|
|
|
// Tables
|
|
const uint32_t table_count = ((AOTModule *)(aot->GetModule()))->table_count;
|
|
AOTTable *tables = ((AOTModule *)(aot->GetModule()))->tables;
|
|
printf("Tables[%u]\n", table_count);
|
|
for (uint32_t index = 0; index < table_count; index++) {
|
|
AOTTable table = tables[index];
|
|
printf(" -[%u] ", index);
|
|
printf("elem_type: ");
|
|
#if WASM_ENABLE_GC != 0
|
|
wasm_dump_value_type(table.table_type.elem_type,
|
|
table.table_type.elem_ref_type);
|
|
#else
|
|
dump_value_type(table.table_type.elem_type);
|
|
#endif
|
|
printf(" init_size:%5u max_size:%5u\n",
|
|
table.table_type.init_size, table.table_type.max_size);
|
|
}
|
|
printf("\n\n");
|
|
|
|
// Memories
|
|
const uint32_t memory_count =
|
|
((AOTModule *)(aot->GetModule()))->memory_count;
|
|
AOTMemory *memories = ((AOTModule *)(aot->GetModule()))->memories;
|
|
printf("Memories[%u]\n", memory_count);
|
|
|
|
for (uint32_t index = 0; index < memory_count; index++) {
|
|
AOTMemory memory = memories[index];
|
|
printf(" -[%u] flags:%5u bytes_per_page:%5u "
|
|
"init_page_count:%5u max_page_count:%5u\n",
|
|
index, memory.flags, memory.num_bytes_per_page,
|
|
memory.init_page_count, memory.max_page_count);
|
|
}
|
|
printf("\n\n");
|
|
|
|
// Globals
|
|
const uint32_t global_count =
|
|
((AOTModule *)(aot->GetModule()))->global_count;
|
|
AOTGlobal *globals = ((AOTModule *)(aot->GetModule()))->globals;
|
|
printf("Globals[%u]\n", global_count);
|
|
|
|
for (uint32_t index = 0; index < global_count; index++) {
|
|
AOTGlobal global = globals[index];
|
|
printf(" -[%u] ", index);
|
|
printf("type: ");
|
|
dump_value_type(global.type.val_type);
|
|
printf(" is_mutable: %d size: %u data_offset: %u\n",
|
|
global.type.is_mutable, global.size, global.data_offset);
|
|
}
|
|
printf("\n\n");
|
|
|
|
// Exports
|
|
const uint32_t export_count =
|
|
((AOTModule *)(aot->GetModule()))->export_count;
|
|
AOTExport *exports = ((AOTModule *)(aot->GetModule()))->exports;
|
|
printf("Exports[%u]\n", export_count);
|
|
|
|
for (uint32_t index = 0; index < export_count; index++) {
|
|
AOTExport expt = exports[index];
|
|
printf(" -[%u] kind:%5d index:%5u name: %s\n", index, expt.kind,
|
|
expt.index, expt.name);
|
|
}
|
|
printf("\n\n");
|
|
|
|
// Code
|
|
const uint32_t aot_code_size = (aot->GetMemConsumption()).aot_code_size;
|
|
const uint32_t literal_size =
|
|
((AOTModule *)(aot->GetModule()))->literal_size;
|
|
const uint32_t data_section_count =
|
|
((AOTModule *)(aot->GetModule()))->data_section_count;
|
|
|
|
printf("Codes[%u]\n", aot_code_size);
|
|
printf(" -code\n");
|
|
printf(" -code_size: %u Bytes\n", code_size);
|
|
printf("\n");
|
|
printf(" -literal\n");
|
|
printf(" -literal_size: %u Bytes\n", literal_size);
|
|
printf("\n");
|
|
printf(" -data section\n");
|
|
for (uint32_t index = 0; index < data_section_count; index++) {
|
|
AOTObjectDataSection *obj_data =
|
|
((AOTModule *)(aot->GetModule()))->data_sections + index;
|
|
printf(" -[%u] code_size:%5u Bytes name: %s\n", index,
|
|
obj_data->size, obj_data->name);
|
|
}
|
|
printf("\n\n");
|
|
}
|
|
|
|
void
|
|
DumpCompare(AoTFile *aot, WasmFile *wasm)
|
|
{
|
|
const AOTTargetInfo target_info = aot->GetTargetInfo();
|
|
AOTModule *aot_module = (AOTModule *)(aot->GetModule());
|
|
WASMModuleMemConsumption aot_mem_conspn = aot->GetMemConsumption();
|
|
|
|
WASMModule *wasm_module = (WASMModule *)(wasm->GetModule());
|
|
|
|
const uint32_t aot_func_count = aot_module->func_count;
|
|
const uint32_t aot_code_size = aot_module->code_size;
|
|
struct func_info *sorted_func_ptrs = NULL;
|
|
sorted_func_ptrs = sort_func_ptrs(((AOTModule *)(aot->GetModule())));
|
|
if (!sorted_func_ptrs) {
|
|
printf("sort AoT functions failed.\n");
|
|
return;
|
|
}
|
|
|
|
const uint32_t wasm_func_count = wasm_module->function_count;
|
|
WASMFunction **wasm_functions = wasm_module->functions;
|
|
|
|
if (aot_func_count != wasm_func_count) {
|
|
printf("The number of AoT functions does not match the number of Wasm "
|
|
"functions.\n");
|
|
wasm_runtime_free(sorted_func_ptrs);
|
|
return;
|
|
}
|
|
|
|
uint32_t wasm_code_size = 0;
|
|
// print function Comparison Details
|
|
printf(
|
|
"|--------------------------------------------------------------------"
|
|
"-------------------|\n");
|
|
printf(
|
|
"| Function Code Size Compare "
|
|
" |\n");
|
|
printf(
|
|
"|--------------------------------------------------------------------"
|
|
"-------------------|\n");
|
|
printf(
|
|
"| ID | AoT Function Code Size | Wasm Function Code Size | "
|
|
"expansion multiple |\n");
|
|
printf(
|
|
"|--------------------------------------------------------------------"
|
|
"-------------------|\n");
|
|
|
|
for (uint32_t index = 0; index < aot_func_count; index++) {
|
|
const uint32_t aot_func_size =
|
|
index + 1 < aot_func_count
|
|
? (uintptr_t)(sorted_func_ptrs[index + 1].ptr)
|
|
- (uintptr_t)(sorted_func_ptrs[index].ptr)
|
|
: aot_code_size + (uintptr_t)(aot_module->code)
|
|
- (uintptr_t)(sorted_func_ptrs[index].ptr);
|
|
const uint32_t wasm_func_size = wasm_functions[index]->code_size;
|
|
wasm_code_size += wasm_func_size;
|
|
printf(
|
|
"| %4d | %10d Bytes | %10d Bytes | %10.2f "
|
|
" "
|
|
" |\n",
|
|
index, aot_func_size, wasm_func_size,
|
|
(aot_func_size * 1.0) / wasm_func_size);
|
|
printf(
|
|
"|-----------------------------------------------------------------"
|
|
"-"
|
|
"---------------------|\n");
|
|
}
|
|
wasm_runtime_free(sorted_func_ptrs);
|
|
|
|
printf("\n\n");
|
|
|
|
printf(
|
|
"|--------------------------------------------------------------------"
|
|
"---|\n");
|
|
printf(
|
|
"| Total Code Size Compare "
|
|
" |\n");
|
|
printf(
|
|
"|--------------------------------------------------------------------"
|
|
"---|\n");
|
|
printf("| AoT code size= %10d Bytes | Wasm code size= %10d Bytes |\n",
|
|
aot_code_size, wasm_code_size);
|
|
printf(
|
|
"|--------------------------------------------------------------------"
|
|
"---|\n");
|
|
}
|
|
|
|
int
|
|
ProgramMain(int argc, char **argv)
|
|
{
|
|
InitStdio();
|
|
|
|
ParseOptions(argc, argv);
|
|
if (!s_objdump_options.info && !s_objdump_options.text_size
|
|
&& !s_objdump_options.details && !s_objdump_options.compare) {
|
|
fprintf(stderr,
|
|
"At least one of the following switches must be given:\n");
|
|
fprintf(stderr, " -i/ --info\n");
|
|
fprintf(stderr, " -t/ --text-size\n");
|
|
fprintf(stderr, " -x/ --details\n");
|
|
fprintf(stderr, " -c/ --compare\n");
|
|
return 1;
|
|
}
|
|
|
|
std::vector<BinaryFile *> readers;
|
|
for (const char *filename : s_infiles) {
|
|
BinaryFile *reader = NULL;
|
|
const char *dot = strrchr(filename, '.');
|
|
if (!dot) {
|
|
printf("bad file name: %s\n", filename);
|
|
continue;
|
|
}
|
|
|
|
if (strncmp(dot, ".aot", 4) == 0) {
|
|
reader = new AoTFile(filename);
|
|
}
|
|
else if (strncmp(dot, ".wasm", 4) == 0) {
|
|
reader = new WasmFile(filename);
|
|
}
|
|
else {
|
|
printf("unkown file extension: %s\n", dot);
|
|
continue;
|
|
}
|
|
|
|
if (reader && reader->ReadModule() == Result::Error) {
|
|
printf("read module failed.\n");
|
|
continue;
|
|
}
|
|
|
|
CHECK_RESULT(reader->Scan());
|
|
readers.push_back(reader);
|
|
}
|
|
|
|
// -i/ --info
|
|
if (s_objdump_options.info == 1) {
|
|
for (size_t i = 0; i < readers.size(); ++i) {
|
|
printf("\n");
|
|
|
|
BinaryFile *reader = readers[i];
|
|
const uint32_t module_type = reader->GetModule()->module_type;
|
|
if (module_type == Wasm_Module_AoT) {
|
|
AoTFile *aot = dynamic_cast<AoTFile *>(reader);
|
|
if (!aot) {
|
|
printf("[DumpInfo]: Reader cast failed.\n");
|
|
continue;
|
|
}
|
|
DumpInfo(aot);
|
|
}
|
|
else {
|
|
printf("[DumpInfo]: Wrong file format, not an AoT file.\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// -t/ --text-size
|
|
if (s_objdump_options.text_size == 1) {
|
|
for (size_t i = 0; i < readers.size(); ++i) {
|
|
printf("\n");
|
|
|
|
BinaryFile *reader = readers[i];
|
|
const uint32_t module_type = reader->GetModule()->module_type;
|
|
if (module_type == Wasm_Module_AoT) {
|
|
AoTFile *aot = dynamic_cast<AoTFile *>(reader);
|
|
if (!aot) {
|
|
printf("[DumpTextSize]: Reader cast failed.\n");
|
|
continue;
|
|
}
|
|
DumpTextSize(aot);
|
|
}
|
|
else {
|
|
printf("[DumpTextSize]: Wrong file format, not an AoT file.\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// -x/ --details
|
|
if (s_objdump_options.details == 1) {
|
|
for (size_t i = 0; i < readers.size(); ++i) {
|
|
printf("\n");
|
|
|
|
BinaryFile *reader = readers[i];
|
|
const uint32_t module_type = reader->GetModule()->module_type;
|
|
if (module_type == Wasm_Module_AoT) {
|
|
AoTFile *aot = dynamic_cast<AoTFile *>(reader);
|
|
if (!aot) {
|
|
printf("[DumpDetails]: Reader cast failed.\n");
|
|
continue;
|
|
}
|
|
DumpDetails(aot);
|
|
}
|
|
else {
|
|
printf("[DumpDetails]: Wrong file format, not an AoT file.\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
// -c/ --compare
|
|
if (s_objdump_options.compare == 1) {
|
|
printf("\n");
|
|
|
|
if (readers.size() != 2) {
|
|
printf("[DumpCompare]: Illegal number of file parameters.\n");
|
|
return 1;
|
|
}
|
|
|
|
AoTFile *aot = NULL;
|
|
WasmFile *wasm = NULL;
|
|
for (size_t i = 0; i < readers.size(); ++i) {
|
|
BinaryFile *reader = readers[i];
|
|
const uint32_t module_type = reader->GetModule()->module_type;
|
|
if (module_type == Wasm_Module_AoT) {
|
|
aot = dynamic_cast<AoTFile *>(reader);
|
|
}
|
|
else if (module_type == Wasm_Module_Bytecode) {
|
|
wasm = dynamic_cast<WasmFile *>(reader);
|
|
}
|
|
}
|
|
if (!aot) {
|
|
printf("[DumpCompare]: an aot file is required for comparison.\n");
|
|
return 1;
|
|
}
|
|
if (!wasm) {
|
|
printf("[DumpCompare]: a wasm file is required for comparison.\n");
|
|
return 1;
|
|
}
|
|
DumpCompare(aot, wasm);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
ANALYZER_TRY
|
|
return ProgramMain(argc, argv);
|
|
ANALYZER_CATCH_BAD_ALLOC_AND_EXIT
|
|
}
|