summaryrefslogtreecommitdiff
path: root/src/wast2wasm.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/wast2wasm.c')
-rw-r--r--src/wast2wasm.c456
1 files changed, 456 insertions, 0 deletions
diff --git a/src/wast2wasm.c b/src/wast2wasm.c
new file mode 100644
index 00000000..6dc4b119
--- /dev/null
+++ b/src/wast2wasm.c
@@ -0,0 +1,456 @@
+/*
+ * Copyright 2016 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 <assert.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "wasm-config.h"
+
+#include "wasm-ast.h"
+#include "wasm-ast-checker.h"
+#include "wasm-ast-parser.h"
+#include "wasm-binary-writer.h"
+#include "wasm-binary-writer-spec.h"
+#include "wasm-common.h"
+#include "wasm-option-parser.h"
+#include "wasm-stack-allocator.h"
+#include "wasm-stream.h"
+#include "wasm-writer.h"
+
+#define PROGRAM_NAME "wast2wasm"
+
+static const char* s_infile;
+static const char* s_outfile;
+static WasmBool s_dump_module;
+static WasmBool s_verbose;
+static WasmWriteBinaryOptions s_write_binary_options =
+ WASM_WRITE_BINARY_OPTIONS_DEFAULT;
+static WasmWriteBinarySpecOptions s_write_binary_spec_options =
+ WASM_WRITE_BINARY_SPEC_OPTIONS_DEFAULT;
+static WasmBool s_spec;
+static WasmBool s_use_libc_allocator;
+static WasmBool s_check = WASM_TRUE;
+static WasmBool s_check_assert_invalid = WASM_TRUE;
+
+static WasmSourceErrorHandler s_error_handler =
+ WASM_SOURCE_ERROR_HANDLER_DEFAULT;
+static WasmSourceErrorHandler s_assert_invalid_error_handler =
+ WASM_ASSERT_INVALID_SOURCE_ERROR_HANDLER_DEFAULT;
+
+static WasmFileWriter s_log_stream_writer;
+static WasmStream s_log_stream;
+
+#define NOPE WASM_OPTION_NO_ARGUMENT
+#define YEP WASM_OPTION_HAS_ARGUMENT
+
+enum {
+ FLAG_VERBOSE,
+ FLAG_HELP,
+ FLAG_DUMP_MODULE,
+ FLAG_OUTPUT,
+ FLAG_SPEC,
+ FLAG_USE_LIBC_ALLOCATOR,
+ FLAG_NO_CANONICALIZE_LEB128S,
+ FLAG_DEBUG_NAMES,
+ FLAG_NO_CHECK,
+ FLAG_NO_CHECK_ASSERT_INVALID,
+ NUM_FLAGS
+};
+
+static const char s_description[] =
+ " read a file in the wasm s-expression format, check it for errors, and\n"
+ " convert it to the wasm binary format.\n"
+ "\n"
+ "examples:\n"
+ " # parse and typecheck test.wast\n"
+ " $ wast2wasm test.wast\n"
+ "\n"
+ " # parse test.wast and write to binary file test.wasm\n"
+ " $ wast2wasm test.wast -o test.wasm\n"
+ "\n"
+ " # parse spec-test.wast, and write verbose output to stdout (including\n"
+ " # the meaning of every byte)\n"
+ " $ wast2wasm spec-test.wast -v\n"
+ "\n"
+ " # parse spec-test.wast, and write files to spec-test.json. Modules are\n"
+ " # written to spec-test.0.wasm, spec-test.1.wasm, etc.\n"
+ " $ wast2wasm spec-test.wast --spec -o spec-test.json\n";
+
+static WasmOption s_options[] = {
+ {FLAG_VERBOSE, 'v', "verbose", NULL, NOPE,
+ "use multiple times for more info"},
+ {FLAG_HELP, 'h', "help", NULL, NOPE, "print this help message"},
+ {FLAG_DUMP_MODULE, 'd', "dump-module", NULL, NOPE,
+ "print a hexdump of the module to stdout"},
+ {FLAG_OUTPUT, 'o', "output", "FILE", YEP,
+ "output file for the generated binary format"},
+ {FLAG_SPEC, 0, "spec", NULL, NOPE,
+ "parse a file with multiple modules and assertions, like the spec "
+ "tests"},
+ {FLAG_USE_LIBC_ALLOCATOR, 0, "use-libc-allocator", NULL, NOPE,
+ "use malloc, free, etc. instead of stack allocator"},
+ {FLAG_NO_CANONICALIZE_LEB128S, 0, "no-canonicalize-leb128s", NULL, NOPE,
+ "Write all LEB128 sizes as 5-bytes instead of their minimal size"},
+ {FLAG_DEBUG_NAMES, 0, "debug-names", NULL, NOPE,
+ "Write debug names to the generated binary file"},
+ {FLAG_NO_CHECK, 0, "no-check", NULL, NOPE,
+ "Don't check for invalid modules"},
+ {FLAG_NO_CHECK_ASSERT_INVALID, 0, "no-check-assert-invalid", NULL, NOPE,
+ "Don't run the assert_invalid checks"},
+};
+WASM_STATIC_ASSERT(NUM_FLAGS == WASM_ARRAY_SIZE(s_options));
+
+static void on_option(struct WasmOptionParser* parser,
+ struct WasmOption* option,
+ const char* argument) {
+ switch (option->id) {
+ case FLAG_VERBOSE:
+ s_verbose++;
+ wasm_init_file_writer_existing(&s_log_stream_writer, stdout);
+ wasm_init_stream(&s_log_stream, &s_log_stream_writer.base, NULL);
+ s_write_binary_options.log_stream = &s_log_stream;
+ break;
+
+ case FLAG_HELP:
+ wasm_print_help(parser, PROGRAM_NAME);
+ exit(0);
+ break;
+
+ case FLAG_DUMP_MODULE:
+ s_dump_module = WASM_TRUE;
+ break;
+
+ case FLAG_OUTPUT:
+ s_outfile = argument;
+ break;
+
+ case FLAG_SPEC:
+ s_spec = WASM_TRUE;
+ break;
+
+ case FLAG_USE_LIBC_ALLOCATOR:
+ s_use_libc_allocator = WASM_TRUE;
+ break;
+
+ case FLAG_NO_CANONICALIZE_LEB128S:
+ s_write_binary_options.canonicalize_lebs = WASM_FALSE;
+ break;
+
+ case FLAG_DEBUG_NAMES:
+ s_write_binary_options.write_debug_names = WASM_TRUE;
+ break;
+
+ case FLAG_NO_CHECK:
+ s_check = WASM_FALSE;
+ break;
+
+ case FLAG_NO_CHECK_ASSERT_INVALID:
+ s_check_assert_invalid = WASM_FALSE;
+ break;
+ }
+}
+
+static void on_argument(struct WasmOptionParser* parser, const char* argument) {
+ s_infile = argument;
+}
+
+static void on_option_error(struct WasmOptionParser* parser,
+ const char* message) {
+ WASM_FATAL("%s\n", message);
+}
+
+static void parse_options(int argc, char** argv) {
+ WasmOptionParser parser;
+ WASM_ZERO_MEMORY(parser);
+ parser.description = s_description;
+ parser.options = s_options;
+ parser.num_options = WASM_ARRAY_SIZE(s_options);
+ parser.on_option = on_option;
+ parser.on_argument = on_argument;
+ parser.on_error = on_option_error;
+ wasm_parse_options(&parser, argc, argv);
+
+ if (!s_infile) {
+ wasm_print_help(&parser, PROGRAM_NAME);
+ WASM_FATAL("No filename given.\n");
+ }
+}
+
+static void write_buffer_to_file(const char* filename,
+ WasmOutputBuffer* buffer) {
+ if (s_dump_module) {
+ if (s_verbose)
+ wasm_writef(&s_log_stream, ";; dump\n");
+ wasm_write_output_buffer_memory_dump(&s_log_stream, buffer);
+ }
+
+ if (filename) {
+ wasm_write_output_buffer_to_file(buffer, filename);
+ }
+}
+
+static WasmStringSlice strip_extension(const char* s) {
+ /* strip .json or .wasm, but leave other extensions, e.g.:
+ *
+ * s = "foo", => "foo"
+ * s = "foo.json" => "foo"
+ * s = "foo.wasm" => "foo"
+ * s = "foo.bar" => "foo.bar"
+ */
+ if (s == NULL) {
+ WasmStringSlice result;
+ result.start = NULL;
+ result.length = 0;
+ return result;
+ }
+
+ size_t slen = strlen(s);
+ const char* ext_start = strrchr(s, '.');
+ if (ext_start == NULL)
+ ext_start = s + slen;
+
+ WasmStringSlice result;
+ result.start = s;
+
+ if (strcmp(ext_start, ".json") == 0 || strcmp(ext_start, ".wasm") == 0) {
+ result.length = ext_start - s;
+ } else {
+ result.length = slen;
+ }
+ return result;
+}
+
+static WasmStringSlice get_basename(const char* s) {
+ /* strip everything up to and including the last slash, e.g.:
+ *
+ * s = "/foo/bar/baz", => "baz"
+ * s = "/usr/local/include/stdio.h", => "stdio.h"
+ * s = "foo.bar", => "foo.bar"
+ */
+ size_t slen = strlen(s);
+ const char* start = s;
+ const char* last_slash = strrchr(s, '/');
+ if (last_slash != NULL)
+ start = last_slash + 1;
+
+ WasmStringSlice result;
+ result.start = start;
+ result.length = s + slen - start;
+ return result;
+}
+
+static char* get_module_filename(WasmAllocator* allocator,
+ WasmStringSlice* filename_noext,
+ uint32_t index) {
+ size_t buflen = filename_noext->length + 20;
+ char* str = wasm_alloc(allocator, buflen, WASM_DEFAULT_ALIGN);
+ wasm_snprintf(str, buflen, PRIstringslice ".%d.wasm",
+ WASM_PRINTF_STRING_SLICE_ARG(*filename_noext), index);
+ return str;
+}
+
+static char* convert_backslash_to_forward_slash(char* buffer, const int buf_size) {
+ int i = 0;
+ for (; i < buf_size; ++i) {
+ if (buffer[i] == '\\') {
+ buffer[i] = '/';
+ }
+ }
+ return buffer;
+}
+
+typedef struct Context {
+ WasmAllocator* allocator;
+ WasmMemoryWriter json_writer;
+ WasmMemoryWriter module_writer;
+ WasmStream json_stream;
+ WasmStringSlice output_filename_noext;
+ char* module_filename;
+ WasmResult result;
+} Context;
+
+static void on_script_begin(void* user_data) {
+ Context* ctx = user_data;
+ if (WASM_FAILED(wasm_init_mem_writer(ctx->allocator, &ctx->module_writer)))
+ WASM_FATAL("unable to open memory writer for writing\n");
+
+ if (WASM_FAILED(wasm_init_mem_writer(ctx->allocator, &ctx->json_writer)))
+ WASM_FATAL("unable to open memory writer for writing\n");
+ wasm_init_stream(&ctx->json_stream, &ctx->json_writer.base, NULL);
+
+ wasm_writef(&ctx->json_stream, "{\"modules\": [\n");
+}
+
+static void on_module_begin(uint32_t index, void* user_data) {
+ Context* ctx = user_data;
+ wasm_free(ctx->allocator, ctx->module_filename);
+ ctx->module_filename =
+ get_module_filename(ctx->allocator, &ctx->output_filename_noext, index);
+ if (index != 0)
+ wasm_writef(&ctx->json_stream, ",\n");
+ ctx->module_filename =
+ convert_backslash_to_forward_slash(ctx->module_filename,
+ strlen(ctx->module_filename));
+
+ WasmStringSlice module_basename = get_basename(ctx->module_filename);
+ wasm_writef(&ctx->json_stream,
+ " {\"filename\": \"" PRIstringslice "\", \"commands\": [\n",
+ WASM_PRINTF_STRING_SLICE_ARG(module_basename));
+}
+
+static void on_command(uint32_t index,
+ WasmCommandType type,
+ const WasmStringSlice* name,
+ const WasmLocation* loc,
+ void* user_data) {
+ static const char* s_command_names[] = {
+ "module",
+ "invoke",
+ "assert_invalid",
+ "assert_return",
+ "assert_return_nan",
+ "assert_trap",
+ };
+ WASM_STATIC_ASSERT(WASM_ARRAY_SIZE(s_command_names) ==
+ WASM_NUM_COMMAND_TYPES);
+
+ static const char* s_command_format =
+ " {"
+ "\"type\": \"%s\", "
+ "\"name\": \"" PRIstringslice
+ "\", "
+ "\"file\": \"%s\", "
+ "\"line\": %d}";
+
+ Context* ctx = user_data;
+ if (index != 0)
+ wasm_writef(&ctx->json_stream, ",\n");
+ const int l = strlen(loc->filename);
+ char* filename = wasm_alloc(ctx->allocator, l + 1, WASM_DEFAULT_ALIGN);
+ memcpy(filename, loc->filename, l + 1);
+ filename = convert_backslash_to_forward_slash(filename, l);
+ wasm_writef(&ctx->json_stream, s_command_format, s_command_names[type],
+ WASM_PRINTF_STRING_SLICE_ARG(*name), filename, loc->line);
+ wasm_free(ctx->allocator, filename);
+}
+
+static void on_module_before_write(uint32_t index,
+ WasmWriter** out_writer,
+ void* user_data) {
+ Context* ctx = user_data;
+ ctx->module_writer.buf.size = 0;
+ *out_writer = &ctx->module_writer.base;
+}
+
+static void on_module_end(uint32_t index, WasmResult result, void* user_data) {
+ Context* ctx = user_data;
+ wasm_writef(&ctx->json_stream, "\n ]}");
+ if (WASM_SUCCEEDED(result))
+ write_buffer_to_file(ctx->module_filename, &ctx->module_writer.buf);
+}
+
+static void on_script_end(void* user_data) {
+ Context* ctx = user_data;
+ wasm_writef(&ctx->json_stream, "\n]}\n");
+
+ if (WASM_SUCCEEDED(ctx->result))
+ write_buffer_to_file(s_outfile, &ctx->json_writer.buf);
+
+ wasm_free(ctx->allocator, ctx->module_filename);
+ wasm_close_mem_writer(&ctx->module_writer);
+ wasm_close_mem_writer(&ctx->json_writer);
+}
+
+int main(int argc, char** argv) {
+ WasmStackAllocator stack_allocator;
+ WasmAllocator* allocator;
+
+ wasm_init_stdio();
+ parse_options(argc, argv);
+
+ if (s_use_libc_allocator) {
+ allocator = &g_wasm_libc_allocator;
+ } else {
+ wasm_init_stack_allocator(&stack_allocator, &g_wasm_libc_allocator);
+ allocator = &stack_allocator.allocator;
+ }
+
+ WasmAstLexer* lexer = wasm_new_ast_file_lexer(allocator, s_infile);
+ if (!lexer)
+ WASM_FATAL("unable to read %s\n", s_infile);
+
+ WasmScript script;
+ WasmResult result = wasm_parse_ast(lexer, &script, &s_error_handler);
+
+ if (WASM_SUCCEEDED(result)) {
+ if (s_check) {
+ /* full validation of the module */
+ result = wasm_check_ast(lexer, &script, &s_error_handler);
+ } else {
+ /* minimal checks necessary to ensure we can generate a binary */
+ result = wasm_check_names(lexer, &script, &s_error_handler);
+ }
+
+ if (WASM_SUCCEEDED(result) && s_check_assert_invalid) {
+ result = wasm_check_assert_invalid(allocator, lexer, &script,
+ &s_assert_invalid_error_handler,
+ &s_error_handler);
+ }
+
+ if (WASM_SUCCEEDED(result)) {
+ if (s_spec) {
+ Context ctx;
+ WASM_ZERO_MEMORY(ctx);
+ ctx.allocator = allocator;
+ ctx.output_filename_noext = strip_extension(s_outfile);
+
+ s_write_binary_spec_options.on_script_begin = &on_script_begin;
+ s_write_binary_spec_options.on_module_begin = &on_module_begin;
+ s_write_binary_spec_options.on_command = &on_command,
+ s_write_binary_spec_options.on_module_before_write =
+ &on_module_before_write;
+ s_write_binary_spec_options.on_module_end = &on_module_end;
+ s_write_binary_spec_options.on_script_end = &on_script_end;
+ s_write_binary_spec_options.user_data = &ctx;
+
+ result = wasm_write_binary_spec_script(allocator, &script,
+ &s_write_binary_options,
+ &s_write_binary_spec_options);
+ } else {
+ WasmMemoryWriter writer;
+ WASM_ZERO_MEMORY(writer);
+ if (WASM_FAILED(wasm_init_mem_writer(allocator, &writer)))
+ WASM_FATAL("unable to open memory writer for writing\n");
+
+ result = wasm_write_binary_script(allocator, &writer.base, &script,
+ &s_write_binary_options);
+ if (WASM_SUCCEEDED(result))
+ write_buffer_to_file(s_outfile, &writer.buf);
+ wasm_close_mem_writer(&writer);
+ }
+ }
+ }
+
+ wasm_destroy_ast_lexer(lexer);
+
+ if (s_use_libc_allocator)
+ wasm_destroy_script(&script);
+ wasm_print_allocator_stats(allocator);
+ wasm_destroy_allocator(allocator);
+ return result;
+}