asm2wasm.cpp

/*
 * Copyright 2015 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.
 */

//
// asm2wasm console tool
//

#include <exception>

#include "ir/trapping.h"
#include "optimization-options.h"
#include "support/colors.h"
#include "support/command-line.h"
#include "support/file.h"
#include "wasm-builder.h"
#include "wasm-io.h"
#include "wasm-printing.h"
#include "wasm-validator.h"

#include "asm2wasm.h"

using namespace cashew;
using namespace wasm;

int main(int argc, const char* argv[]) {
  bool legalizeJavaScriptFFI = true;
  TrapMode trapMode = TrapMode::JS;
  bool wasmOnly = false;
  std::string sourceMapFilename;
  std::string sourceMapUrl;
  std::string symbolMap;
  bool emitBinary = true;

  OptimizationOptions options("asm2wasm",
                              "Translate asm.js files to .wast files");
  options
    .add("--output",
         "-o",
         "Output file (stdout if not specified)",
         Options::Arguments::One,
         [](Options* o, const std::string& argument) {
           o->extra["output"] = argument;
           Colors::setEnabled(false);
         })
    .add(
      "--mapped-globals",
      "-n",
      "Mapped globals",
      Options::Arguments::One,
      [](Options* o, const std::string& argument) {
        std::cerr
          << "warning: the --mapped-globals/-m option is deprecated (a mapped "
             "globals file is no longer needed as we use wasm globals)"
          << std::endl;
      })
    .add("--mem-init",
         "-t",
         "Import a memory initialization file into the output module",
         Options::Arguments::One,
         [](Options* o, const std::string& argument) {
           o->extra["mem init"] = argument;
         })
    .add("--mem-base",
         "-mb",
         "Set the location to write the memory initialization (--mem-init) "
         "file (GLOBAL_BASE in emscripten). If not provided, the __memory_base "
         "global import is used.",
         Options::Arguments::One,
         [](Options* o, const std::string& argument) {
           o->extra["mem base"] = argument;
         })
    .add("--mem-max",
         "-mm",
         "Set the maximum size of memory in the wasm module (in bytes). -1 "
         "means no limit. Without this, TOTAL_MEMORY is used (as it is used "
         "for the initial value), or if memory growth is enabled, no limit is "
         "set. This overrides both of those.",
         Options::Arguments::One,
         [](Options* o, const std::string& argument) {
           o->extra["mem max"] = argument;
         })
    .add("--total-memory",
         "-m",
         "Total memory size",
         Options::Arguments::One,
         [](Options* o, const std::string& argument) {
           o->extra["total memory"] = argument;
         })
    .add("--table-max",
         "-tM",
         "Set the maximum size of the table. Without this, it is set depending "
         "on how many functions are in the module. -1 means no limit",
         Options::Arguments::One,
         [](Options* o, const std::string& argument) {
           o->extra["table max"] = argument;
         })
    .add("--no-opts",
         "-n",
         "Disable optimization passes (deprecated)",
         Options::Arguments::Zero,
         [](Options* o, const std::string&) {
           std::cerr << "--no-opts is deprecated (use -O0, etc.)\n";
         })
    .add("--trap-mode",
         "",
         "Strategy for handling potentially trapping instructions. Valid "
         "values are \"allow\", \"js\", and \"clamp\"",
         Options::Arguments::One,
         [&trapMode](Options* o, const std::string& argument) {
           try {
             trapMode = trapModeFromString(argument);
           } catch (std::invalid_argument& e) {
             std::cerr << "Error: " << e.what() << "\n";
             exit(EXIT_FAILURE);
           }
         })
    .add("--wasm-only",
         "-w",
         "Input is in WebAssembly-only format, and not actually valid asm.js",
         Options::Arguments::Zero,
         [&wasmOnly](Options* o, const std::string&) { wasmOnly = true; })
    .add("--no-legalize-javascript-ffi",
         "-nj",
         "Do not fully legalize (i64->i32, f32->f64) the imports and exports "
         "for interfacing with JS",
         Options::Arguments::Zero,
         [&legalizeJavaScriptFFI](Options* o, const std::string&) {
           legalizeJavaScriptFFI = false;
         })
    .add("--source-map",
         "-sm",
         "Emit source map (if using binary output) to the specified file",
         Options::Arguments::One,
         [&sourceMapFilename](Options* o, const std::string& argument) {
           sourceMapFilename = argument;
         })
    .add("--source-map-url",
         "-su",
         "Use specified string as source map URL",
         Options::Arguments::One,
         [&sourceMapUrl](Options* o, const std::string& argument) {
           sourceMapUrl = argument;
         })
    .add("--symbolmap",
         "-s",
         "Emit a symbol map (indexes => names)",
         Options::Arguments::One,
         [&](Options* o, const std::string& argument) { symbolMap = argument; })
    .add("--emit-text",
         "-S",
         "Emit text instead of binary for the output file",
         Options::Arguments::Zero,
         [&](Options* o, const std::string& argument) { emitBinary = false; })
    .add_positional("INFILE",
                    Options::Arguments::One,
                    [](Options* o, const std::string& argument) {
                      o->extra["infile"] = argument;
                    });
  options.parse(argc, argv);

  // finalize arguments
  if (options.extra["output"].size() == 0) {
    // when no output file is specified, we emit text to stdout
    emitBinary = false;
  }

  if (options.runningDefaultOptimizationPasses()) {
    if (options.passes.size() > 1) {
      Fatal() << "asm2wasm can only run default optimization passes (-O, -Ox, "
                 "etc.), and not specific additional passes";
    }
  }

  const auto& tm_it = options.extra.find("total memory");
  size_t totalMemory = tm_it == options.extra.end()
                         ? 16 * 1024 * 1024
                         : atoll(tm_it->second.c_str());
  if (totalMemory & ~Memory::kPageMask) {
    std::cerr << "Error: total memory size " << totalMemory
              << " is not a multiple of the 64k wasm page size\n";
    exit(EXIT_FAILURE);
  }

  Asm2WasmPreProcessor pre;
  // wasm binaries can contain a names section, but not full debug info --
  // debug info is disabled if a map file is not specified with wasm binary
  pre.debugInfo =
    options.passOptions.debugInfo && (!emitBinary || sourceMapFilename.size());
  auto input(
    read_file<std::vector<char>>(options.extra["infile"], Flags::Text));
  char* start = pre.process(input.data());

  if (options.debug) {
    std::cerr << "parsing..." << std::endl;
  }
  cashew::Parser<Ref, DotZeroValueBuilder> builder;
  Ref asmjs = builder.parseToplevel(start);

  if (options.debug) {
    std::cerr << "wasming..." << std::endl;
  }
  Module wasm;

  // set up memory
  wasm.memory.initial = wasm.memory.max = totalMemory / Memory::kPageSize;

  // import mem init file, if provided (do this before compiling the module,
  // since the optimizer should see the memory segments)
  const auto& memInit = options.extra.find("mem init");
  if (memInit != options.extra.end()) {
    auto filename = memInit->second.c_str();
    auto data(read_file<std::vector<char>>(filename, Flags::Binary));
    // create the memory segment
    Expression* init;
    const auto& memBase = options.extra.find("mem base");
    if (memBase == options.extra.end()) {
      init = Builder(wasm).makeGlobalGet(MEMORY_BASE, Type::i32);
    } else {
      init = Builder(wasm).makeConst(
        Literal(int32_t(atoi(memBase->second.c_str()))));
    }
    wasm.memory.segments.emplace_back(init, data);
  }

  // set up the module's features, needed by optimization and validation passes
  options.applyFeatures(wasm);

  // compile the code
  Asm2WasmBuilder asm2wasm(wasm,
                           pre,
                           options.debug,
                           trapMode,
                           options.passOptions,
                           legalizeJavaScriptFFI,
                           options.runningDefaultOptimizationPasses(),
                           wasmOnly);
  asm2wasm.processAsm(asmjs);

  // Set the max memory size, if requested
  const auto& memMax = options.extra.find("mem max");
  if (memMax != options.extra.end()) {
    uint64_t max = strtoull(memMax->second.c_str(), nullptr, 10);
    if (max != uint64_t(-1)) {
      wasm.memory.max = max / Memory::kPageSize;
    } else {
      wasm.memory.max = Memory::kUnlimitedSize;
    }
  }
  // Set the table sizes, if requested
  const auto& tableMax = options.extra.find("table max");
  if (tableMax != options.extra.end()) {
    int max = atoi(tableMax->second.c_str());
    if (max >= 0) {
      wasm.table.max = max;
    } else {
      wasm.table.max = Table::kUnlimitedSize;
    }
  }

  if (options.passOptions.validate) {
    if (!WasmValidator().validate(wasm)) {
      WasmPrinter::printModule(&wasm);
      Fatal() << "error in validating output";
    }
  }

  if (options.debug) {
    std::cerr << "emitting..." << std::endl;
  }
  ModuleWriter writer;
  writer.setDebugInfo(options.passOptions.debugInfo);
  writer.setSymbolMap(symbolMap);
  writer.setBinary(emitBinary);
  if (emitBinary) {
    writer.setSourceMapFilename(sourceMapFilename);
    writer.setSourceMapUrl(sourceMapUrl);
  }
  writer.write(wasm, options.extra["output"]);

  if (options.debug) {
    std::cerr << "done." << std::endl;
  }
}