path: root/src/binary-writer-spec.cc

/*
 * 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 "binary-writer-spec.h"

#include <assert.h>
#include <inttypes.h>

#include "binary.h"
#include "binary-writer.h"
#include "config.h"
#include "ir.h"
#include "stream.h"
#include "writer.h"

namespace wabt {

static void convert_backslash_to_slash(char* s, size_t length) {
  for (size_t i = 0; i < length; ++i)
    if (s[i] == '\\')
      s[i] = '/';
}

static StringSlice 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) {
    StringSlice result;
    result.start = nullptr;
    result.length = 0;
    return result;
  }

  size_t slen = strlen(s);
  const char* ext_start = strrchr(s, '.');
  if (!ext_start)
    ext_start = s + slen;

  StringSlice 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 StringSlice 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)
    start = last_slash + 1;

  StringSlice result;
  result.start = start;
  result.length = s + slen - start;
  return result;
}

namespace {

class BinaryWriterSpec {
 public:
  BinaryWriterSpec(const char* source_filename,
                   const WriteBinarySpecOptions* spec_options);

  Result WriteScript(Script* script);

 private:
  char* GetModuleFilename();
  void WriteString(const char* s);
  void WriteKey(const char* key);
  void WriteSeparator();
  void WriteEscapedStringSlice(StringSlice ss);
  void WriteCommandType(const Command& command);
  void WriteLocation(const Location* loc);
  void WriteVar(const Var* var);
  void WriteTypeObject(Type type);
  void WriteConst(const Const* const_);
  void WriteConstVector(const ConstVector& consts);
  void WriteAction(const Action* action);
  void WriteActionResultType(Script* script, const Action* action);
  void WriteModule(char* filename, const Module* module);
  void WriteRawModule(char* filename, const RawModule* raw_module);
  void WriteInvalidModule(const RawModule* module, StringSlice text);
  void WriteCommands(Script* script);

  MemoryStream json_stream_;
  StringSlice source_filename_;
  StringSlice module_filename_noext_;
  bool write_modules_ = false; /* Whether to write the modules files. */
  const WriteBinarySpecOptions* spec_options_ = nullptr;
  Result result_ = Result::Ok;
  size_t num_modules_ = 0;
};

BinaryWriterSpec::BinaryWriterSpec(const char* source_filename,
                                   const WriteBinarySpecOptions* spec_options)
    : spec_options_(spec_options) {
  source_filename_.start = source_filename;
  source_filename_.length = strlen(source_filename);
  module_filename_noext_ = strip_extension(spec_options_->json_filename
                                               ? spec_options_->json_filename
                                               : source_filename);
  write_modules_ = !!spec_options_->json_filename;
}

char* BinaryWriterSpec::GetModuleFilename() {
  size_t buflen = module_filename_noext_.length + 20;
  char* str = new char[buflen];
  size_t length = wabt_snprintf(
      str, buflen, PRIstringslice ".%" PRIzd ".wasm",
      WABT_PRINTF_STRING_SLICE_ARG(module_filename_noext_), num_modules_);
  convert_backslash_to_slash(str, length);
  return str;
}

void BinaryWriterSpec::WriteString(const char* s) {
  json_stream_.Writef("\"%s\"", s);
}

void BinaryWriterSpec::WriteKey(const char* key) {
  json_stream_.Writef("\"%s\": ", key);
}

void BinaryWriterSpec::WriteSeparator() {
  json_stream_.Writef(", ");
}

void BinaryWriterSpec::WriteEscapedStringSlice(StringSlice ss) {
  json_stream_.WriteChar('"');
  for (size_t i = 0; i < ss.length; ++i) {
    uint8_t c = ss.start[i];
    if (c < 0x20 || c == '\\' || c == '"') {
      json_stream_.Writef("\\u%04x", c);
    } else {
      json_stream_.WriteChar(c);
    }
  }
  json_stream_.WriteChar('"');
}

void BinaryWriterSpec::WriteCommandType(const Command& command) {
  static const char* s_command_names[] = {
      "module",
      "action",
      "register",
      "assert_malformed",
      "assert_invalid",
      nullptr, /* ASSERT_INVALID_NON_BINARY, this command will never be
                  written */
      "assert_unlinkable",
      "assert_uninstantiable",
      "assert_return",
      "assert_return_canonical_nan",
      "assert_return_arithmetic_nan",
      "assert_trap",
      "assert_exhaustion",
  };
  WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_command_names) == kCommandTypeCount);

  WriteKey("type");
  assert(s_command_names[static_cast<size_t>(command.type)]);
  WriteString(s_command_names[static_cast<size_t>(command.type)]);
}

void BinaryWriterSpec::WriteLocation(const Location* loc) {
  WriteKey("line");
  json_stream_.Writef("%d", loc->line);
}

