src/binary-reader-linker.cc - external/github.com/WebAssembly/wabt - Git at Google

 /*
  * Copyright 2017 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-reader-linker.h"

 #include <vector>

 #include "binary-reader-nop.h"
 #include "wasm-link.h"

 #define RELOC_SIZE 5

 namespace wabt {
 namespace link {

 namespace {

 class BinaryReaderLinker : public BinaryReaderNop {
  public:
   explicit BinaryReaderLinker(LinkerInputBinary* binary);

   virtual Result BeginSection(BinarySection section_type, uint32_t size);

   virtual Result OnImport(uint32_t index,
                           StringSlice module_name,
                           StringSlice field_name);
   virtual Result OnImportFunc(uint32_t import_index,
                               StringSlice module_name,
                               StringSlice field_name,
                               uint32_t func_index,
                               uint32_t sig_index);
   virtual Result OnImportGlobal(uint32_t import_index,
                                 StringSlice module_name,
                                 StringSlice field_name,
                                 uint32_t global_index,
                                 Type type,
                                 bool mutable_);

   virtual Result OnFunctionCount(uint32_t count);

   virtual Result OnTable(uint32_t index,
                          Type elem_type,
                          const Limits* elem_limits);

   virtual Result OnMemory(uint32_t index, const Limits* limits);

   virtual Result OnExport(uint32_t index,
                           ExternalKind kind,
                           uint32_t item_index,
                           StringSlice name);

   virtual Result OnElemSegmentFunctionIndexCount(uint32_t index,
                                                  uint32_t count);

   virtual Result BeginDataSegment(uint32_t index, uint32_t memory_index);
   virtual Result OnDataSegmentData(uint32_t index,
                                    const void* data,
                                    uint32_t size);

   virtual Result BeginNamesSection(uint32_t size);

   virtual Result OnFunctionName(uint32_t function_index,
                                 StringSlice function_name);

   virtual Result OnRelocCount(uint32_t count,
                               BinarySection section_code,
                               StringSlice section_name);
   virtual Result OnReloc(RelocType type,
                          uint32_t offset,
                          uint32_t index,
                          uint32_t addend);

   virtual Result OnInitExprI32ConstExpr(uint32_t index, uint32_t value);

  private:
   LinkerInputBinary* binary;

   Section* reloc_section = nullptr;
   Section* current_section = nullptr;
   uint32_t function_count = 0;
 };

 BinaryReaderLinker::BinaryReaderLinker(LinkerInputBinary* binary)
     : binary(binary) {}

 Result BinaryReaderLinker::OnRelocCount(uint32_t count,
                                         BinarySection section_code,
                                         StringSlice section_name) {
   if (section_code == BinarySection::Custom) {
     WABT_FATAL("relocation for custom sections not yet supported\n");
   }

   for (const std::unique_ptr<Section>& section : binary->sections) {
     if (section->section_code != section_code)
       continue;
     reloc_section = section.get();
     return Result::Ok;
   }

   WABT_FATAL("section not found: %d\n", static_cast<int>(section_code));
   return Result::Error;
 }

 Result BinaryReaderLinker::OnReloc(RelocType type,
                                    uint32_t offset,
                                    uint32_t index,
                                    uint32_t addend) {
   if (offset + RELOC_SIZE > reloc_section->size) {
     WABT_FATAL("invalid relocation offset: %#x\n", offset);
   }

   reloc_section->relocations.emplace_back(type, offset, index, addend);

   return Result::Ok;
 }

 Result BinaryReaderLinker::OnImport(uint32_t index,
                                     StringSlice module_name,
                                     StringSlice field_name) {
   if (!string_slice_eq_cstr(&module_name, WABT_LINK_MODULE_NAME)) {
     WABT_FATAL("unsupported import module: " PRIstringslice,
                WABT_PRINTF_STRING_SLICE_ARG(module_name));
   }
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnImportFunc(uint32_t import_index,
                                         StringSlice module_name,
                                         StringSlice field_name,
                                         uint32_t global_index,
                                         uint32_t sig_index) {
   binary->function_imports.emplace_back();
   FunctionImport* import = &binary->function_imports.back();
   import->name = field_name;
   import->sig_index = sig_index;
   import->active = true;
   binary->active_function_imports++;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnImportGlobal(uint32_t import_index,
                                           StringSlice module_name,
                                           StringSlice field_name,
                                           uint32_t global_index,
                                           Type type,
                                           bool mutable_) {
   binary->global_imports.emplace_back();
   GlobalImport* import = &binary->global_imports.back();
   import->name = field_name;
   import->type = type;
   import->mutable_ = mutable_;
   binary->active_global_imports++;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnFunctionCount(uint32_t count) {
   function_count = count;
   return Result::Ok;
 }

 Result BinaryReaderLinker::BeginSection(BinarySection section_code,
                                         uint32_t size) {
   Section* sec = new Section();
   binary->sections.emplace_back(sec);
   current_section = sec;
   sec->section_code = section_code;
   sec->size = size;
   sec->offset = state->offset;
   sec->binary = binary;

   if (sec->section_code != BinarySection::Custom &&
       sec->section_code != BinarySection::Start) {
     size_t bytes_read = read_u32_leb128(
         &binary->data[sec->offset], &binary->data[binary->size], &sec->count);
     if (bytes_read == 0)
       WABT_FATAL("error reading section element count\n");
     sec->payload_offset = sec->offset + bytes_read;
     sec->payload_size = sec->size - bytes_read;
   }
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnTable(uint32_t index,
                                    Type elem_type,
                                    const Limits* elem_limits) {
   if (elem_limits->has_max && (elem_limits->max != elem_limits->initial))
     WABT_FATAL("Tables with max != initial not supported by wabt-link\n");

   binary->table_elem_count = elem_limits->initial;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnElemSegmentFunctionIndexCount(uint32_t index,
                                                            uint32_t count) {
   Section* sec = current_section;

   /* Modify the payload to include only the actual function indexes */
   size_t delta = state->offset - sec->payload_offset;
   sec->payload_offset += delta;
   sec->payload_size -= delta;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnMemory(uint32_t index, const Limits* page_limits) {
   Section* sec = current_section;
   sec->data.memory_limits = *page_limits;
   binary->memory_page_count = page_limits->initial;
   return Result::Ok;
 }

 Result BinaryReaderLinker::BeginDataSegment(uint32_t index,
                                             uint32_t memory_index) {
   Section* sec = current_section;
   if (!sec->data.data_segments) {
     sec->data.data_segments = new std::vector<DataSegment>();
   }
   sec->data.data_segments->emplace_back();
   DataSegment& segment = sec->data.data_segments->back();
   segment.memory_index = memory_index;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnInitExprI32ConstExpr(uint32_t index,
                                                   uint32_t value) {
   Section* sec = current_section;
   if (sec->section_code != BinarySection::Data)
     return Result::Ok;
   DataSegment& segment = sec->data.data_segments->back();
   segment.offset = value;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnDataSegmentData(uint32_t index,
                                              const void* src_data,
                                              uint32_t size) {
   Section* sec = current_section;
   DataSegment& segment = sec->data.data_segments->back();
   segment.data = static_cast<const uint8_t*>(src_data);
   segment.size = size;
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnExport(uint32_t index,
                                     ExternalKind kind,
                                     uint32_t item_index,
                                     StringSlice name) {
   binary->exports.emplace_back();
   Export* export_ = &binary->exports.back();
   export_->name = name;
   export_->kind = kind;
   export_->index = item_index;
   return Result::Ok;
 }

 Result BinaryReaderLinker::BeginNamesSection(uint32_t size) {
   binary->debug_names.resize(function_count + binary->function_imports.size());
   return Result::Ok;
 }

 Result BinaryReaderLinker::OnFunctionName(uint32_t index, StringSlice name) {
   binary->debug_names[index] = string_slice_to_string(name);
   return Result::Ok;
 }

 }  // namespace

 Result read_binary_linker(LinkerInputBinary* input_info, LinkOptions* options) {
   BinaryReaderLinker reader(input_info);

   ReadBinaryOptions read_options = WABT_READ_BINARY_OPTIONS_DEFAULT;
   read_options.read_debug_names = true;
   read_options.log_stream = options->log_stream;
   return read_binary(input_info->data, input_info->size, &reader,
                      &read_options);
 }

 }  // namespace link
 }  // namespace wabt
	/*
	* Copyright 2017 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-reader-linker.h"

	#include <vector>

	#include "binary-reader-nop.h"
	#include "wasm-link.h"

	#define RELOC_SIZE 5

	namespace wabt {
	namespace link {

	namespace {

	class BinaryReaderLinker : public BinaryReaderNop {
	public:
	explicit BinaryReaderLinker(LinkerInputBinary* binary);

	virtual Result BeginSection(BinarySection section_type, uint32_t size);

	virtual Result OnImport(uint32_t index,
	StringSlice module_name,
	StringSlice field_name);
	virtual Result OnImportFunc(uint32_t import_index,
	StringSlice module_name,
	StringSlice field_name,
	uint32_t func_index,
	uint32_t sig_index);
	virtual Result OnImportGlobal(uint32_t import_index,
	StringSlice module_name,
	StringSlice field_name,
	uint32_t global_index,
	Type type,
	bool mutable_);

	virtual Result OnFunctionCount(uint32_t count);

	virtual Result OnTable(uint32_t index,
	Type elem_type,
	const Limits* elem_limits);

	virtual Result OnMemory(uint32_t index, const Limits* limits);

	virtual Result OnExport(uint32_t index,
	ExternalKind kind,
	uint32_t item_index,
	StringSlice name);

	virtual Result OnElemSegmentFunctionIndexCount(uint32_t index,
	uint32_t count);

	virtual Result BeginDataSegment(uint32_t index, uint32_t memory_index);
	virtual Result OnDataSegmentData(uint32_t index,
	const void* data,
	uint32_t size);

	virtual Result BeginNamesSection(uint32_t size);

	virtual Result OnFunctionName(uint32_t function_index,
	StringSlice function_name);

	virtual Result OnRelocCount(uint32_t count,
	BinarySection section_code,
	StringSlice section_name);
	virtual Result OnReloc(RelocType type,
	uint32_t offset,
	uint32_t index,
	uint32_t addend);

	virtual Result OnInitExprI32ConstExpr(uint32_t index, uint32_t value);

	private:
	LinkerInputBinary* binary;

	Section* reloc_section = nullptr;
	Section* current_section = nullptr;
	uint32_t function_count = 0;
	};

	BinaryReaderLinker::BinaryReaderLinker(LinkerInputBinary* binary)
	: binary(binary) {}

	Result BinaryReaderLinker::OnRelocCount(uint32_t count,
	BinarySection section_code,
	StringSlice section_name) {
	if (section_code == BinarySection::Custom) {
	WABT_FATAL("relocation for custom sections not yet supported\n");
	}

	for (const std::unique_ptr<Section>& section : binary->sections) {
	if (section->section_code != section_code)
	continue;
	reloc_section = section.get();
	return Result::Ok;
	}

	WABT_FATAL("section not found: %d\n", static_cast<int>(section_code));
	return Result::Error;
	}

	Result BinaryReaderLinker::OnReloc(RelocType type,
	uint32_t offset,
	uint32_t index,
	uint32_t addend) {
	if (offset + RELOC_SIZE > reloc_section->size) {
	WABT_FATAL("invalid relocation offset: %#x\n", offset);
	}

	reloc_section->relocations.emplace_back(type, offset, index, addend);

	return Result::Ok;
	}

	Result BinaryReaderLinker::OnImport(uint32_t index,
	StringSlice module_name,
	StringSlice field_name) {
	if (!string_slice_eq_cstr(&module_name, WABT_LINK_MODULE_NAME)) {
	WABT_FATAL("unsupported import module: " PRIstringslice,
	WABT_PRINTF_STRING_SLICE_ARG(module_name));
	}
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnImportFunc(uint32_t import_index,
	StringSlice module_name,
	StringSlice field_name,
	uint32_t global_index,
	uint32_t sig_index) {
	binary->function_imports.emplace_back();
	FunctionImport* import = &binary->function_imports.back();
	import->name = field_name;
	import->sig_index = sig_index;
	import->active = true;
	binary->active_function_imports++;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnImportGlobal(uint32_t import_index,
	StringSlice module_name,
	StringSlice field_name,
	uint32_t global_index,
	Type type,
	bool mutable_) {
	binary->global_imports.emplace_back();
	GlobalImport* import = &binary->global_imports.back();
	import->name = field_name;
	import->type = type;
	import->mutable_ = mutable_;
	binary->active_global_imports++;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnFunctionCount(uint32_t count) {
	function_count = count;
	return Result::Ok;
	}

	Result BinaryReaderLinker::BeginSection(BinarySection section_code,
	uint32_t size) {
	Section* sec = new Section();
	binary->sections.emplace_back(sec);
	current_section = sec;
	sec->section_code = section_code;
	sec->size = size;
	sec->offset = state->offset;
	sec->binary = binary;

	if (sec->section_code != BinarySection::Custom &&
	sec->section_code != BinarySection::Start) {
	size_t bytes_read = read_u32_leb128(
	&binary->data[sec->offset], &binary->data[binary->size], &sec->count);
	if (bytes_read == 0)
	WABT_FATAL("error reading section element count\n");
	sec->payload_offset = sec->offset + bytes_read;
	sec->payload_size = sec->size - bytes_read;
	}
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnTable(uint32_t index,
	Type elem_type,
	const Limits* elem_limits) {
	if (elem_limits->has_max && (elem_limits->max != elem_limits->initial))
	WABT_FATAL("Tables with max != initial not supported by wabt-link\n");

	binary->table_elem_count = elem_limits->initial;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnElemSegmentFunctionIndexCount(uint32_t index,
	uint32_t count) {
	Section* sec = current_section;

	/* Modify the payload to include only the actual function indexes */
	size_t delta = state->offset - sec->payload_offset;
	sec->payload_offset += delta;
	sec->payload_size -= delta;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnMemory(uint32_t index, const Limits* page_limits) {
	Section* sec = current_section;
	sec->data.memory_limits = *page_limits;
	binary->memory_page_count = page_limits->initial;
	return Result::Ok;
	}

	Result BinaryReaderLinker::BeginDataSegment(uint32_t index,
	uint32_t memory_index) {
	Section* sec = current_section;
	if (!sec->data.data_segments) {
	sec->data.data_segments = new std::vector<DataSegment>();
	}
	sec->data.data_segments->emplace_back();
	DataSegment& segment = sec->data.data_segments->back();
	segment.memory_index = memory_index;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnInitExprI32ConstExpr(uint32_t index,
	uint32_t value) {
	Section* sec = current_section;
	if (sec->section_code != BinarySection::Data)
	return Result::Ok;
	DataSegment& segment = sec->data.data_segments->back();
	segment.offset = value;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnDataSegmentData(uint32_t index,
	const void* src_data,
	uint32_t size) {
	Section* sec = current_section;
	DataSegment& segment = sec->data.data_segments->back();
	segment.data = static_cast<const uint8_t*>(src_data);
	segment.size = size;
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnExport(uint32_t index,
	ExternalKind kind,
	uint32_t item_index,
	StringSlice name) {
	binary->exports.emplace_back();
	Export* export_ = &binary->exports.back();
	export_->name = name;
	export_->kind = kind;
	export_->index = item_index;
	return Result::Ok;
	}

	Result BinaryReaderLinker::BeginNamesSection(uint32_t size) {
	binary->debug_names.resize(function_count + binary->function_imports.size());
	return Result::Ok;
	}

	Result BinaryReaderLinker::OnFunctionName(uint32_t index, StringSlice name) {
	binary->debug_names[index] = string_slice_to_string(name);
	return Result::Ok;
	}

	} // namespace

	Result read_binary_linker(LinkerInputBinary* input_info, LinkOptions* options) {
	BinaryReaderLinker reader(input_info);

	ReadBinaryOptions read_options = WABT_READ_BINARY_OPTIONS_DEFAULT;
	read_options.read_debug_names = true;
	read_options.log_stream = options->log_stream;
	return read_binary(input_info->data, input_info->size, &reader,
	&read_options);
	}

	} // namespace link
	} // namespace wabt