// Copyright 2015 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "src/macro-assembler.h" #include "src/objects.h" #include "src/v8.h" #include "src/simulator.h" #include "src/wasm/ast-decoder.h" #include "src/wasm/module-decoder.h" #include "src/wasm/wasm-module.h" #include "src/wasm/wasm-result.h" #include "src/compiler/wasm-compiler.h" namespace v8 { namespace internal { namespace wasm { std::ostream& operator<<(std::ostream& os, const WasmModule& module) { os << "WASM module with "; os << (1 << module.min_mem_size_log2) << " min mem"; os << (1 << module.max_mem_size_log2) << " max mem"; if (module.functions) os << module.functions->size() << " functions"; if (module.globals) os << module.functions->size() << " globals"; if (module.data_segments) os << module.functions->size() << " data segments"; return os; } std::ostream& operator<<(std::ostream& os, const WasmFunction& function) { os << "WASM function with signature " << *function.sig; os << " locals: "; if (function.local_i32_count) os << function.local_i32_count << " i32s "; if (function.local_i64_count) os << function.local_i64_count << " i64s "; if (function.local_f32_count) os << function.local_f32_count << " f32s "; if (function.local_f64_count) os << function.local_f64_count << " f64s "; os << " code bytes: " << (function.code_end_offset - function.code_start_offset); return os; } std::ostream& operator<<(std::ostream& os, const WasmFunctionName& pair) { os << "#" << pair.function_->func_index << ":"; if (pair.function_->name_offset > 0) { if (pair.module_) { os << pair.module_->GetName(pair.function_->name_offset); } else { os << "+" << pair.function_->func_index; } } else { os << "?"; } return os; } // A helper class for compiling multiple wasm functions that offers // placeholder code objects for calling functions that are not yet compiled. class WasmLinker { public: WasmLinker(Isolate* isolate, size_t size) : isolate_(isolate), placeholder_code_(size), function_code_(size) {} // Get the code object for a function, allocating a placeholder if it has // not yet been compiled. Handle

 GetFunctionCode(uint32_t index) {
    DCHECK(index < function_code_.size());
    if (function_code_[index].is_null()) {
      // Create a placeholder code object and encode the corresponding index in
      // the {constant_pool_offset} field of the code object.
      // TODO(titzer): placeholder code objects are somewhat dangerous.
      Handle self(nullptr, isolate_);
      byte buffer[] = {0, 0, 0, 0, 0, 0, 0, 0};  // fake instructions.
      CodeDesc desc = {buffer, 8, 8, 0, 0, nullptr};
      Handle code = isolate_->factory()->NewCode(
          desc, Code::KindField::encode(Code::WASM_FUNCTION), self);
      code->set_constant_pool_offset(index + kPlaceholderMarker);
      placeholder_code_[index] = code;
      function_code_[index] = code;
    }
    return function_code_[index];
  }

  void Finish(uint32_t index, Handle code) {
    DCHECK(index < function_code_.size());
    function_code_[index] = code;
  }

  void Link(Handle function_table,
            std::vector* functions) {
    for (size_t i = 0; i < function_code_.size(); i++) {
      LinkFunction(function_code_[i]);
    }
    if (functions && !function_table.is_null()) {
      int table_size = static_cast(functions->size());
      DCHECK_EQ(function_table->length(), table_size * 2);
      for (int i = 0; i < table_size; i++) {
        function_table->set(i + table_size, *function_code_[functions->at(i)]);
      }
    }
  }

 private:
  static const int kPlaceholderMarker = 1000000000;

  Isolate* isolate_;
  std::vector> placeholder_code_;
  std::vector> function_code_;

  void LinkFunction(Handle code) {
    bool modified = false;
    int mode_mask = RelocInfo::kCodeTargetMask;
    AllowDeferredHandleDereference embedding_raw_address;
    for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
      RelocInfo::Mode mode = it.rinfo()->rmode();
      if (RelocInfo::IsCodeTarget(mode)) {
        Code* target =
            Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
        if (target->kind() == Code::WASM_FUNCTION &&
            target->constant_pool_offset() >= kPlaceholderMarker) {
          // Patch direct calls to placeholder code objects.
          uint32_t index = target->constant_pool_offset() - kPlaceholderMarker;
          CHECK(index < function_code_.size());
          Handle new_target = function_code_[index];
          if (target != *new_target) {
            CHECK_EQ(*placeholder_code_[index], target);
            it.rinfo()->set_target_address(new_target->instruction_start(),
                                           SKIP_WRITE_BARRIER,
                                           SKIP_ICACHE_FLUSH);
            modified = true;
          }
        }
      }
    }
    if (modified) {
      Assembler::FlushICache(isolate_, code->instruction_start(),
                             code->instruction_size());
    }
  }
};