void BinaryWriterSpec::WriteVar(const Var* var) {
  if (var->type == VarType::Index)
    json_stream_.Writef("\"%" PRIu64 "\"", var->index);
  else
    WriteEscapedStringSlice(var->name);
}

void BinaryWriterSpec::WriteTypeObject(Type type) {
  json_stream_.Writef("{");
  WriteKey("type");
  WriteString(get_type_name(type));
  json_stream_.Writef("}");
}

void BinaryWriterSpec::WriteConst(const Const* const_) {
  json_stream_.Writef("{");
  WriteKey("type");

  /* Always write the values as strings, even though they may be representable
   * as JSON numbers. This way the formatting is consistent. */
  switch (const_->type) {
    case Type::I32:
      WriteString("i32");
      WriteSeparator();
      WriteKey("value");
      json_stream_.Writef("\"%u\"", const_->u32);
      break;

    case Type::I64:
      WriteString("i64");
      WriteSeparator();
      WriteKey("value");
      json_stream_.Writef("\"%" PRIu64 "\"", const_->u64);
      break;

    case Type::F32: {
      /* TODO(binji): write as hex float */
      WriteString("f32");
      WriteSeparator();
      WriteKey("value");
      json_stream_.Writef("\"%u\"", const_->f32_bits);
      break;
    }

    case Type::F64: {
      /* TODO(binji): write as hex float */
      WriteString("f64");
      WriteSeparator();
      WriteKey("value");
      json_stream_.Writef("\"%" PRIu64 "\"", const_->f64_bits);
      break;
    }

    default:
      assert(0);
  }

  json_stream_.Writef("}");
}

void BinaryWriterSpec::WriteConstVector(const ConstVector& consts) {
  json_stream_.Writef("[");
  for (size_t i = 0; i < consts.size(); ++i) {
    const Const* const_ = &consts[i];
    WriteConst(const_);
    if (i != consts.size() - 1)
      WriteSeparator();
  }
  json_stream_.Writef("]");
}

void BinaryWriterSpec::WriteAction(const Action* action) {
  WriteKey("action");
  json_stream_.Writef("{");
  WriteKey("type");
  if (action->type == ActionType::Invoke) {
    WriteString("invoke");
  } else {
    assert(action->type == ActionType::Get);
    WriteString("get");
  }
  WriteSeparator();
  if (action->module_var.type != VarType::Index) {
    WriteKey("module");
    WriteVar(&action->module_var);
    WriteSeparator();
  }
  if (action->type == ActionType::Invoke) {
    WriteKey("field");
    WriteEscapedStringSlice(action->name);
    WriteSeparator();
    WriteKey("args");
    WriteConstVector(action->invoke->args);
  } else {
    WriteKey("field");
    WriteEscapedStringSlice(action->name);
  }
  json_stream_.Writef("}");
}

void BinaryWriterSpec::WriteActionResultType(Script* script,
                                             const Action* action) {
  const Module* module = get_module_by_var(script, &action->module_var);
  const Export* export_;
  json_stream_.Writef("[");
  switch (action->type) {
    case ActionType::Invoke: {
      export_ = get_export_by_name(module, &action->name);
      assert(export_->kind == ExternalKind::Func);
      Func* func = get_func_by_var(module, &export_->var);
      size_t num_results = get_num_results(func);
      for (size_t i = 0; i < num_results; ++i)
        WriteTypeObject(get_result_type(func, i));
      break;
    }

    case ActionType::Get: {
      export_ = get_export_by_name(module, &action->name);
      assert(export_->kind == ExternalKind::Global);
      Global* global = get_global_by_var(module, &export_->var);
      WriteTypeObject(global->type);
      break;
    }
  }
  json_stream_.Writef("]");
}

void BinaryWriterSpec::WriteModule(char* filename, const Module* module) {
  MemoryStream memory_stream;
  result_ = write_binary_module(&memory_stream.writer(), module,
                                &spec_options_->write_binary_options);
  if (WABT_SUCCEEDED(result_) && write_modules_)
    result_ = memory_stream.WriteToFile(filename);
}

void BinaryWriterSpec::WriteRawModule(char* filename,
                                      const RawModule* raw_module) {
  if (raw_module->type == RawModuleType::Text) {
    WriteModule(filename, raw_module->text);
  } else if (write_modules_) {
    FileStream file_stream(filename);
    if (file_stream.is_open()) {
      file_stream.WriteData(raw_module->binary.data, raw_module->binary.size,
                            "");
      result_ = file_stream.result();
    } else {
      result_ = Result::Error;
    }
  }
}

void BinaryWriterSpec::WriteInvalidModule(const RawModule* module,
                                          StringSlice text) {
  char* filename = GetModuleFilename();
  WriteLocation(get_raw_module_location(module));
  WriteSeparator();
  WriteKey("filename");
  WriteEscapedStringSlice(get_basename(filename));
  WriteSeparator();
  WriteKey("text");
  WriteEscapedStringSlice(text);
  WriteRawModule(filename, module);
  delete [] filename;
}

