v8/src/wasm/encoder.h

// 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.

#ifndef V8_WASM_ENCODER_H_
#define V8_WASM_ENCODER_H_

#include "src/signature.h"
#include "src/zone-containers.h"

#include "src/base/smart-pointers.h"

#include "src/wasm/wasm-module.h"
#include "src/wasm/wasm-opcodes.h"
#include "src/wasm/wasm-result.h"

namespace v8 {
namespace internal {
namespace wasm {

class WasmModuleBuilder;

class WasmFunctionEncoder : public ZoneObject {
 public:
  uint32_t HeaderSize() const;
  uint32_t BodySize() const;
  uint32_t NameSize() const;
  void Serialize(byte* buffer, byte** header, byte** body) const;

 private:
  WasmFunctionEncoder(Zone* zone, LocalType return_type, bool exported,
                      bool external);
  friend class WasmFunctionBuilder;
  uint16_t signature_index_;
  ZoneVector<LocalType> params_;
  uint16_t local_int32_count_;
  uint16_t local_int64_count_;
  uint16_t local_float32_count_;
  uint16_t local_float64_count_;
  bool exported_;
  bool external_;
  ZoneVector<uint8_t> body_;
  ZoneVector<char> name_;

  bool HasLocals() const {
    return (local_int32_count_ + local_int64_count_ + local_float32_count_ +
            local_float64_count_) > 0;
  }

  bool HasName() const { return exported_ && name_.size() > 0; }
};

class WasmFunctionBuilder : public ZoneObject {
 public:
  uint16_t AddParam(LocalType type);
  uint16_t AddLocal(LocalType type);
  void ReturnType(LocalType type);
  void EmitCode(const byte* code, uint32_t code_size);
  void EmitCode(const byte* code, uint32_t code_size,
                const uint32_t* local_indices, uint32_t indices_size);
  void Emit(WasmOpcode opcode);
  void EmitWithU8(WasmOpcode opcode, const byte immediate);
  void EmitWithLocal(WasmOpcode opcode);
  uint32_t EmitEditableImmediate(const byte immediate);
  void EditImmediate(uint32_t offset, const byte immediate);
  void Exported(uint8_t flag);
  void External(uint8_t flag);
  WasmFunctionEncoder* Build(Zone* zone, WasmModuleBuilder* mb) const;

 private:
  WasmFunctionBuilder(Zone* zone, const unsigned char* name, int name_length);
  friend class WasmModuleBuilder;
  LocalType return_type_;
  struct Type;
  ZoneVector<Type> locals_;
  uint8_t exported_;
  uint8_t external_;
  ZoneVector<uint8_t> body_;
  ZoneVector<uint32_t> local_indices_;
  ZoneVector<char> name_;
  uint16_t AddVar(LocalType type, bool param);
  void IndexVars(WasmFunctionEncoder* e, uint16_t* var_index) const;
};

class WasmDataSegmentEncoder : public ZoneObject {
 public:
  WasmDataSegmentEncoder(Zone* zone, const byte* data, uint32_t size,
                         uint32_t dest);
  uint32_t HeaderSize() const;
  uint32_t BodySize() const;
  void Serialize(byte* buffer, byte** header, byte** body) const;

 private:
  ZoneVector<byte> data_;
  uint32_t dest_;
};

class WasmModuleIndex : public ZoneObject {
 public:
  const byte* Begin() const { return begin_; }
  const byte* End() const { return end_; }

 private:
  friend class WasmModuleWriter;
  WasmModuleIndex(const byte* begin, const byte* end)
      : begin_(begin), end_(end) {}
  const byte* begin_;
  const byte* end_;
};

class WasmModuleWriter : public ZoneObject {
 public:
  WasmModuleIndex* WriteTo(Zone* zone) const;

 private:
  friend class WasmModuleBuilder;
  explicit WasmModuleWriter(Zone* zone);
  ZoneVector<WasmFunctionEncoder*> functions_;
  ZoneVector<WasmDataSegmentEncoder*> data_segments_;
  ZoneVector<FunctionSig*> signatures_;
  ZoneVector<uint16_t> indirect_functions_;
  ZoneVector<std::pair<MachineType, bool>> globals_;
};

class WasmModuleBuilder : public ZoneObject {
 public:
  explicit WasmModuleBuilder(Zone* zone);
  uint16_t AddFunction(const unsigned char* name = nullptr,
                       int name_length = 0);
  uint32_t AddGlobal(MachineType type, bool exported);
  WasmFunctionBuilder* FunctionAt(size_t index);
  void AddDataSegment(WasmDataSegmentEncoder* data);
  uint16_t AddSignature(FunctionSig* sig);
  void AddIndirectFunction(uint16_t index);
  WasmModuleWriter* Build(Zone* zone);

 private:
  struct CompareFunctionSigs {
    int operator()(FunctionSig* a, FunctionSig* b) const;
  };
  typedef ZoneMap<FunctionSig*, uint16_t, CompareFunctionSigs> SignatureMap;

  Zone* zone_;
  ZoneVector<FunctionSig*> signatures_;
  ZoneVector<WasmFunctionBuilder*> functions_;
  ZoneVector<WasmDataSegmentEncoder*> data_segments_;
  ZoneVector<uint16_t> indirect_functions_;
  ZoneVector<std::pair<MachineType, bool>> globals_;
  SignatureMap signature_map_;
};

std::vector<uint8_t> UnsignedLEB128From(uint32_t result);
}  // namespace wasm
}  // namespace internal
}  // namespace v8

#endif  // V8_WASM_ENCODER_H_