namespace {
// Internal constants for the layout of the module object.
const int kWasmModuleInternalFieldCount = 4;
const int kWasmModuleFunctionTable = 0;
const int kWasmModuleCodeTable = 1;
const int kWasmMemArrayBuffer = 2;
const int kWasmGlobalsArrayBuffer = 3;


size_t AllocateGlobalsOffsets(std::vector* globals) {
  uint32_t offset = 0;
  if (!globals) return 0;
  for (WasmGlobal& global : *globals) {
    byte size = WasmOpcodes::MemSize(global.type);
    offset = (offset + size - 1) & ~(size - 1);  // align
    global.offset = offset;
    offset += size;
  }
  return offset;
}


void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
  for (const WasmDataSegment& segment : *module->data_segments) {
    if (!segment.init) continue;
    CHECK_LT(segment.dest_addr, mem_size);
    CHECK_LE(segment.source_size, mem_size);
    CHECK_LE(segment.dest_addr + segment.source_size, mem_size);
    byte* addr = mem_addr + segment.dest_addr;
    memcpy(addr, module->module_start + segment.source_offset,
           segment.source_size);
  }
}


Handle BuildFunctionTable(Isolate* isolate, WasmModule* module) {
  if (!module->function_table || module->function_table->size() == 0) {
    return Handle::null();
  }
  int table_size = static_cast(module->function_table->size());
  Handle fixed = isolate->factory()->NewFixedArray(2 * table_size);
  for (int i = 0; i < table_size; i++) {
    WasmFunction* function =
        &module->functions->at(module->function_table->at(i));
    fixed->set(i, Smi::FromInt(function->sig_index));
  }
  return fixed;
}

Handle NewArrayBuffer(Isolate* isolate, size_t size,
                                     byte** backing_store) {
  if (size > (1 << WasmModule::kMaxMemSize)) {
    // TODO(titzer): lift restriction on maximum memory allocated here.
    *backing_store = nullptr;
    return Handle::null();
  }
  void* memory =
      isolate->array_buffer_allocator()->Allocate(static_cast(size));
  if (!memory) {
    *backing_store = nullptr;
    return Handle::null();
  }

  *backing_store = reinterpret_cast(memory);

#if DEBUG
  // Double check the API allocator actually zero-initialized the memory.
  byte* bytes = reinterpret_cast(*backing_store);
  for (size_t i = 0; i < size; i++) {
    DCHECK_EQ(0, bytes[i]);
  }
#endif

  Handle buffer = isolate->factory()->NewJSArrayBuffer();
  JSArrayBuffer::Setup(buffer, isolate, false, memory, static_cast(size));
  buffer->set_is_neuterable(false);
  return buffer;
}

// Set the memory for a module instance to be the {memory} array buffer.
void SetMemory(WasmModuleInstance* instance, Handle memory) {
  memory->set_is_neuterable(false);
  instance->mem_start = reinterpret_cast(memory->backing_store());
  instance->mem_size = memory->byte_length()->Number();
  instance->mem_buffer = memory;
}

// Allocate memory for a module instance as a new JSArrayBuffer.
bool AllocateMemory(ErrorThrower* thrower, Isolate* isolate,
                    WasmModuleInstance* instance) {
  DCHECK(instance->module);
  DCHECK(instance->mem_buffer.is_null());

  if (instance->module->min_mem_size_log2 > WasmModule::kMaxMemSize) {
    thrower->Error("Out of memory: wasm memory too large");
    return false;
  }
  instance->mem_size = static_cast(1)
                       << instance->module->min_mem_size_log2;
  instance->mem_buffer =
      NewArrayBuffer(isolate, instance->mem_size, &instance->mem_start);
  if (!instance->mem_start) {
    thrower->Error("Out of memory: wasm memory");
    instance->mem_size = 0;
    return false;
  }
  return true;
}

bool AllocateGlobals(ErrorThrower* thrower, Isolate* isolate,
                     WasmModuleInstance* instance) {
  instance->globals_size = AllocateGlobalsOffsets(instance->module->globals);

  if (instance->globals_size > 0) {
    instance->globals_buffer = NewArrayBuffer(isolate, instance->globals_size,
                                              &instance->globals_start);
    if (!instance->globals_start) {
      // Not enough space for backing store of globals.
      thrower->Error("Out of memory: wasm globals");
      return false;
    }
  }
  return true;
}
}  // namespace

WasmModule::WasmModule()
    : shared_isolate(nullptr),
      module_start(nullptr),
      module_end(nullptr),
      min_mem_size_log2(0),
      max_mem_size_log2(0),
      mem_export(false),
      mem_external(false),
      start_function_index(-1),
      globals(nullptr),
      signatures(nullptr),
      functions(nullptr),
      data_segments(nullptr),
      function_table(nullptr),
      import_table(nullptr) {}

WasmModule::~WasmModule() {
  if (globals) delete globals;
  if (signatures) delete signatures;
  if (functions) delete functions;
  if (data_segments) delete data_segments;
  if (function_table) delete function_table;
  if (import_table) delete import_table;
}

static MaybeHandle LookupFunction(ErrorThrower& thrower,
                                              Handle ffi,
                                              uint32_t index,
                                              Handle name,
                                              const char* cstr) {
  if (!ffi.is_null()) {
    MaybeHandle