void BinaryWriterSpec::WriteCommands(Script* script) {
  json_stream_.Writef("{\"source_filename\": ");
  WriteEscapedStringSlice(source_filename_);
  json_stream_.Writef(",\n \"commands\": [\n");
  int last_module_index = -1;
  for (size_t i = 0; i < script->commands.size(); ++i) {
    const Command& command = *script->commands[i].get();

    if (command.type == CommandType::AssertInvalidNonBinary)
      continue;

    if (i != 0)
      WriteSeparator();
    json_stream_.Writef("\n");

    json_stream_.Writef("  {");
    WriteCommandType(command);
    WriteSeparator();

    switch (command.type) {
      case CommandType::Module: {
        Module* module = command.module;
        char* filename = GetModuleFilename();
        WriteLocation(&module->loc);
        WriteSeparator();
        if (module->name.start) {
          WriteKey("name");
          WriteEscapedStringSlice(module->name);
          WriteSeparator();
        }
        WriteKey("filename");
        WriteEscapedStringSlice(get_basename(filename));
        WriteModule(filename, module);
        delete [] filename;
        num_modules_++;
        last_module_index = static_cast<int>(i);
        break;
      }

      case CommandType::Action:
        WriteLocation(&command.action->loc);
        WriteSeparator();
        WriteAction(command.action);
        break;

      case CommandType::Register:
        WriteLocation(&command.register_.var.loc);
        WriteSeparator();
        if (command.register_.var.type == VarType::Name) {
          WriteKey("name");
          WriteVar(&command.register_.var);
          WriteSeparator();
        } else {
          /* If we're not registering by name, then we should only be
           * registering the last module. */
          WABT_USE(last_module_index);
          assert(command.register_.var.index == last_module_index);
        }
        WriteKey("as");
        WriteEscapedStringSlice(command.register_.module_name);
        break;

      case CommandType::AssertMalformed:
        WriteInvalidModule(command.assert_malformed.module,
                           command.assert_malformed.text);
        num_modules_++;
        break;

      case CommandType::AssertInvalid:
        WriteInvalidModule(command.assert_invalid.module,
                             command.assert_invalid.text);
        num_modules_++;
        break;

      case CommandType::AssertUnlinkable:
        WriteInvalidModule(command.assert_unlinkable.module,
                           command.assert_unlinkable.text);
        num_modules_++;
        break;

      case CommandType::AssertUninstantiable:
        WriteInvalidModule(command.assert_uninstantiable.module,
                           command.assert_uninstantiable.text);
        num_modules_++;
        break;

      case CommandType::AssertReturn:
        WriteLocation(&command.assert_return.action->loc);
        WriteSeparator();
        WriteAction(command.assert_return.action);
        WriteSeparator();
        WriteKey("expected");
        WriteConstVector(*command.assert_return.expected);
        break;

      case CommandType::AssertReturnCanonicalNan:
        WriteLocation(&command.assert_return_canonical_nan.action->loc);
        WriteSeparator();
        WriteAction(command.assert_return_canonical_nan.action);
        WriteSeparator();
        WriteKey("expected");
        WriteActionResultType(script,
                              command.assert_return_canonical_nan.action);
        break;

      case CommandType::AssertReturnArithmeticNan:
        WriteLocation(&command.assert_return_arithmetic_nan.action->loc);
        WriteSeparator();
        WriteAction(command.assert_return_arithmetic_nan.action);
        WriteSeparator();
        WriteKey("expected");
        WriteActionResultType(script,
                              command.assert_return_arithmetic_nan.action);
        break;

      case CommandType::AssertTrap:
        WriteLocation(&command.assert_trap.action->loc);
        WriteSeparator();
        WriteAction(command.assert_trap.action);
        WriteSeparator();
        WriteKey("text");
        WriteEscapedStringSlice(command.assert_trap.text);
        break;

      case CommandType::AssertExhaustion:
        WriteLocation(&command.assert_trap.action->loc);
        WriteSeparator();
        WriteAction(command.assert_trap.action);
        break;

      case CommandType::AssertInvalidNonBinary:
        assert(0);
        break;
    }

    json_stream_.Writef("}");
  }
  json_stream_.Writef("]}\n");
}

Result BinaryWriterSpec::WriteScript(Script* script) {
  WriteCommands(script);
  if (spec_options_->json_filename) {
    json_stream_.WriteToFile(spec_options_->json_filename);
  }
  return result_;
}

}  // namespace

Result write_binary_spec_script(Script* script,
                                const char* source_filename,
                                const WriteBinarySpecOptions* spec_options) {
  assert(source_filename);
  BinaryWriterSpec binary_writer_spec(source_filename, spec_options);
  return binary_writer_spec.WriteScript(script);
}

}  // namespace wabt