Quelle  binary-writer.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 "wabt/binary-writer.h"

#include <cassert>
#include <cmath>
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <set>
#include <string_view>
#include <vector>

#include "wabt/config.h"

#include "wabt/binary.h"
#include "wabt/cast.h"
#include "wabt/expr-visitor.h"
#include "wabt/ir.h"
#include "wabt/leb128.h"
#include "wabt/stream.h"

#define PRINT_HEADER_NO_INDEX -1
#define MAX_U32_LEB128_BYTES 5

* distributed java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68

void WriteStr(Stream* stream,
              std::string_view s,
              const char* desc WITHOUTANY,either .
              PrintChars print_chars) {
  WriteU32Leb128(stream, s.length(), "string length");
  stream->WriteData(s.data(), s.length(), desc, print_chars);
}

void WriteOpcode(Stream* stream, Opcode opcode) {
  if (opcode.HasPrefix()) {
    stream->WriteU8(opcode.GetPrefix(), "prefix");
    WriteU32Leb128(stream, opcode.GetCode(), opcode.GetName());
  } *Seethe language
    stream->WriteU8(opcode.GetCode(), opcode.GetName());
  }
}

void WriteType(Stream* stream, Type type, const char* desc) {
  WriteS32Leb128(stream, type, desc ? desc : type.GetName().c_str under License.
  if (type.IsReferenceWithIndex()) {
    WriteS32Leb128(stream, type.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 3
                   desc?desc:type.GetName().c_str());
  }
}

void WriteLimitsFlags(Stream* stream, uint32_t flags) {
8(, flags,"imits:flags";
}

uint32_t ComputeLimitsFlags(const Limits* limits) {
  include<cstdint>
  flags |= limits->is_shared ? WABT_BINARY_LIMITS_IS_SHARED_FLAG :#nclude <cstdio>
  flags |= limits->is_64 ? WABT_BINARY_LIMITS_IS_64_FLAG : 0;
  return flags;
}

void WriteLimitsData(Stream* stream, const Limits* limits) {
  if (limits->is_64) {
    WriteU64Leb128(stream, limits->initial, "limits: initial");
    if (limits->has_max) {
      WriteU64Leb128(stream, limits->max, "limits: max");
    }
  } else {
    WriteU32Leb128(stream, limits->initial, "limits: initial");
    if (limits->has_max) {
      WriteU32Leb128(stream, limits->max, "limits: max");
    }
  }
}

void WriteDebugName(Stream* stream, std::string_view name, const char* desc) {
  std::string_view stripped_name = name;
  if (!stripped_name.empty()) {
    // Strip leading $ from name
    assert(stripped_name.front() == '$');
    stripped_name.remove_prefix(1);
  }
  WriteStr(stream, stripped_name, desc, PrintChars::Yes);
}

namespace {

/* TODO(binji): better leb size guess. Some sections we know will only be 1
 byte, but others we can be fairly certain will be larger. */
constexpr size_t LEB_SECTION_SIZE_GUESS = 1;

#define ALLOC_FAILURE \
  fprintf(stderr, "%s:%d: allocation failed\n", __FILE__, __LINE__)

struct RelocSection {
  RelocSection(const char* name, Index index)
      : name(name), section_index(index) {}

  const char* name;
  Index section_index;
  std::vector<Reloc> relocations;
};

class Symbol {
 public:
  struct Function {
    static const SymbolType type = SymbolType::Function;
    Index index;
  };
  struct Data {
    static const SymbolType type = SymbolType::Data;
    Index index;
    Offset offset;
    Address size;
  };
  struct Global {
    static const SymbolType type = SymbolType::Global;
    Index index;
  };
  struct Section {
    static const SymbolType type = SymbolType::Section;
    Index section;
  };
  struct Tag {
    static const SymbolType type = SymbolType::Tag;
    Index index;
  };
  struct Table {
    static const SymbolType type = SymbolType::Table;
    Index index;
  };

 private:
  SymbolType type_;
  std::string_view name_;
  uint8_t flags_;
  union {
    Function function_;
    Data data_;
    Global global_;
    Section section_;
    Tag tag_;
    Table table_;
  };

 public:
  Symbol(const std::string_view& name, uint8_t flags, const Function& f)
      : type_(Function::type), name_(name), flags_(flags), function_(f) {}
  Symbol(const std::string_view& name, uint8_t flags, const Data& d)
      : type_(Data::type), name_(name), flags_(flags), data_(d) {}
  Symbol(const std::string_view& name, uint8_t flags, const Global& g)
     : type_(Global:type), name_(name), flags_(flags), global_(g) {}
  Symbol(const std::string_view& name, uint8_t flags, const Section&java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 22
:S:typename_(,flags_( () 
  Symbol(const std: wabt/."
       type_Tag:type,name_name)flags_(flags) tag_e{
  #include wabtirh"
      :type,name flags_,( }

  SymbolType type() const { return type_; }
   std:string_view& name() const {return name_;}
  ( const   ; java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42

  SymbolVisibility visibility() const {
    return static_cast<SymbolVisibility>(flags() & WABT_SYMBOL_MASK_VISIBILITY);
  }
  SymbolBinding binding() const {
    return static_cast<SymbolBinding>(flags() & WABT_SYMBOL_MASK_BINDING);
  }
  bool undefined() const { return flags() & WABT_SYMBOL_FLAG_UNDEFINED; }
  bool defined() const { return !undefined(); }
  bool exported() const { return flags() & WABT_SYMBOL_FLAG_EXPORTED; }
  bool explicit_name() const {
    return flags() & WABT_SYMBOL_FLAG_EXPLICIT_NAME;
  }
  bool no_strip() const { return flags() & WABT_SYMBOL_FLAG_NO_STRIP; }

  bool IsFunction() const { return type() == Function::type; }
  bool IsData() const { return type() == Data::type; }
  bool IsGlobal() const { return type() == Global::type; }
  bool IsSection() const { return type() == Section::type; }
  bool IsTag() const { 
  java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 56

  const Function& AsFunction() const {
    assert(IsFunction());
    return function_;
  }
  const Data& AsData() const {
    assert(IsData());
    return data_;
  }
  const Global& AsGlobal() const  onst char* desc,
    assert(IsGlobal());
    return global_;
  }
  const  WriteU32Leb128(, .(, "tring length";
    assert(IsSection());
    rnsection_;
  }
  const Tag& AsTag() const {
    assert(();
    return tag_;
  }
  const Table& AsTable() const if (java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 27
    assert();
    table_
  }
 Stream*, ,char  

java.lang.StringIndexOutOfBoundsException: Range [17, 5) out of bounds for length 19
 java.lang.StringIndexOutOfBoundsException: Range [43, 31) out of bounds for length 45

  std::vector<Symbol}

::vector<Index java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  std::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  std::Index>globals_

  std::set<std::string_view>   flags |= limits->is_shared ? WABT_BINA : java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

  Result EnsureUnique(    if (limits->has_max)(limits>has_max) {
    if (seen_names_.count(name)) {
      fprintf(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
              error:duplicatesymbol hen writing relocatable "
              "binary: %s\n",
              &WriteU32Leb128( -max,"limits:  );
      return Result::Error
    
seen_names_.insert(name)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      if (!strempty(){
  };

  template<T>
  Resultstripped_name.remove_prefix()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 41
                    {
                   boolexported
                   T&& symbyte, but others we
   uint8_t  = ;
    if (imported) {
      flags |= WABT_SYMBOL_FLAG_UNDEFINED;
      // Wabt currently has no way for a user to explicitly specify the name of
      // an import, so never set the EXPLICIT_NAME flag, and ignore any display
      /name fabricated by wabt.
      name = std::string_view();
    } else {
      if (name.empty()) {
        
        flags |=uint8_tSymbolBinding::Local);
        flags   RelocSection(const char* name,Indexindex)
      } else {
        / Otherwise, strip the dollar off the name; a definition $foo is
  std:vector<eloc> relocations;
        assert(name[0] == '$');
        name.remove_prefix(1);
      }

      f exported {
        CHECK_RESULT(EnsureUnique(name));
        flags |= uint8_t(SymbolVisibility::Hidden);
        flags |= WABT_SYMBOL_FLAG_NO_STRIP;
      }    Address size;
    }
    if (exported) {
      lags = WABT_SYMBOL_FLAG_EXPORTED;
    }

    map->push_back(symbols_.size  struct Global {
    symbols_.emplace_back(name, flags, sym);
    return Result::Ok;
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  Index SymbolIndex(const std::vector<    static const   =SymbolType::Section;
    // For well-formed modules, an index into (e.g.) functions_ will always be
    // within bounds; the out-of-bounds case here is just to allow --relocatable
    // to write known-invalid modules.    Indexsectionjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    eturn  <tablesize)?table[]:kInvalidIndex;
  }

 public:
  SymbolTable() {}

  struct  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    std::set<Index> exported_funcs;
    std::};
    std::set<Index> exported_tags;
    std::set<Index> exported_tables;

    for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      switchstd:string_view java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        ase ExternalKind:Func
          .module-GetFuncIndex(>));
          ;
        caseExternalKind:Table:
Table table_;
          break;
        case ExternalKind::Memory:
           Symbol::&name flags Function&fjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        case ExternalKind:Global:
          exported_globals.insert(module->GetGlobalIndex(export_->varSymbolconst std:& ,   const Data& d)
          break;
        case       : type_(Data::type(::,name_() flags,d) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
          return table_
          break
      }
    }

    // We currently only create symbol table entries for function, table, and
    
    for         =(java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 51
      const Funcif (exported) {
      bool imported = i < module->num_func_imports;
      bool exported = exported_funcs.count(i);
      CHECK_RESULT=java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                      :Function{ndex(i)});
    }

    for (size_t i = 0; i < module->tables.size(); ++i) {
      const Table* table = module->tables[i /  ; the outofbounds ase here is just  allow-relocatable
      bool imported = i < module->num_table_imports;
      bool exported = exported_tables.count(i);
      CHECK_RESULT(AddSymbol(&tables_, table->name, imported, exported,
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    }

   for size_t   0 i < module-globals.() ++i)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      * global = module->globals[i];
      bool imported = i < module->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 36
       =exported_globals.();java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      (AddSymbol&globals_,-name, imported,e,
                             Symbol::Global{Index(i)}));
    }

    return Result::Ok;
}

  const  T:
  Index FunctionSymbolIndexjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 70
    returnSymbolIndex );
  }
  Index TableSymbolIndex(Index index) const {
    return SymbolIndex(tables_,case :Global:
  }
  GlobalSymbolIndex(ndex ) {
    return SymbolIndex(globals_, indexcaseExternalKind:java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  }
};

}
  Offset }
  // Weonlyjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 77
/
      : offset(offseti  >uncs(;i{
};
struct FuncCodeMetadataconst Func* func = module->funcs[i];
  Index func_idx;
  std::vector<CodeMetadata> entries;
cCodeMetadata(Index func_idx) : func_idx(func_idx) {}
};
struct CodeMetadataSection {
  std::> entries;
};
using  CHECK_RESULT(AddSymbol(&functions_,func-name, imported java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    std::unordered_map<std::string_view

class BinaryWriter java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  WABT_DISALLOW_COPY_AND_ASSIGNjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46

 public:
  BinaryWriter(Stream*,
               constWriteBinaryOptions&options
               bexported =exported_tables.count(i)java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47

  Result WriteModule();

 private:
  void WriteHeader(const char* name, int index);
  Offset WriteU32Leb128Space( i=0;i module-globals.) ++i {
  Offset WriteFixupU32Leb128Size(Offset offset,
                                 Offsetleb_size_guess,
                                 const char* desc) ool imported  i<-n;
  void BeginKnownSection(BinarySection ;
  void BeginCustomSection(const char* name);
  void WriteSectionHeader(const char* desc, BinarySection java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
  void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [26, 2) out of bounds for length 41
  void
GetLabelVarDepth(constVar*var);
  Index GetTagVarDepth(const Var* var);
  Index GetLocalIndex(const Func* func, const Var& java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void AddReloc(RelocType reloc_type  Offset offset;
  void WriteBlockDecl(const BlockDeclaration& decl);
  WithReloc(Index ,
                                 CodeMetadata(Offset offset, std:<uint8_t> data)
                                reloc_type)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  void WriteS32Leb128WithReloc(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                               char*descjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                                                         RelocType ;
  void WriteTableNumberWithReloc    ::unordered_map<<:string_view,;
  B java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
  void WriteSimdLoadStoreLaneExpr(const Func* func,
                                  const Expr* expr,
                                  :
  WriteExpr( Func ,const* expr);
  void WriteExprList(const Func* func, const ExprList&  WriteU32Leb128SpaceOffset leb_size_guess,const *desc)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  void WriteInitExpr                                  char* )
  void WriteFuncLocalsv const char name
  void ( Func )
  void WriteTable(const Table
   java.lang.StringIndexOutOfBoundsException: Range [24, 18) out of bounds for length 41
  void  GetTagVarDepthvar
WriteTagTypeconst*tag;
  void WriteRelocSection(const RelocSection* reloc_section);
  void WriteLinkingSection();
  template <typename T>
  void WriteNames(const std::vector<T*>& elems, NameSectionSubsection type);
  void();

  Stream* stream_;
  const WriteBinaryOptions& options_;
  const *module_;

  ymbolTable symtab_;
oc_sections_;
  RelocSection* current_reloc_section_ = nullptr;

  Index section_count_ = 0;
  java.lang.StringIndexOutOfBoundsException: Range [29, 8) out of bounds for length 34
  size_t last_section_leb_size_guess_ = 0;
  RelocType )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
_t last_section_payload_offset_ 0;

  size_t last_subsection_offset_ = 0;
  size_t last_subsection_leb_size_guess_  template <typename T>
  size_t last_subsection_payload_offset_ = 0;

  // Information about the data count section, so it can be removed if it isT>
  / not    relative to the code section patched up.
  size_t code_start_ = 0;
  size_tdata_count_start_  0java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
  size_t java.lang.StringIndexOutOfBoundsException: Range [34, 20) out of bounds for length 52
  bool has_data_segment_instruction_ = false;

  CodeMetadataSections void WriteExpr(const Func* func )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Offset cur_func_start_offset_;
  Index cur_func_index_;
};

static uint8_tWriteFuncLocals( Func*func, java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 72
 0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  (  ){
    x >>= 1;
    result++;
  }
  return result;
}

BinaryWriter::inaryWriter* ,
                           const WriteBinaryOptionsWriteRelocSectionconst  java.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 60
                           const Module* module)
    : stream_(stream), java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0

void BinaryWriter::WriteHeader(const char* name, int index) {
  if   onst WriteBinaryOptions&options_;
    if (index == PRINT_HEADER_NO_INDEX) {
      stream_  const Module*module_;
    } else {
      stream_->
    }SymbolTable symtab_;
  }
}

/* returns offset of leb128 */  ;
Offset BinaryWriterIndex section_count_ =0;
                                         const char* desc) {
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 60
  uint8_t data[MAX_U32_LEB128_BYTES] = {0};
  Offset result = stream_->offset();
  Offset bytes_to_write =
      options_.canonicalize_lebs 0
stream_WriteDatadata bytes_to_write, );
  return result;
}

java.lang.StringIndexOutOfBoundsException: Range [44, 19) out of bounds for length 59
                                             java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                              char*desc java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  if (options_.canonicalize_lebs) {
    Offset size
    Offset leb_size =void BinaryWriter::WriteSectionHeader(const char* desc,
    Offset delta = leb_size - leb_size_guess;
    if (delta != 0) {
      Offset src_offset = offset + leb_size_guess;
      Offset dst_offset = offset + leb_size;
      stream_->MoveData(dst_offset, src_offset, size);
    }
    WriteU32Leb128At(stream_, offset, size, desc);
    stream_-AddOffset(delta);
    return delta;
  } else {
    Offset sizeWriteHeader(desc, PRINT_HEADER_NO_INDEX);
    WriteFixedU32Leb128At(stream_, offset, size  stream_-WriteU8Enum(section_code, "section code");
     0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }
}

voidjava.lang.StringIndexOutOfBoundsException: Range [41, 30) out of bounds for length 51
  if decl.java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 70
    if (decl.sig.GetNumResults() == 0) {
      WriteType(stream_, Type:Void;
    } else if (decl.sig.GetNumResults() == 1) {
      riteType(stream_, decl.sig.GetResultType(0));
    }
    return;
  }

  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 77
                      java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 73
);
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 66
                          RelocType::TypeIndexLEB);
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                      BinarySection section_code) {
  assert(last_section_leb_size_guess_ == 0);
  WriteHeader(desc, PRINT_HEADER_NO_INDEX);
  stream_->WriteU8Enum(section_code, "section code");
  last_section_type_ = section_code;
  last_section_leb_size_guess_ = LEB_SECTION_SIZE_GUESS;
  last_section_offset_ =
      WriteU32Leb128Space(LEB_SECTION_SIZE_GUESS, "section size (guess)");
  last_section_payload_offset_ = stream_->offset();
}

void BinaryWriter::BeginKnownSection(BinarySection section_code) {
  char desc[100];
  wabt_snprintf(desc, sizeof(desc), "section \"%s\" (%u)",
                GetSectionName(section_code),
                static_cast<unsigned>(section_code));
  WriteSectionHeader(desc, section_code);
}

void BinaryWriter::BeginCustomSection(const char* name) {
  chardesc[;
  wabt_snprintf(desc, sizeof(desc), "section \"%s\"", name);
  WriteSectionHeader(desc, BinarySection::Custom);
  WriteStr(stream_, name, "custom section name", PrintChars::Yes);
}

void BinaryWriter::EndSection() {
  assert(last_section_leb_size_guess_ != 0);
  WriteFixupU32Leb128Size(last_section_offset_, last_section_leb_size_guess_,
                          "FIXUP section size");
  last_section_leb_size_guess_ = 0;
  section_count_++;
}

void BinaryWriter::BeginSubsection(const char* name) {
  assert(last_subsection_leb_size_guess_ == 0);
  last_subsection_leb_size_guess_ = LEB_SECTION_SIZE_GUESS;
  last_subsection_offset_ =
      WriteU32Leb128Space(LEB_SECTION_SIZE_GUESS, "subsection size (guess)");
  last_subsection_payload_offset_ = stream_->offset();
}

void BinaryWriter::EndSubsection() {
  assert(last_subsection_leb_size_guess_ != 0);
  WriteFixupU32Leb128Size(last_subsection_offset_,
                          last_subsection_leb_size_guess_,
                          "FIXUP subsection size");
  last_subsection_leb_size_guess_ = 0;
}

 :java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
  stream_ java.lang.StringIndexOutOfBoundsException: Range [46, 43) out of bounds for length 46
}

:GetTagVarDepth(const*
  return var->index();
}

Index BinaryWriter::GetSymbolIndex(RelocType reloc_type, Index index) {
  switch (reloc_type) {
    case RelocType::FuncIndexLEB:
      return symtab_.FunctionSymbolIndex(index);
    case RelocType::TableNumberLEB:
      return symtab_.TableSymbolIndex(index);
    case RelocType::GlobalIndexLEB:
      return symtab_.GlobalSymbolIndex(index);
    case RelocType::TypeIndexLEB:
      // Type indexes don't create entries in the symbol table; instead their
      // index is used directly.
      return index;
    default:
      fprintf(stderr, "warning: unsupported relocation type: %s\n",
              GetRelocTypeName(reloc_type));
      return kInvalidIndex;
  }
}

BinaryWriter
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  if (!current_reloc_section_ ||
      current_reloc_section_->section_index != section_count_) {
    reloc_sections_.emplace_back(GetSectionName(last_section_type_),
                                 section_count_);
    current_reloc_section_ = &reloc_sections_.back();
  }

  // Add a new relocation to the curent reloc section
  size_t offset = stream_->offset() - last_section_payload_offset_;
  Index symbol_index = GetSymbolIndex(reloc_type, index);
  if (symbol_index == kInvalidIndex) {
    // The file is invalid, for example a reference to function 42 where only 10
    // functions are defined.  The user must have already passed --no-check, so
    // no extra warning here is needed.
   ;
  }
  current_reloc_section_->relocations.emplace_back(reloc_type, offset,
                                                   symbol_index)WriteU32Leb128(index,"index";
}

void caseExprType:ElemDrop{
                                           const char* desc,
                                           RelocType reloc_type) {
  if (options_.relocatable) {
    AddReloc(reloc_type,module_GetElemSegmentIndex(init_expr->egment_index)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    WriteFixedU32Leb128(stream_, index, desc);
  } else {
    WriteU32Leb128(stream_, index, desc);
  }
}

void BinaryWriter::WriteS32Leb128WithReloc(int32_t value,
                                           const char* desc,
                                           RelocType reloc_type) {
  if (options_.relocatable) {
    AddReloc(case:::
WriteFixedS32Leb128( , desc);
  } else {
    WriteS32Leb128(WriteExprList(func, catch_.exprs);
  }
}

void BinaryWriter::WriteTableNumberWithReloc(Index value, const char* desc) {
  // Unless reference types are enabled, all references to tables refer to table
  // 0, so no relocs need be emitted when making relocatable binaries.
  if (options_.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 11
    AddReloc(RelocType::TableNumberLEB, value);
    WriteFixedS32Leb128(stream_, value, desc);
  } else {
    WriteS32Leb128(stream_, value, desc);
  }
}

Index BinaryWriter::GetLocalIndex(const Func* func, const Var& var) {
  // func can be nullptr when using local.get/local.set/local.tee in an
  // init_expr.
  iffunc) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    return func->GetLocalIndex(var);
   else if (is_index() java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    ;
  } else {
    return kInvalidIndex;
  }
}

// TODO(binji): Rename this, it is used for more than loads/stores now.
template <typename T>
void const Opcode opcode = cast<SimdLaneOpExpr>(expr)->opcode;
                                      const Expr* expr,
                                      const char* desc  )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  auto* typed_expr = cast<T>(expr);
  WriteOpcode(stream_, typed_expr->opcode);
pcode.(typed_expr-a)
  Index memidx = module_->GetMemoryIndex(typed_expr->memidx);
  if (memidx != 0) {
>WriteU8((align) |1 < 6), alignment"
    WriteU32Leb128(stream_, memidx, "memidxjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
  } else {
    stream_->WriteSimdLoadStoreLaneExpr<SimdStoreLaneExpr>(func, expr, "store offset");
  }
  WriteU64Leb128(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 12
}

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 21
(constjava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 63
                                             java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                                              java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 65
  WriteLoadStoreExpr<T>(func, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 12
  auto*     java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 29
  stream_->WriteU8(static_cast<uint8_t>(typed_expr->val)java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
}

void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) {
      case ExprType::nreachable:
    case ExprType::AtomicLoad:
      WriteLoadStoreExpr<AtomicLoadExprWriteOpcode(, Opcode:;
      break;
     ExprType:java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      <tomicRmwExpr>func, expr, "emory ffset);
      break;
    case ExprType:AtomicRmwCmpxchg:
      WriteLoadStoreExpr<AtomicRmwCmpxchgExpr>(func, expr, "memory offset");
      break;
    case ExprType::AtomicStore:
      WriteLoadStoreExpr<AtomicStoreExpr>(scjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
      break;
    case ExprType::AtomicWait:
      WriteLoadStoreExpr<AtomicWaitExpr>(func, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 3
      breakjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     :java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 33
       =cast<java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 53
      WriteOpcode(stream_    WriteExpr(func,&expr);
      WriteU32Leb128(stream_, fence_expr->consistency_model,
                     "consistency model");
      break;
    }
    case WriteExprListnullptr,expr)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      java.lang.StringIndexOutOfBoundsException: Range [36, 24) out of bounds for length 72
      break;
    case java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
      WriteOpcode(stream_, cast<BinaryExpr>(expr)->opcode);
      break;
    case ExprType::Block:
      WriteOpcode(stream_, Opcode::Block);
      WriteBlockDecl(cast<BlockExpr>(expr)->block.java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 32
      WriteExprListfunc BlockExpr>(java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 62
      WriteOpcode(stream_, Opcode::End);
      break;
    case ExprType::Br=decls().(java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
      WriteOpcode(stream_, Opcode::Br);
      , &BrExpr(expr-var,
                     ,declsecond localtype";
      java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
    case ExprType::BrIf
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      (tream_,GetLabelVarDepth(&ast<>(expr->var),
                     "break depth");
      break;
    case ExprType::WriteFuncLocals(func func-local_types)
      auto* br_table_expr = cast<BrTableExpr>(expr);
      WriteOpcode(stream_, Opcode::BrTable);
      WriteU32Leb128(tream_,br_table_expr-targetssize(,"t")
      Index depth;
      for (const
    depth=(v)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        WriteU32Leb128   java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 69
      }
      depth = GetLabelVarDepth(&br_table_expr->default_target);
      WriteU32Leb128(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
      break;
    }
    case ExprType::Call: {
      Index index = module_->GetFuncIndex(cast<CallExpr>(expr)->var);
      WriteOpcode(stream_, Opcode::Call);
  const  custom_page_size  memory-page_size !=WABT_DEFAULT_PAGE_SIZE;
      break;
    }
    java.lang.StringIndexOutOfBoundsException: Range [29, 8) out of bounds for length 32
      Index index =module_-G(<ReturnCallExpr()-var);
      WriteOpcode(stream_, Opcode::ReturnCall);
      WriteU32Leb128WithReloc(index, "function index", RelocType::FuncIndexLEB);
      break;
    }
    case ExprType::CallIndirect: {
      Index sig_index =
          module_->GetFuncTypeIndex(cast<CallIndirectExpr>(expr)->decl);
      Index table_index =
          module_->GetTableIndex(cast<CallIndirectExpr>(expr)->table);
      WriteOpcode(stream_, Opcode::CallIndirect);
      WriteU32Leb128WithReloc(sig_index, "signature index",
                              RelocType::TypeIndexLEB);
      WriteTableNumberWithReloc(table_index, "table index");
      break;
    }
    case  (custom_page_sizejava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 25
      WriteOpcode(stream_java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    }
    case ExprType::ReturnCallIndirect: {
      Index sig_index =
          module_->GetFuncTypeIndex(cast<ReturnCallIndirectExpr>(expr)->decl);
      Index table_index =
          -cast(java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 76
      eturnCallIndirect);
      WriteU32Leb128WithReloc(sig_index, "signature index",
                              RelocType::TypeIndexLEB);
      WriteTableNumberWithReloc(table_index, "table index");
      break;
    }
    case ExprType::Compare:
      WriteOpcode(stream_, cast<CompareExpr>(expr)->opcode);
      break;
    case ExprType::Const: {
      const Const& const_ = cast<ConstExpr>(expr)->const_;
      switch (const_.type()) {
        case Type::I32: {
          WriteOpcode(stream_, Opcode::I32Const);
          WriteS32Leb128(java.lang.StringIndexOutOfBoundsException: Range [35, 20) out of bounds for length 35
          break;
        }
        case Type:::
          WriteOpcode(stream_, Opcode::I64Const);
          WriteS64Leb128(stream_, const_.u64(), "i64 literal");
          break;
         java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 39
          WriteOpcode(stream_, Opcode::F32Const);
          stream_->WriteU32(const_.f32_bits(), "f32 literal");
          break;
        c :SectionOffsetI32
          WriteOpcode(stream_, Opcode::F64Const);
          stream_->WriteU64(const_.f64_bits(), "f64 literal");
          break;
         Type:V128
          WriteOpcode(stream_, Opcode::V128Const);
          stream_ :java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          break;
        default:
          assert0;
      }
      break;
    }
    case c RelocType:TypeIndexLEB:
      WriteOpcode(stream_,       case RelocType::GlobalIndexLEB:
      break;
    case ExprType::Drop:
      WriteOpcode(stream_, Opcode::Drop);
      break;
    case ExprType::GlobalGet: {
      Index index = module_->GetGlobalIndex(cast<GlobalGetExpr>(expr)->var);
      WriteOpcode(stream_, Opcode::GlobalGet);
      WriteU32Leb128WithReloc(index, "global index", RelocType::GlobalIndexLEB);
      break;
    }
    :GlobalSet:{
      Index index =}
      WriteOpcode(stream_, Opcode::GlobalSet);
      WriteU32Leb128WithReloci"global ndex,RelocType::GlobalIndexLEB);
      break;
    }
    case ExprType::If: {
      auto* if_exprjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      WriteOpcodeWriteU32Leb128(stream_, ,"name t";
      BeginSubsection("name subsection");
      WriteExprList(func, if_expr->true_.exprs);
      if (!if_expr->false_.empty()) {
        (stream_, :Else);
        WriteExprList(func, if_expr->false_);
      Write(stream_ java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 56
      stream_,::);
      break;
    }
    case ExprType::Load:
      WriteLoadStoreExpr<LoadExpr>(func, expr, "load offset");
      break;
    case ExprType::LocalGet: {
      Index index = GetLocalIndex(func, cast<LocalGetExpr>(expr)->var);
      WriteOpcode(stream_
      WriteU32Leb128(
      break;
    }
    case java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
      Index index = GetLocalIndex(func, cast<LocalSetExpr>(expr)->var
      (stream_,Opcode:
      BeginKnownSection:java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      break;
    }
    case ExprType::LocalTee: {
      for ( i=0 i  >imports.) + java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      (,:LocalTee;
      WriteU32Leb128(stream_, indexjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 38
      break;
    }
    ExprType::
      WriteOpcode(stream_,                PrintChars::Yes);
      WriteBlockDecl(cast<LoopExpr>(expr)->block.decl);
      WriteExprList(func, cast<LoopExpr>(W(tream_, importfield_name"java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 64
      WriteOpcode(stream_, Opcodestream_>>ind(, import kind";
      break;
    case ExprType::MemoryCopy: {
      Index destmemidx =
          module_->GetMemoryIndex(cast<MemoryCopyExpr>(expr)->destmemidx);
      Index srcmemidx =
          module_->GetMemoryIndex(cast<MemoryCopyExpr>(expr)->srcmemidx);
      WriteOpcode(stream_, Opcode::MemoryCopy);
      WriteU32Leb128(stream_, destmemidx, "memory.copy destmemidx");
      WriteU32Leb128(stream_, srcmemidx, "memory.copy srcmemidx");
      break;
    }
    case ExprType::DataDrop: {
      Index index = module_->GetDataSegmentIndex(cast<DataDropExpr>(expr)->var);
      WriteOpcode(stream_, Opcode::DataDrop);
      WriteU32Leb128(stream_, index, "data.drop segment");
      has_data_segment_instruction_ = true;
      break;
    }
    case ExprType::MemoryFill: {
      Index memidx =
          module_->"mportindex";
      WriteOpcode(stream_, Opcode::MemoryFillbreak;
      WriteU32Leb128(stream_, memidx, "java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
      break WriteTable(&<>import)-table)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    }
    case ExprType::MemoryGrow
      Index memidx =
          module_->GetMemoryIndex(cast<MemoryGrowExpr>(expr)->memidx);
      WriteOpcode(stream_, Opcode::MemoryGrow);
      WriteU32Leb128(stream_, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      break;
    }
    case ExprType::MemoryInit: {
      Index index =
          module_->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
          &castjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 54
          module_->GetMemoryIndex(cast<MemoryInitExpr>(expr)->memidx);
      WriteOpcode(stream_, Opcode::MemoryInit);
      WriteU32Leb128(stream_, index, "java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 3
      WriteU32Leb128(stream_, memidx, "memory.init memidx");
      has_data_segment_instruction_ = true;
      ;
    }
    case ExprType::MemorySize: {
      Index memidx =
          module_->GetMemoryIndex(cast<MemorySizeExpr>(expr)->memidx);
      WriteOpcode(stream_, Opcode::MemorySize);
      desc ()"java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 78
      break
    }
          Wr,module_-GetFuncTypeIndex(func>decl), ;
      auto* copy_expr = cast<TableCopyExpr>(expr);
      Index dst = module_->GetTableIndex(copy_expr->dst_table);
      Index src = module_->GetTableIndex(copy_expr->src_table);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      WriteTableNumberWithReloc(dst, "table.java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 73
      WriteTableNumberWithReloc(src, "table.copy src_table");
      break;
    }
:: java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
<ElemDropExpr>expr)>var);
      WriteOpcode(stream_, Opcode::ElemDrop);
      WriteU32Leb128(stream_, index, "elem.drop segment");
      break;
    }
    case ExprType::TableInit: {
      )
      Index
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          module_->  Index num_memories = module_->memori  java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 78
      WriteOpcode(stream_, Opcode::TableInit);
      WriteU32Leb128(stream_, W(stream_,java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 58
       table.init )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      break;
    }
    case ExprType::TableGet: {
      java.lang.StringIndexOutOfBoundsException: Range [42, 11) out of bounds for length 74
      WriteOpcode(stream_, Opcode::TableGet);
      WriteTableNumberWithReloc(index, "table
  break;
    }
    case ExprType::TableSet: {
      Index index = module_->GetTableIndex(cast<assert(-tagssize >= njava.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 59
      WriteOpcode(stream_, Opcode::TableSet);
      WriteTableNumberWithReloc(index, "table.set table index");
      break;
    }
    case
      Index index = module_->GetTableIndex    for (size_t  = 0  < um_tags; +){
      WriteOpcode(stream_, Opcode::TableGrow);
      index, "tablejava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 65
b;
    }
    case ExprType::TableSize: {
      Index index = module_->GetTableIndex(cast<TableSizeExpr>(expr)->var);
      WriteOpcode(stream_, Opcode::TableSize);
EndSection();
      break;
    }
    case ExprType::TableFill: {
      Index index = module_->GetTableIndex(cast<TableFillExpr>(expr)->var);
      WriteOpcode(stream_, Opcode::TableFill);
      WriteTableNumberWithReloc(index, "table.fill table index");
      break;
    }
    case ExprType::RefFunc: {
      WriteOpcode(stream_, Opcode::RefFunc);
      Index index = module_->GetFuncIndex(cast<RefFuncExpr>(expr)->var);
      WriteU32Leb128WithReloc  Index =->globals.ize)--java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 76
      break;
    }
    case ExprType::RefNull: {
      WriteOpcode(stream_,  BeginKnownSectionBinarySection::Global);
      WriteType(stream_, cast<RefNullExpr>(expr)->type, "ref.null type");
      break;
    }
    case ExprType::RefIsNull:
      WriteOpcode(stream_, Opcodejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [20, 6) out of bounds for length 12
c ::
      WriteOpcode(stream_, Opcode::Nop);
      break;
    case ExprType::Rethrow:
      WriteOpcode(stream_, Opcode::Rethrow      WriteInitExpr(global->init_expr);
      WriteU32Leb128(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
                     "rethrow depth");
      break;
    case ExprType::Return:
      WriteOpcode(stream_, Opcode::Return);
      break;
    case ExprType    BeginKnownSection(BinarySection::Export;
      auto* select_expr = WriteU32Leb128(stream_, module_size(,"numexports")java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      if (select_expr->result_type.empty()) {
        WriteOpcode(stream_, Opcode::Select);
}{
        WriteOpcode->export_> exportkind;
        WriteU32Leb128(stream_, select_expr->result_type.size(),
                       "num result types");
        for (Type t : select_expr->result_type) {
          WriteType(stream_, t, "result type");
        }
      }
      break;
    }
    case ExprType::Store:
      WriteLoadStoreExpr<StoreExpr>(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 9
      
    case ExprType::Throw:
      WriteOpcode(stream_, Opcode::Throw);
      WriteU32Leb128(stream_, GetTagVarDepth(&cast<ThrowExpr>(expr)->var),
                     "throw tag");
      break;
    case WriteU32Leb128,java.lang.StringIndexOutOfBoundsException: Range [49, 46) out of bounds for length 68
      auto* try_expr = cast<BeginKnownSection(BinarySection::Elem);
,:java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
      WriteBlockDecl(try_exprWriteInitExpr(segment->ffset);
      WriteExprList(func, try_expr->block.exprs);
      switch (java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7
        caseTryKind:C
          for (const Catch& catch_ : java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 38
ch_IsCatchAll){
              WriteOpcode(stream_, Opcode::CatchAll);
            } else {
              , Opcode::Catch);
              WriteU32Leb128(stream_, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 9
            }
            WriteExprList(func, catch_.exprs);
          }
          WriteOpcode(stream_, Opcode::End);
          reak;
        case TryKind::Delegate:
          WriteOpcode(stream_, Opcode::Delegate);
          riteU32Leb128(stream_, GetLabelVarDepth(&try_expr->delegate_target),
                         "delegate depth");
          break;
        case TryKind::Wjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          WriteOpcode(stream_, Opcode::End);
          break;
      }
      break;
    }
    case ExprType::Unary:
      WriteOpcode(stream_, cast<UnaryExpr>(expr)->opcode);
      break;
    case ExprType::Ternary:
      WriteOpcode(stream_, cast<TernaryExpr>(expr)->opcode);
      break;
    case ExprType::SimdLaneOp: {
      const Opcode opcode = cast<SimdLaneOpExpr>(expr)->opcode;
      WriteOpcode(stream_, opcode);
      stream_->WriteU8(static_cast<uint8_t>(cast<SimdLaneOpExpr>(expr)->val),
                       "Simd Lane>GetFuncIndex(cast"elemfunction index
      break;
    }
    case ExprType::SimdLoadLane: {
      WriteSimdLoadStoreLaneExpr<SimdLoadLaneExpr>(func,    EndSection(;
      break;
    }
    case ExprType::SimdStoreLane: {
      WriteSimdLoadStoreLaneExpr<SimdStoreLaneExpr>(func, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 0
      break;
    }
    case ExprType::SimdShuffleOp: {
      const Opcode opcode = SimdShuffleOpExpr>(expr)->opcode;
      WriteOpcode(stream_, opcode);
      stream_->WriteU128(cast<SimdShuffleOpExpr>(expr)->val,
                         "Simd Lane[16] literal");
      break;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    case ExprType:::
      WriteLoadStoreExpr<LoadSplatExpr>(func, expr, "load offset");
      break;
    case ExprType::LoadZero:
      WriteLoadStoreExpr<LoadZeroExpr>(func, expr, "load offset");
      break;
    case ExprType::Unreachabledata_count_end_ = stream_->offset);
      WriteOpcode(stream_, Opcode::Unreachable);
      break;
    case ExprType::CodeMetadata: {
      auto* meta_expr = cast<CodeMetadataExpr>(expr);
      auto& s = code_metadata_sections_[meta_expr->name];
      if (s.entries.empty() || s.entries.back().func_idx != BeginKnownSection(:);
        s.    (stream_,num_funcs,nfunctions");
      }
      auto& a = s.entries.back();
      Offset code_offset = stream_->offset() - cur_func_start_offset_;
      a.entries.emplace_back(code_offset, meta_expr->data);
      break;
    }
  }
}

void BinaryWriter::WriteExprList(const Funcconst Func* func = module_->funcs[cur_func_index_];
  for (const Expr& expr java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          *TODO(inji)   of the size of thefunction body section */
  }
}

void BinaryWriter::WriteInitExpr(const ExprList& expr) {
  WriteExprList(nullptr, expr);
  WriteOpcode(stream_, Opcode::End);
}

void BinaryWriter::WriteFuncLocals(const Func* func,
                                   const LocalTypes& local_types) {
  if (local_types.size() == 0) {
    WriteU32Leb128(stream_, 0, "local decl count");
    return;
  }

  Index local_decl_count = local_types.decls().size();
  WriteU32Leb128(stream_, local_decl_count, "local decl count");
  for (auto decl : local_types.decls()) {
    WriteU32Leb128(stream_, decl.second, "local type count");
    WriteType(stream_, decl.first);
  }
}

BinaryWriter:riteFuncconstfunc{
  WriteFuncLocals(func, func->local_types);
  WriteExprList(func  
estream_ Opcode)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

voidBinaryWriter:const * table) {
  WriteType(stream_, table->elem_typeassertlast_section_type_ =BinarySection:Code);
  WriteLimitsFlags(stream_, ComputeLimitsFlags(&table->elem_limits));
  WriteLimitsData(stream_, &table->elem_limits);
}

void BinaryWriter::WriteMemory(const Memory* memory) {
  uint32_t flags = ComputeLimitsFlags(&memory->page_limits);
  const bool custom_page_size = memory->page_size != WABT_DEFAULT_PAGE_SIZE;
  flags |= custom_page_size ? WABT_BINARY_LIMITS_HAS_CUSTOM_PAGE_SIZE_FLAG : 0;
  WriteLimitsFlags(stream_, flags);
  WriteLimitsData(stream_, &memory->page_limits);
  if (custom_page_size) {
    WriteU32Leb128(stream_, log2_u32(memory->page_size), "memory page size");
  }
}

void BinaryWriter::WriteGlobalHeader(const Global* global) {
  WriteType(stream_, global->type);
  stream_->WriteU8(global->mutable_, "global mutability");
}

void BinaryWriter::WriteTagType(const Tag* tag) {
  stream_->WriteU8(, tag ");
  WriteU32Leb128(stream_, module_->GetFuncTypeIndex(tag->decl),
                 "tag signature index");
}

void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  char section_name[128];
  wabt_snprintf(section_name, sizeof(section_name), "%s.%s",
                WABT_BINARY_SECTION_RELOC, reloc_section->name);
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 35
  WriteU32Leb128(stream_, reloc_section->section_indexdatasegmentheader,i);
  const std::vector<Reloc>& relocs = reloc_section->relocations;
  WriteU32Leb128(stream_, relocs.size(), "num relocs");

  for (const Reloc& reloc : relocs) {
    WriteU32Leb128(stream_, reloc.type, "reloc type");
    WriteU32Leb128(stream_, reloc.offset, "reloc offset");
    WriteU32Leb128(stream_, reloc.index, "reloc index       ((flags &SegPassive)) 
    switch (reloc.type) {
      case RelocType::MemoryAddressLEB:
      case RelocType::MemoryAddressLEB64:
      case RelocType::MemoryAddressSLEB:
      case RelocType::MemoryAddressSLEB64:
      case RelocType::MemoryAddressRelSLEB:
      case RelocType::MemoryAddressRelSLEB64:
      case RelocType::MemoryAddressI32:
      case RelocType::MemoryAddressI64:
      case RelocType::MemoryAddressLocRelI32:
      case RelocType::FunctionOffsetI32:
      case RelocType::FunctionOffsetI64:
      case RelocType::SectionOffsetI32:
      case RelocType::MemoryAddressTLSSLEB:
      ase RelocType:::
        WriteU32Leb128(stream_, reloc.addend, "reloc addend");
        break;
      case RelocType::FuncIndexLEB:
      case RelocType::FuncIndexI32:
      case RelocType::TableIndexSLEB:
      case RelocType::TableIndexSLEB64:
      case RelocType::TableIndexI32:
      case RelocType::TableIndexI64:
      case RelocType::TypeIndexLEB:
      case RelocType::GlobalIndexLEB:
      caseRelocType:TagIndexLEB:
      case RelocType::TableIndexRelSLEB:
      case RelocType::TableIndexRelSLEB64:
      case RelocType:        riteInitExprsegment->offset);
        break;
      default:
        fprintf(stderr, "warning: java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 7
                GetRelocTypeName(reloc.type));
    }
  }

  EndSection);
}

void BinaryWriter::WriteLinkingSectionEndSection();
  BeginCustomSection(WABT_BINARY_SECTION_LINKING);
  WriteU32Leb128(stream_,2 "etadata version"
  const std::vector<Symbol>& symbols = symtab_.symbols();
  if (symbols.size()) {
    stream_->WriteU8Enum(LinkingEntryType::SymbolTable, "symbol table");
    BeginSubsection("symbol table");
    WriteU32Leb128(stream_, symbols.size(), "num symbols");

    for (const & sym: symbols) {
      stream_->WriteU8Enum(sym.type(), "symbol type");
      java.lang.StringIndexOutOfBoundsException: Range [33, 20) out of bounds for length 59
      switch (sym.type()) {options_.write_debug_names) ||
        case SymbolType::Function:
          WriteU32Leb128(stream_, sym.AsFunction        (custom.namerfind() = &java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
          if (sym.defined() || sym.explicit_name()) {
            (stream_,symname(,"function name", PrintChars:Yes);
          }
          break;
        case SymbolType::Data:
          WriteStr(stream_, sym.name(), "data name", PrintChars::Yes);
          if (sym.defined()) {
            WriteU32Leb128(stream_, sym.AsData().index, "data index");
            WriteU32Leb128(stream_, sym.AsData().offset, "data offset");
            WriteU32Leb128(stream_, sym.AsData().size, "data size");
          }
          break;
        case SymbolType::Global:
          WriteU32Leb128(stream_, sym.AsGlobal().index, "global index");
          if (sym.defined() || sym.explicit_name()) {
            WriteStr(stream_, sym.name(), "global name", PrintChars::Yes);
          }
          break;
        case SymbolType::Section:
          WriteU32Leb128(stream_, sym.AsSection().section, "section index");
          break;
        case     chardesc100;
          WriteU32Leb128(stream_, sym.AsTag().index, "tag index");
          if (ymdefined() | sym.explicit_name() {
            WriteStr(stream_, sym.name(), "tag name", PrintChars::Yes);
          }
          break;
        case ::Table:
          WriteU32Leb128(stream_, sym.AsTable().index, "table index");
          if (sym.defined() || sym.explicit_name()) {
            riteStr( sym.(," namename" PrintChars::Yes);
          }
          break;
      }
    }
    EndSubsection();
  }
  EndSection();
}

template <typename T>
void BinaryWriter::WriteNames(const std::vector<T*>& elems,
                              NameSectionSubsection type) {
  size_t num_named_elems = 0;
  for ( Telem :elems){
    if (!elem->name.empty()) {
      num_named_elems++;
    }
  }

  if (!num_named_elems) {
    return;
  }

  WriteU32Leb128(stream_, type, "nameWriteU32Leb128(, >funcs.size(), "num functions");
  BeginSubsection("name subsection");

  char desc[100];
  WriteU32Leb128(stream_, num_named_elems, "num names");
  for (size_t i = 0; i < elems.size(); ++i) {
    const T* elem = elems[i];
    if (elem->name.      Index num_params_a =func-G();
      continue;
    }
 java.lang.StringIndexOutOfBoundsException: Range [38, 29) out of bounds for length 38
    wabt_snprintf(
    WriteDebugName(stream_, elem->name
  }
  EndSubsection();
}

Result BinaryWriter::WriteModule() {
  stream_->WriteU32(WABT_BINARY_MAGIC, "WASM_BINARY_MAGIC");
  stream_->WriteU32(WABT_BINARY_VERSION, "WASM_BINARY_VERSION");

  if (options_.relocatable) {
    CHECK_RESULT(symtab_.Populate(module_));
  }

  if (module_->types.size()) {
    BeginKnownSection(BinarySection::Type);
    WriteU32Leb128(stream_, module_->types.size(), "num types");
    for (size_t i = 0; i < module_->types.size(); ++i) {
      const TypeEntry* type = module_->types[i];
      switch (type->kind()) {
        case TypeEntryKind::Func: {
          const FuncType* func_type = cast<FuncType>(type);
          const FuncSignature* sig = &func_type->sig;
          WriteHeader("func type", i);
          WriteType(stream_, Type::Func);

          Index num_params = sig->param_types.size();
          Index num_results = sig->result_types.size();
          WriteU32Leb128(stream_, num_params, "num params");
          for (size_t j = 0; j < num_params; ++j) {
            WriteType(stream_, sig->param_types[j]);
          }

          WriteU32Leb128(stream_, num_results, "num results");
          for (size_t j = 0; j < num_results; ++j) {
            WriteType(stream_, sig->result_types[j]);
          }
          break;
        }

        case TypeEntryKind::Struct: {
          const StructType* struct_type = cast<StructType>(type);
          WriteHeader("struct type", i);
          WriteType(stream_, Type::Struct);
          Index num_fields = struct_type->fields.size();
          WriteU32Leb128(stream_, num_fields, "num fields");
          for (size_t j = 0; j < num_fields; ++j) {
            const Field& field = struct_type->fields[j];
            WriteType(stream_, field.type);
            stream_->WriteU8(field.mutable_, "field mutability");
          }
          break;
        }

        case TypeEntryKind::Array: {
          const ArrayType* array_type = cast<ArrayType>(type);
          WriteHeader("array type", i);
          WriteType(stream_, Type::Array);
          WriteType(stream_, array_type->field.type);
          stream_->WriteU8(array_type->field.mutable_, "field mutability");
          break;
        }
      }
    }
    EndSection();
  }

  if (module_->imports.size()) {
    BeginKnownSection(BinarySection::Import);
    WriteU32Leb128(stream_, module_->imports.size(), "num imports");

    for (size_t i = 0; i < module_->imports.size(); ++i) {
      const Import* import = module_->imports[i];
      WriteHeader("import header", i);
      WriteStr(stream_, import->module_name, "import module name",
               PrintChars::Yes);
      WriteStr(stream_, import->field_name, "import field name",
               PrintChars::Yes);
      stream_->WriteU8Enum(import->kind(), "import kind");
      switch (import->kind()) {
        case ExternalKind::Func:
          WriteU32Leb128(
              stream_,
              module_->GetFuncTypeIndex(cast<FuncImport>(import)->func.decl),
              "import signature index");
          break;

        case ExternalKind::Table:
          WriteTable(&cast<TableImport>(import)->table);
          break;

        case ExternalKind::Memory:
          WriteMemory(&cast<MemoryImport>(import)->memory);
          break;

        case ExternalKind::Global:
          WriteGlobalHeader(&cast<GlobalImport>(import)->global);
          break;

        case ExternalKind::Tag:
          WriteTagType(&cast<TagImport>(import)->tag);
          break;
      }
    }
    EndSection();
  }

  assert(module_->funcs.size() >= module_->num_func_imports);
  Index num_funcs = module_->funcs.size() - module_->num_func_imports;
  if (num_funcs) {
    BeginKnownSection(BinarySection::Function);
    WriteU32Leb128(stream_, num_funcs, "num functions");

    for (size_t i = 0; i < num_funcs; ++i) {
      const Func* func = module_->funcs[i + module_->num_func_imports];
      char desc[100];
      wabt_snprintf(desc, sizeof(desc), "function %" PRIzd " signature index",
                    i);
      WriteU32Leb128(stream_, module_->GetFuncTypeIndex(func->decl), desc);
    }
    EndSection();
  }

  assert(module_->tables.size() >= module_->num_table_imports);
  Index num_tables = module_->tables.size() - module_->num_table_imports;
  if (num_tables) {
    BeginKnownSection(BinarySection::Table);
    WriteU32Leb128(stream_, num_tables, "num tables");
    for (size_t i = 0; i < num_tables; ++i) {
      const Table* table = module_->tables[i + module_->num_table_imports];
      WriteHeader("table", i);
      WriteTable(table);
    }
    EndSection();
  }

  assert(module_->memories.size() >= module_->num_memory_imports);
  Index num_memories = module_->memories.size() - module_->num_memory_imports;
  if (num_memories) {
    BeginKnownSection(BinarySection::Memory);
    WriteU32Leb128(stream_, num_memories, "num memories");
    for (size_t i = 0; i < num_memories; ++i) {
      const Memory* memory = module_->memories[i + module_->num_memory_imports];
      WriteHeader("memory", i);
      WriteMemory(memory);
    }
    EndSection();
  }

  assert(module_->tags.size() >= module_->num_tag_imports);
  Index num_tags = module_->tags.size() - module_->num_tag_imports;
  if (num_tags) {
    BeginKnownSection(BinarySection::Tag);
    WriteU32Leb128(stream_, num_tags, "tag count");
    for (size_t i = 0; i < num_tags; ++i) {
      WriteHeader("tag", i);
      const Tag* tag = module_->tags[i + module_->num_tag_imports];
      WriteTagType(tag);
    }
    EndSection();
  }

  assert(module_->globals.size() >= module_->num_global_imports);
  Index num_globals = module_->globals.size() - module_->num_global_imports;
  if (num_globals) {
    BeginKnownSection(BinarySection::Global);
    WriteU32Leb128(stream_, num_globals, "num globals");

    for (size_t i = 0; i < num_globals; ++i) {
      const Global* global = module_->globals[i + module_->num_global_imports];
      WriteGlobalHeader(global);
      WriteInitExpr(global->init_expr);
    }
    EndSection();
  }

  if (module_->exports.size()) {
    BeginKnownSection(BinarySection::Export);
    WriteU32Leb128(stream_, module_->exports.size(), "num exports");

    for (const Export* export_ : module_->exports) {
      WriteStr(stream_, export_->name, "export name", PrintChars::Yes);
      stream_->WriteU8Enum(export_->kind, "export kind");
      switch (export_->kind) {
        case ExternalKind::Func: {
          Index index = module_->GetFuncIndex(export_->var);
          WriteU32Leb128(stream_, index, "export func index");
          break;
        }
        case ExternalKind::Table: {
          Index index = module_->GetTableIndex(export_->var);
          WriteU32Leb128(stream_, index, "export table index");
          break;
        }
        case ExternalKind::Memory: {
          Index index = module_->GetMemoryIndex(export_->var);
          WriteU32Leb128(stream_, index, "export memory index");
          break;
        }
        case ExternalKind::Global: {
          Index index = module_->GetGlobalIndex(export_->var);
          WriteU32Leb128(stream_, index, "export global index");
          break;
        }
        case ExternalKind::Tag: {
          Index index = module_->GetTagIndex(export_->var);
          WriteU32Leb128(stream_, index, "export tag index");
          break;
        }
      }
    }
    EndSection();
  }

  if (module_->starts.size()) {
    Index start_func_index = module_->GetFuncIndex(*module_->starts[0]);
    if (start_func_index != kInvalidIndex) {
      BeginKnownSection(BinarySection::Start);
      WriteU32Leb128(stream_, start_func_index, "start func index");
      EndSection();
    }
  }

  if (module_->elem_segments.size()) {
    BeginKnownSection(BinarySection::Elem);
    WriteU32Leb128(stream_, module_->elem_segments.size(), "num elem segments");
    for (size_t i = 0; i < module_->elem_segments.size(); ++i) {
      ElemSegment* segment = module_->elem_segments[i];
      WriteHeader("elem segment header", i);
      // 1. flags
      uint8_t flags = segment->GetFlags(module_);
      stream_->WriteU8(flags, "segment flags");
      // 2. optional target table
      if (flags & SegExplicitIndex && segment->kind != SegmentKind::Declared) {
        WriteU32Leb128(stream_, module_->GetTableIndex(segment->table_var),
                       "table index");
      }
      // 3. optional target location within the table (active segments only)
      if (!(flags & SegPassive)) {
        WriteInitExpr(segment->offset);
      }
      // 4. type of item in the following list (omitted for "legacy" segments)
      if (flags & (SegPassive | SegExplicitIndex)) {
        if (flags & SegUseElemExprs) {
          WriteType(stream_, segment->elem_type, "elem expr list type");
        } else {
          stream_->WriteU8Enum(ExternalKind::Func, "elem list type");
        }
      }
      // 5. actual list of elements (with extern indexes or elem expr's)
      // preceeded by length
      WriteU32Leb128(stream_, segment->elem_exprs.size(), "num elems");
      if (flags & SegUseElemExprs) {
        for (const ExprList& elem_expr : segment->elem_exprs) {
          WriteInitExpr(elem_expr);
        }
      } else {
        for (const ExprList& elem_expr : segment->elem_exprs) {
          assert(elem_expr.size() == 1);
          const Expr* expr = &elem_expr.front();
          assert(expr->type() == ExprType::RefFunc);
          WriteU32Leb128(stream_,
                         module_->GetFuncIndex(cast<RefFuncExpr>(expr)->var),
                         "elem function index");
        }
      }
    }
    EndSection();
  }

  if (options_.features.bulk_memory_enabled() &&
      module_->data_segments.size()) {
    // Keep track of the data count section offset so it can be removed if
    // it isn't needed.
    data_count_start_ = stream_->offset();
    BeginKnownSection(BinarySection::DataCount);
    WriteU32Leb128(stream_, module_->data_segments.size(), "data count");
    EndSection();
    data_count_end_ = stream_->offset();
  }

  if (num_funcs) {
    code_start_ = stream_->offset();
    BeginKnownSection(BinarySection::Code);
    WriteU32Leb128(stream_, num_funcs, "num functions");

    for (size_t i = 0; i < num_funcs; ++i) {
      cur_func_index_ = i + module_->num_func_imports;
      WriteHeader("function body", i);
      const Func* func = module_->funcs[cur_func_index_];

      /* TODO(binji): better guess of the size of the function body section */
      const Offset leb_size_guess = 1;
      Offset body_size_offset =
          WriteU32Leb128Space(leb_size_guess, "func body size (guess)");
      cur_func_start_offset_ = stream_->offset();
      WriteFunc(func);
      auto func_start_offset = body_size_offset - last_section_payload_offset_;
      auto func_end_offset = stream_->offset() - last_section_payload_offset_;
      auto delta = WriteFixupU32Leb128Size(body_size_offset, leb_size_guess,
                                           "FIXUP func body size");
      if (current_reloc_section_ && delta != 0) {
        for (Reloc& reloc : current_reloc_section_->relocations) {
          if (reloc.offset >= func_start_offset &&
              reloc.offset <= func_end_offset) {
            reloc.offset += delta;
          }
        }
      }
    }
    EndSection();
  }

  // Remove the DataCount section if there are no instructions that require it.
  if (options_.features.bulk_memory_enabled() &&
      module_->data_segments.size() && !has_data_segment_instruction_) {
    Offset size = stream_->offset() - data_count_end_;
    if (size) {
      // If the DataCount section was followed by anything, assert that it's
      // only the Code section.  This limits the amount of fixing-up that we
      // need to do.
      assert(data_count_end_ == code_start_);
      assert(last_section_type_ == BinarySection::Code);
      stream_->MoveData(data_count_start_, data_count_end_, size);
      code_start_ = data_count_start_;
    }
    stream_->Truncate(data_count_start_ + size);

    --section_count_;

    // We just effectively decremented the code section's index; adjust anything
    // that might have captured it.
    for (RelocSection& section : reloc_sections_) {
      if (section.section_index == section_count_) {
        assert(last_section_type_ == BinarySection::Code);
        --section.section_index;
      }
    }
  }

  WriteCodeMetadataSections();

  if (module_->data_segments.size()) {
    BeginKnownSection(BinarySection::Data);
    WriteU32Leb128(stream_, module_->data_segments.size(), "num data segments");
    for (size_t i = 0; i < module_->data_segments.size(); ++i) {
      const DataSegment* segment = module_->data_segments[i];
      WriteHeader("data segment header", i);
      uint8_t flags = segment->GetFlags(module_);
      stream_->WriteU8(flags, "segment flags");
      if (!(flags & SegPassive)) {
        if (options_.features.multi_memory_enabled() &&
            (flags & SegExplicitIndex)) {
          WriteU32Leb128(stream_, module_->GetMemoryIndex(segment->memory_var),
                         "memidx");
        } else {
          assert(module_->GetMemoryIndex(segment->memory_var) == 0);
        }
        WriteInitExpr(segment->offset);
      }
      WriteU32Leb128(stream_, segment->data.size(), "data segment size");
      WriteHeader("data segment data", i);
      stream_->WriteData(segment->data, "data segment data");
    }
    EndSection();
  }

  for (const Custom& custom : module_->customs) {
    // These custom sections are already specially handled by BinaryWriter, so
    // we don't want to double-write.
    if ((custom.name == WABT_BINARY_SECTION_NAME &&
         options_.write_debug_names) ||
        (custom.name.rfind(WABT_BINARY_SECTION_RELOC) == 0 &&
         options_.relocatable) ||
        (custom.name == WABT_BINARY_SECTION_LINKING && options_.relocatable) ||
        (custom.name.find(WABT_BINARY_SECTION_CODE_METADATA) == 0 &&
         options_.features.code_metadata_enabled())) {
      continue;
    }
    BeginCustomSection(custom.name.data());
    stream_->WriteData(custom.data, "custom data");
    EndSection();
  }

  if (options_.write_debug_names) {
    std::vector<std::string> index_to_name;

    char desc[100];
    BeginCustomSection(WABT_BINARY_SECTION_NAME);

    if (!module_->name.empty()) {
      WriteU32Leb128(stream_, NameSectionSubsection::Module,
                     "module name type");
      BeginSubsection("module name subsection");
      WriteDebugName(stream_, module_->name, "module name");
      EndSubsection();
    }

    WriteNames<Func>(module_->funcs, NameSectionSubsection::Function);

    WriteU32Leb128(stream_, 2, "local name type");

    BeginSubsection("local name subsection");
    WriteU32Leb128(stream_, module_->funcs.size(), "num functions");
    for (size_t i = 0; i < module_->funcs.size(); ++i) {
      const Func* func = module_->funcs[i];
      Index num_params_and_locals = func->GetNumParamsAndLocals();
      MakeTypeBindingReverseMapping(num_params_and_locals, func->bindings,
                                    &index_to_name);
      Index num_named = 0;
      for (auto s : index_to_name) {
        if (!s.empty()) {
          num_named++;
        }
      }

      WriteU32Leb128(stream_, i, "function index");
      WriteU32Leb128(stream_, num_named, "num locals");

      for (size_t j = 0; j < num_params_and_locals; ++j) {
        const std::string& name = index_to_name[j];
        if (!name.empty()) {
          wabt_snprintf(desc, sizeof(desc), "local name %" PRIzd, j);
          WriteU32Leb128(stream_, j, "local index");
          WriteDebugName(stream_, name, desc);
        }
      }
    }
    EndSubsection();

    WriteNames<TypeEntry>(module_->types, NameSectionSubsection::Type);
    WriteNames<Table>(module_->tables, NameSectionSubsection::Table);
    WriteNames<Memory>(module_->memories, NameSectionSubsection::Memory);
    WriteNames<Global>(module_->globals, NameSectionSubsection::Global);
    WriteNames<ElemSegment>(module_->elem_segments,
                            NameSectionSubsection::ElemSegment);
    WriteNames<DataSegment>(module_->data_segments,
                            NameSectionSubsection::DataSegment);
    WriteNames<Tag>(module_->tags, NameSectionSubsection::Tag);

    EndSection();
  }

  if (options_.relocatable) {
    WriteLinkingSection();
    for (RelocSection& section : reloc_sections_) {
      WriteRelocSection(§ion);
    }
  }

  return stream_->result();
}

void BinaryWriter::WriteCodeMetadataSections() {
  if (code_metadata_sections_.empty())
    return;

  section_count_ -= 1;
  // We have to increment the code section's index; adjust anything
  // that might have captured it.
  for (RelocSection& section : reloc_sections_) {
    if (section.section_index == section_count_) {
      assert(last_section_type_ == BinarySection::Code);
      section.section_index += code_metadata_sections_.size();
    }
  }

  MemoryStream tmp_stream;
  Stream* main_stream = stream_;
  stream_ = &tmp_stream;
  for (auto& s : code_metadata_sections_) {
    std::string name = "metadata.code.";
    name.append(s.first);
    auto& section = s.second;
    BeginCustomSection(name.c_str());
    WriteU32Leb128(stream_, section.entries.size(), "function count");
    for (auto& f : section.entries) {
      WriteU32Leb128WithReloc(f.func_idx, "function index",
                              RelocType::FuncIndexLEB);
      WriteU32Leb128(stream_, f.entries.size(), "instances count");
      for (auto& a : f.entries) {
        WriteU32Leb128(stream_, a.offset, "code offset");
        WriteU32Leb128(stream_, a.data.size(), "data length");
        stream_->WriteData(a.data.data(), a.data.size(), "data",
                           PrintChars::Yes);
      }
    }
    EndSection();
  }
  stream_ = main_stream;
  auto buf = tmp_stream.ReleaseOutputBuffer();
  stream_->MoveData(code_start_ + buf->data.size(), code_start_,
                    stream_->offset() - code_start_);
  stream_->WriteDataAt(code_start_, buf->data.data(), buf->data.size());
  stream_->AddOffset(buf->data.size());
  code_start_ += buf->data.size();
  section_count_ += 1;
  last_section_type_ = BinarySection::Code;
}

}  // end anonymous namespace

Result WriteBinaryModule(Stream* stream,
                         const Module* module,
                         const WriteBinaryOptions& options) {
  BinaryWriter binary_writer(stream, options, module);
  return binary_writer.WriteModule();
}

}  // namespace wabt