Use Index/Address/Offset instead of uint32_t (#433)

An `Index` is an index into one of the WebAssembly index spaces. It also
is used for counts for these spaces, as well as parameter counts and
result counts.

An `Address` is an index into linear memory, or the size of a data
region in linear memory.

An `Offset` is an offset into the host's file or memory buffer.

This fixes issue #322.

1 files changed, 339 insertions, 339 deletions

diff --git a/src/binary-reader-interpreter.cc b/src/binary-reader-interpreter.cc
index 95508acc..0c2396ff 100644
--- a/src/binary-reader-interpreter.cc
+++ b/src/binary-reader-interpreter.cc
@@ -38,221 +38,225 @@ namespace wabt {
 
 namespace {
 
-typedef std::vector<uint32_t> Uint32Vector;
-typedef std::vector<Uint32Vector> Uint32VectorVector;
+typedef std::vector<Index> IndexVector;
+typedef std::vector<IstreamOffset> IstreamOffsetVector;
+typedef std::vector<IstreamOffsetVector> IstreamOffsetVectorVector;
 
 struct Label {
-  Label(uint32_t offset, uint32_t fixup_offset);
+  Label(IstreamOffset offset, IstreamOffset fixup_offset);
 
-  uint32_t offset; /* branch location in the istream */
-  uint32_t fixup_offset;
+  IstreamOffset offset;
+  IstreamOffset fixup_offset;
 };
 
-Label::Label(uint32_t offset, uint32_t fixup_offset)
+Label::Label(IstreamOffset offset, IstreamOffset fixup_offset)
     : offset(offset), fixup_offset(fixup_offset) {}
 
 struct ElemSegmentInfo {
-  ElemSegmentInfo(uint32_t* dst, uint32_t func_index)
+  ElemSegmentInfo(Index* dst, Index func_index)
       : dst(dst), func_index(func_index) {}
 
-  uint32_t* dst;
-  uint32_t func_index;
+  Index* dst;
+  Index func_index;
 };
 
 struct DataSegmentInfo {
-  DataSegmentInfo(void* dst_data, const void* src_data, uint32_t size)
+  DataSegmentInfo(void* dst_data, const void* src_data, IstreamOffset size)
       : dst_data(dst_data), src_data(src_data), size(size) {}
 
   void* dst_data;        // Not owned.
   const void* src_data;  // Not owned.
-  uint32_t size;
+  IstreamOffset size;
 };
 
 class BinaryReaderInterpreter : public BinaryReaderNop {
  public:
   BinaryReaderInterpreter(InterpreterEnvironment* env,
                           DefinedInterpreterModule* module,
-                          size_t istream_offset,
+                          IstreamOffset istream_offset,
                           BinaryErrorHandler* error_handler);
 
   std::unique_ptr<OutputBuffer> ReleaseOutputBuffer();
-  size_t get_istream_offset() { return istream_offset; }
+  IstreamOffset get_istream_offset() { return istream_offset; }
 
   // Implement BinaryReader.
-  virtual bool OnError(const char* message);
-
-  virtual Result EndModule();
-
-  virtual Result OnTypeCount(uint32_t count);
-  virtual Result OnType(uint32_t index,
-                        uint32_t param_count,
-                        Type* param_types,
-                        uint32_t result_count,
-                        Type* result_types);
-
-  virtual Result OnImportCount(uint32_t count);
-  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 OnImportTable(uint32_t import_index,
-                               StringSlice module_name,
-                               StringSlice field_name,
-                               uint32_t table_index,
-                               Type elem_type,
-                               const Limits* elem_limits);
-  virtual Result OnImportMemory(uint32_t import_index,
-                                StringSlice module_name,
-                                StringSlice field_name,
-                                uint32_t memory_index,
-                                const Limits* page_limits);
-  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 OnFunction(uint32_t index, uint32_t sig_index);
-
-  virtual Result OnTable(uint32_t index,
-                         Type elem_type,
-                         const Limits* elem_limits);
-
-  virtual Result OnMemory(uint32_t index, const Limits* limits);
-
-  virtual Result OnGlobalCount(uint32_t count);
-  virtual Result BeginGlobal(uint32_t index, Type type, bool mutable_);
-  virtual Result EndGlobalInitExpr(uint32_t index);
-
-  virtual Result OnExport(uint32_t index,
-                          ExternalKind kind,
-                          uint32_t item_index,
-                          StringSlice name);
-
-  virtual Result OnStartFunction(uint32_t func_index);
-
-  virtual Result BeginFunctionBody(uint32_t index);
-  virtual Result OnLocalDeclCount(uint32_t count);
-  virtual Result OnLocalDecl(uint32_t decl_index, uint32_t count, Type type);
-
-  virtual Result OnBinaryExpr(Opcode opcode);
-  virtual Result OnBlockExpr(uint32_t num_types, Type* sig_types);
-  virtual Result OnBrExpr(uint32_t depth);
-  virtual Result OnBrIfExpr(uint32_t depth);
-  virtual Result OnBrTableExpr(uint32_t num_targets,
-                               uint32_t* target_depths,
-                               uint32_t default_target_depth);
-  virtual Result OnCallExpr(uint32_t func_index);
-  virtual Result OnCallIndirectExpr(uint32_t sig_index);
-  virtual Result OnCompareExpr(Opcode opcode);
-  virtual Result OnConvertExpr(Opcode opcode);
-  virtual Result OnCurrentMemoryExpr();
-  virtual Result OnDropExpr();
-  virtual Result OnElseExpr();
-  virtual Result OnEndExpr();
-  virtual Result OnF32ConstExpr(uint32_t value_bits);
-  virtual Result OnF64ConstExpr(uint64_t value_bits);
-  virtual Result OnGetGlobalExpr(uint32_t global_index);
-  virtual Result OnGetLocalExpr(uint32_t local_index);
-  virtual Result OnGrowMemoryExpr();
-  virtual Result OnI32ConstExpr(uint32_t value);
-  virtual Result OnI64ConstExpr(uint64_t value);
-  virtual Result OnIfExpr(uint32_t num_types, Type* sig_types);
-  virtual Result OnLoadExpr(Opcode opcode,
-                            uint32_t alignment_log2,
-                            uint32_t offset);
-  virtual Result OnLoopExpr(uint32_t num_types, Type* sig_types);
-  virtual Result OnNopExpr();
-  virtual Result OnReturnExpr();
-  virtual Result OnSelectExpr();
-  virtual Result OnSetGlobalExpr(uint32_t global_index);
-  virtual Result OnSetLocalExpr(uint32_t local_index);
-  virtual Result OnStoreExpr(Opcode opcode,
-                             uint32_t alignment_log2,
-                             uint32_t offset);
-  virtual Result OnTeeLocalExpr(uint32_t local_index);
-  virtual Result OnUnaryExpr(Opcode opcode);
-  virtual Result OnUnreachableExpr();
-  virtual Result EndFunctionBody(uint32_t index);
-
-  virtual Result EndElemSegmentInitExpr(uint32_t index);
-  virtual Result OnElemSegmentFunctionIndex(uint32_t index,
-                                            uint32_t func_index);
-
-  virtual Result OnDataSegmentData(uint32_t index,
-                                   const void* data,
-                                   uint32_t size);
-
-  virtual Result OnInitExprF32ConstExpr(uint32_t index, uint32_t value);
-  virtual Result OnInitExprF64ConstExpr(uint32_t index, uint64_t value);
-  virtual Result OnInitExprGetGlobalExpr(uint32_t index, uint32_t global_index);
-  virtual Result OnInitExprI32ConstExpr(uint32_t index, uint32_t value);
-  virtual Result OnInitExprI64ConstExpr(uint32_t index, uint64_t value);
+  bool OnError(const char* message) override;
+
+  Result EndModule() override;
+
+  Result OnTypeCount(Index count) override;
+  Result OnType(Index index,
+                Index param_count,
+                Type* param_types,
+                Index result_count,
+                Type* result_types) override;
+
+  Result OnImportCount(Index count) override;
+  Result OnImport(Index index,
+                  StringSlice module_name,
+                  StringSlice field_name) override;
+  Result OnImportFunc(Index import_index,
+                      StringSlice module_name,
+                      StringSlice field_name,
+                      Index func_index,
+                      Index sig_index) override;
+  Result OnImportTable(Index import_index,
+                       StringSlice module_name,
+                       StringSlice field_name,
+                       Index table_index,
+                       Type elem_type,
+                       const Limits* elem_limits) override;
+  Result OnImportMemory(Index import_index,
+                        StringSlice module_name,
+                        StringSlice field_name,
+                        Index memory_index,
+                        const Limits* page_limits) override;
+  Result OnImportGlobal(Index import_index,
+                        StringSlice module_name,
+                        StringSlice field_name,
+                        Index global_index,
+                        Type type,
+                        bool mutable_) override;
+
+  Result OnFunctionCount(Index count) override;
+  Result OnFunction(Index index, Index sig_index) override;
+
+  Result OnTable(Index index,
+                 Type elem_type,
+                 const Limits* elem_limits) override;
+
+  Result OnMemory(Index index, const Limits* limits) override;
+
+  Result OnGlobalCount(Index count) override;
+  Result BeginGlobal(Index index, Type type, bool mutable_) override;
+  Result EndGlobalInitExpr(Index index) override;
+
+  Result OnExport(Index index,
+                  ExternalKind kind,
+                  Index item_index,
+                  StringSlice name) override;
+
+  Result OnStartFunction(Index func_index) override;
+
+  Result BeginFunctionBody(Index index) override;
+  Result OnLocalDeclCount(Index count) override;
+  Result OnLocalDecl(Index decl_index, Index count, Type type) override;
+
+  Result OnBinaryExpr(Opcode opcode) override;
+  Result OnBlockExpr(Index num_types, Type* sig_types) override;
+  Result OnBrExpr(Index depth) override;
+  Result OnBrIfExpr(Index depth) override;
+  Result OnBrTableExpr(Index num_targets,
+                       Index* target_depths,
+                       Index default_target_depth) override;
+  Result OnCallExpr(Index func_index) override;
+  Result OnCallIndirectExpr(Index sig_index) override;
+  Result OnCompareExpr(Opcode opcode) override;
+  Result OnConvertExpr(Opcode opcode) override;
+  Result OnCurrentMemoryExpr() override;
+  Result OnDropExpr() override;
+  Result OnElseExpr() override;
+  Result OnEndExpr() override;
+  Result OnF32ConstExpr(uint32_t value_bits) override;
+  Result OnF64ConstExpr(uint64_t value_bits) override;
+  Result OnGetGlobalExpr(Index global_index) override;
+  Result OnGetLocalExpr(Index local_index) override;
+  Result OnGrowMemoryExpr() override;
+  Result OnI32ConstExpr(uint32_t value) override;
+  Result OnI64ConstExpr(uint64_t value) override;
+  Result OnIfExpr(Index num_types, Type* sig_types) override;
+  Result OnLoadExpr(Opcode opcode,
+                    uint32_t alignment_log2,
+                    Address offset) override;
+  Result OnLoopExpr(Index num_types, Type* sig_types) override;
+  Result OnNopExpr() override;
+  Result OnReturnExpr() override;
+  Result OnSelectExpr() override;
+  Result OnSetGlobalExpr(Index global_index) override;
+  Result OnSetLocalExpr(Index local_index) override;
+  Result OnStoreExpr(Opcode opcode,
+                     uint32_t alignment_log2,
+                     Address offset) override;
+  Result OnTeeLocalExpr(Index local_index) override;
+  Result OnUnaryExpr(Opcode opcode) override;
+  Result OnUnreachableExpr() override;
+  Result EndFunctionBody(Index index) override;
+
+  Result EndElemSegmentInitExpr(Index index) override;
+  Result OnElemSegmentFunctionIndex(Index index,
+                                    Index func_index) override;
+
+  Result OnDataSegmentData(Index index,
+                           const void* data,
+                           Address size) override;
+
+  Result OnInitExprF32ConstExpr(Index index, uint32_t value) override;
+  Result OnInitExprF64ConstExpr(Index index, uint64_t value) override;
+  Result OnInitExprGetGlobalExpr(Index index,
+                                 Index global_index) override;
+  Result OnInitExprI32ConstExpr(Index index, uint32_t value) override;
+  Result OnInitExprI64ConstExpr(Index index, uint64_t value) override;
 
  private:
-  Label* GetLabel(uint32_t depth);
+  Label* GetLabel(Index depth);
   Label* TopLabel();
-  void PushLabel(uint32_t offset, uint32_t fixup_offset);
+  void PushLabel(IstreamOffset offset, IstreamOffset fixup_offset);
   void PopLabel();
 
-  bool HandleError(uint32_t offset, const char* message);
+  bool HandleError(Offset offset, const char* message);
   void PrintError(const char* format, ...);
   static void OnTypecheckerError(const char* msg, void* user_data);
 
-  uint32_t TranslateSigIndexToEnv(uint32_t sig_index);
-  InterpreterFuncSignature* GetSignatureByEnvIndex(uint32_t sig_index);
-  InterpreterFuncSignature* GetSignatureByModuleIndex(uint32_t sig_index);
-  uint32_t TranslateFuncIndexToEnv(uint32_t func_index);
-  uint32_t TranslateModuleFuncIndexToDefined(uint32_t func_index);
-  InterpreterFunc* GetFuncByEnvIndex(uint32_t func_index);
-  InterpreterFunc* GetFuncByModuleIndex(uint32_t func_index);
-  uint32_t TranslateGlobalIndexToEnv(uint32_t global_index);
-  InterpreterGlobal* GetGlobalByEnvIndex(uint32_t global_index);
-  InterpreterGlobal* GetGlobalByModuleIndex(uint32_t global_index);
-  Type GetGlobalTypeByModuleIndex(uint32_t global_index);
-  uint32_t TranslateLocalIndex(uint32_t local_index);
-  Type GetLocalTypeByIndex(InterpreterFunc* func, uint32_t local_index);
-
-  uint32_t GetIstreamOffset();
-
-  Result EmitDataAt(size_t offset, const void* data, size_t size);
-  Result EmitData(const void* data, size_t size);
+  Index TranslateSigIndexToEnv(Index sig_index);
+  InterpreterFuncSignature* GetSignatureByEnvIndex(Index sig_index);
+  InterpreterFuncSignature* GetSignatureByModuleIndex(Index sig_index);
+  Index TranslateFuncIndexToEnv(Index func_index);
+  Index TranslateModuleFuncIndexToDefined(Index func_index);
+  InterpreterFunc* GetFuncByEnvIndex(Index func_index);
+  InterpreterFunc* GetFuncByModuleIndex(Index func_index);
+  Index TranslateGlobalIndexToEnv(Index global_index);
+  InterpreterGlobal* GetGlobalByEnvIndex(Index global_index);
+  InterpreterGlobal* GetGlobalByModuleIndex(Index global_index);
+  Type GetGlobalTypeByModuleIndex(Index global_index);
+  Index TranslateLocalIndex(Index local_index);
+  Type GetLocalTypeByIndex(InterpreterFunc* func, Index local_index);
+
+  IstreamOffset GetIstreamOffset();
+
+  Result EmitDataAt(IstreamOffset offset,
+                    const void* data,
+                    IstreamOffset size);
+  Result EmitData(const void* data, IstreamOffset size);
   Result EmitOpcode(Opcode opcode);
   Result EmitOpcode(InterpreterOpcode opcode);
   Result EmitI8(uint8_t value);
   Result EmitI32(uint32_t value);
   Result EmitI64(uint64_t value);
-  Result EmitI32At(uint32_t offset, uint32_t value);
+  Result EmitI32At(IstreamOffset offset, uint32_t value);
   Result EmitDropKeep(uint32_t drop, uint8_t keep);
-  Result AppendFixup(Uint32VectorVector* fixups_vector, uint32_t index);
-  Result EmitBrOffset(uint32_t depth, uint32_t offset);
-  Result GetBrDropKeepCount(uint32_t depth,
-                            uint32_t* out_drop_count,
-                            uint32_t* out_keep_count);
-  Result GetReturnDropKeepCount(uint32_t* out_drop_count,
-                                uint32_t* out_keep_count);
-  Result EmitBr(uint32_t depth, uint32_t drop_count, uint32_t keep_count);
-  Result EmitBrTableOffset(uint32_t depth);
+  Result AppendFixup(IstreamOffsetVectorVector* fixups_vector, Index index);
+  Result EmitBrOffset(Index depth, IstreamOffset offset);
+  Result GetBrDropKeepCount(Index depth,
+                            Index* out_drop_count,
+                            Index* out_keep_count);
+  Result GetReturnDropKeepCount(Index* out_drop_count,
+                                Index* out_keep_count);
+  Result EmitBr(Index depth, Index drop_count, Index keep_count);
+  Result EmitBrTableOffset(Index depth);
   Result FixupTopLabel();
-  Result EmitFuncOffset(DefinedInterpreterFunc* func, uint32_t func_index);
+  Result EmitFuncOffset(DefinedInterpreterFunc* func, Index func_index);
 
-  Result CheckLocal(uint32_t local_index);
-  Result CheckGlobal(uint32_t global_index);
+  Result CheckLocal(Index local_index);
+  Result CheckGlobal(Index global_index);
   Result CheckImportKind(InterpreterImport* import, ExternalKind expected_kind);
   Result CheckImportLimits(const Limits* declared_limits,
                            const Limits* actual_limits);
   Result CheckHasMemory(Opcode opcode);
-  Result CheckAlign(uint32_t alignment_log2, uint32_t natural_alignment);
+  Result CheckAlign(uint32_t alignment_log2, Address natural_alignment);
 
   Result AppendExport(InterpreterModule* module,
                       ExternalKind kind,
-                      uint32_t item_index,
+                      Index item_index,
                       StringSlice name);
 
   PrintErrorCallback MakePrintErrorCallback();
@@ -265,18 +269,18 @@ class BinaryReaderInterpreter : public BinaryReaderNop {
   TypeCheckerErrorHandler tc_error_handler;
   TypeChecker typechecker;
   std::vector<Label> label_stack;
-  Uint32VectorVector func_fixups;
-  Uint32VectorVector depth_fixups;
+  IstreamOffsetVectorVector func_fixups;
+  IstreamOffsetVectorVector depth_fixups;
   MemoryWriter istream_writer;
-  uint32_t istream_offset = 0;
+  IstreamOffset istream_offset = 0;
   /* mappings from module index space to env index space; this won't just be a
    * translation, because imported values will be resolved as well */
-  Uint32Vector sig_index_mapping;
-  Uint32Vector func_index_mapping;
-  Uint32Vector global_index_mapping;
+  IndexVector sig_index_mapping;
+  IndexVector func_index_mapping;
+  IndexVector global_index_mapping;
 
-  uint32_t num_func_imports = 0;
-  uint32_t num_global_imports = 0;
+  Index num_func_imports = 0;
+  Index num_global_imports = 0;
 
   // Changes to linear memory and tables should not apply if a validation error
   // occurs; these vectors cache the changes that must be applied after we know
@@ -286,16 +290,16 @@ class BinaryReaderInterpreter : public BinaryReaderNop {
 
   /* values cached so they can be shared between callbacks */
   InterpreterTypedValue init_expr_value;
-  uint32_t table_offset = 0;
+  IstreamOffset table_offset = 0;
   bool is_host_import = false;
   HostInterpreterModule* host_import_module = nullptr;
-  uint32_t import_env_index = 0;
+  Index import_env_index = 0;
 };
 
 BinaryReaderInterpreter::BinaryReaderInterpreter(
     InterpreterEnvironment* env,
     DefinedInterpreterModule* module,
-    size_t istream_offset,
+    IstreamOffset istream_offset,
     BinaryErrorHandler* error_handler)
     : error_handler(error_handler),
       env(env),
@@ -311,7 +315,7 @@ std::unique_ptr<OutputBuffer> BinaryReaderInterpreter::ReleaseOutputBuffer() {
   return istream_writer.ReleaseOutputBuffer();
 }
 
-Label* BinaryReaderInterpreter::GetLabel(uint32_t depth) {
+Label* BinaryReaderInterpreter::GetLabel(Index depth) {
   assert(depth < label_stack.size());
   return &label_stack[label_stack.size() - depth - 1];
 }
@@ -320,15 +324,14 @@ Label* BinaryReaderInterpreter::TopLabel() {
   return GetLabel(0);
 }
 
-bool BinaryReaderInterpreter::HandleError(uint32_t offset,
-                                          const char* message) {
+bool BinaryReaderInterpreter::HandleError(Offset offset, const char* message) {
   return error_handler->OnError(offset, message);
 }
 
 void WABT_PRINTF_FORMAT(2, 3)
     BinaryReaderInterpreter::PrintError(const char* format, ...) {
   WABT_SNPRINTF_ALLOCA(buffer, length, format);
-  HandleError(WABT_INVALID_OFFSET, buffer);
+  HandleError(kInvalidOffset, buffer);
 }
 
 // static
@@ -337,79 +340,77 @@ void BinaryReaderInterpreter::OnTypecheckerError(const char* msg,
   static_cast<BinaryReaderInterpreter*>(user_data)->PrintError("%s", msg);
 }
 
-uint32_t BinaryReaderInterpreter::TranslateSigIndexToEnv(uint32_t sig_index) {
+Index BinaryReaderInterpreter::TranslateSigIndexToEnv(Index sig_index) {
   assert(sig_index < sig_index_mapping.size());
   return sig_index_mapping[sig_index];
 }
 
 InterpreterFuncSignature* BinaryReaderInterpreter::GetSignatureByEnvIndex(
-    uint32_t sig_index) {
+    Index sig_index) {
   return &env->sigs[sig_index];
 }
 
 InterpreterFuncSignature* BinaryReaderInterpreter::GetSignatureByModuleIndex(
-    uint32_t sig_index) {
+    Index sig_index) {
   return GetSignatureByEnvIndex(TranslateSigIndexToEnv(sig_index));
 }
 
-uint32_t BinaryReaderInterpreter::TranslateFuncIndexToEnv(uint32_t func_index) {
+Index BinaryReaderInterpreter::TranslateFuncIndexToEnv(Index func_index) {
   assert(func_index < func_index_mapping.size());
   return func_index_mapping[func_index];
 }
 
-uint32_t BinaryReaderInterpreter::TranslateModuleFuncIndexToDefined(
-    uint32_t func_index) {
+Index BinaryReaderInterpreter::TranslateModuleFuncIndexToDefined(
+    Index func_index) {
   assert(func_index >= num_func_imports);
   return func_index - num_func_imports;
 }
 
 InterpreterFunc* BinaryReaderInterpreter::GetFuncByEnvIndex(
-    uint32_t func_index) {
+    Index func_index) {
   return env->funcs[func_index].get();
 }
 
 InterpreterFunc* BinaryReaderInterpreter::GetFuncByModuleIndex(
-    uint32_t func_index) {
+    Index func_index) {
   return GetFuncByEnvIndex(TranslateFuncIndexToEnv(func_index));
 }
 
-uint32_t BinaryReaderInterpreter::TranslateGlobalIndexToEnv(
-    uint32_t global_index) {
+Index BinaryReaderInterpreter::TranslateGlobalIndexToEnv(Index global_index) {
   return global_index_mapping[global_index];
 }
 
 InterpreterGlobal* BinaryReaderInterpreter::GetGlobalByEnvIndex(
-    uint32_t global_index) {
+    Index global_index) {
   return &env->globals[global_index];
 }
 
 InterpreterGlobal* BinaryReaderInterpreter::GetGlobalByModuleIndex(
-    uint32_t global_index) {
+    Index global_index) {
   return GetGlobalByEnvIndex(TranslateGlobalIndexToEnv(global_index));
 }
 
-Type BinaryReaderInterpreter::GetGlobalTypeByModuleIndex(
-    uint32_t global_index) {
+Type BinaryReaderInterpreter::GetGlobalTypeByModuleIndex(Index global_index) {
   return GetGlobalByModuleIndex(global_index)->typed_value.type;
 }
 
 Type BinaryReaderInterpreter::GetLocalTypeByIndex(InterpreterFunc* func,
-                                                  uint32_t local_index) {
+                                                  Index local_index) {
   assert(!func->is_host);
   return func->as_defined()->param_and_local_types[local_index];
 }
 
-uint32_t BinaryReaderInterpreter::GetIstreamOffset() {
+IstreamOffset BinaryReaderInterpreter::GetIstreamOffset() {
   return istream_offset;
 }
 
-Result BinaryReaderInterpreter::EmitDataAt(size_t offset,
+Result BinaryReaderInterpreter::EmitDataAt(IstreamOffset offset,
                                            const void* data,
-                                           size_t size) {
+                                           IstreamOffset size) {
   return istream_writer.WriteData(offset, data, size);
 }
 
-Result BinaryReaderInterpreter::EmitData(const void* data, size_t size) {
+Result BinaryReaderInterpreter::EmitData(const void* data, IstreamOffset size) {
   CHECK_RESULT(EmitDataAt(istream_offset, data, size));
   istream_offset += size;
   return Result::Ok;
@@ -435,7 +436,8 @@ Result BinaryReaderInterpreter::EmitI64(uint64_t value) {
   return EmitData(&value, sizeof(value));
 }
 
-Result BinaryReaderInterpreter::EmitI32At(uint32_t offset, uint32_t value) {
+Result BinaryReaderInterpreter::EmitI32At(IstreamOffset offset,
+                                          uint32_t value) {
   return EmitDataAt(offset, &value, sizeof(value));
 }
 
@@ -454,16 +456,18 @@ Result BinaryReaderInterpreter::EmitDropKeep(uint32_t drop, uint8_t keep) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::AppendFixup(Uint32VectorVector* fixups_vector,
-                                            uint32_t index) {
+Result BinaryReaderInterpreter::AppendFixup(
+    IstreamOffsetVectorVector* fixups_vector,
+    Index index) {
   if (index >= fixups_vector->size())
     fixups_vector->resize(index + 1);
   (*fixups_vector)[index].push_back(GetIstreamOffset());
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::EmitBrOffset(uint32_t depth, uint32_t offset) {
-  if (offset == WABT_INVALID_OFFSET) {
+Result BinaryReaderInterpreter::EmitBrOffset(Index depth,
+                                             IstreamOffset offset) {
+  if (offset == kInvalidIstreamOffset) {
     /* depth_fixups stores the depth counting up from zero, where zero is the
      * top-level function scope. */
     depth = label_stack.size() - 1 - depth;
@@ -473,9 +477,9 @@ Result BinaryReaderInterpreter::EmitBrOffset(uint32_t depth, uint32_t offset) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::GetBrDropKeepCount(uint32_t depth,
-                                                   uint32_t* out_drop_count,
-                                                   uint32_t* out_keep_count) {
+Result BinaryReaderInterpreter::GetBrDropKeepCount(Index depth,
+                                                   Index* out_drop_count,
+                                                   Index* out_keep_count) {
   TypeCheckerLabel* label;
   CHECK_RESULT(typechecker_get_label(&typechecker, depth, &label));
   *out_keep_count =
@@ -490,9 +494,8 @@ Result BinaryReaderInterpreter::GetBrDropKeepCount(uint32_t depth,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::GetReturnDropKeepCount(
-    uint32_t* out_drop_count,
-    uint32_t* out_keep_count) {
+Result BinaryReaderInterpreter::GetReturnDropKeepCount(Index* out_drop_count,
+                                                       Index* out_keep_count) {
   if (WABT_FAILED(GetBrDropKeepCount(label_stack.size() - 1, out_drop_count,
                                      out_keep_count))) {
     return Result::Error;
@@ -502,17 +505,17 @@ Result BinaryReaderInterpreter::GetReturnDropKeepCount(
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::EmitBr(uint32_t depth,
-                                       uint32_t drop_count,
-                                       uint32_t keep_count) {
+Result BinaryReaderInterpreter::EmitBr(Index depth,
+                                       Index drop_count,
+                                       Index keep_count) {
   CHECK_RESULT(EmitDropKeep(drop_count, keep_count));
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::Br));
   CHECK_RESULT(EmitBrOffset(depth, GetLabel(depth)->offset));
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::EmitBrTableOffset(uint32_t depth) {
-  uint32_t drop_count, keep_count;
+Result BinaryReaderInterpreter::EmitBrTableOffset(Index depth) {
+  Index drop_count, keep_count;
   CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count));
   CHECK_RESULT(EmitBrOffset(depth, GetLabel(depth)->offset));
   CHECK_RESULT(EmitI32(drop_count));
@@ -521,24 +524,24 @@ Result BinaryReaderInterpreter::EmitBrTableOffset(uint32_t depth) {
 }
 
 Result BinaryReaderInterpreter::FixupTopLabel() {
-  uint32_t offset = GetIstreamOffset();
-  uint32_t top = label_stack.size() - 1;
+  IstreamOffset offset = GetIstreamOffset();
+  Index top = label_stack.size() - 1;
   if (top >= depth_fixups.size()) {
     /* nothing to fixup */
     return Result::Ok;
   }
 
-  Uint32Vector& fixups = depth_fixups[top];
-  for (uint32_t fixup : fixups)
+  IstreamOffsetVector& fixups = depth_fixups[top];
+  for (IstreamOffset fixup : fixups)
     CHECK_RESULT(EmitI32At(fixup, offset));
   fixups.clear();
   return Result::Ok;
 }
 
 Result BinaryReaderInterpreter::EmitFuncOffset(DefinedInterpreterFunc* func,
-                                               uint32_t func_index) {
-  if (func->offset == WABT_INVALID_OFFSET) {
-    uint32_t defined_index = TranslateModuleFuncIndexToDefined(func_index);
+                                               Index func_index) {
+  if (func->offset == kInvalidIstreamOffset) {
+    Index defined_index = TranslateModuleFuncIndexToDefined(func_index);
     CHECK_RESULT(AppendFixup(&func_fixups, defined_index));
   }
   CHECK_RESULT(EmitI32(func->offset));
@@ -549,18 +552,18 @@ bool BinaryReaderInterpreter::OnError(const char* message) {
   return HandleError(state->offset, message);
 }
 
-Result BinaryReaderInterpreter::OnTypeCount(uint32_t count) {
+Result BinaryReaderInterpreter::OnTypeCount(Index count) {
   sig_index_mapping.resize(count);
-  for (uint32_t i = 0; i < count; ++i)
+  for (Index i = 0; i < count; ++i)
     sig_index_mapping[i] = env->sigs.size() + i;
   env->sigs.resize(env->sigs.size() + count);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnType(uint32_t index,
-                                       uint32_t param_count,
+Result BinaryReaderInterpreter::OnType(Index index,
+                                       Index param_count,
                                        Type* param_types,
-                                       uint32_t result_count,
+                                       Index result_count,
                                        Type* result_types) {
   InterpreterFuncSignature* sig = GetSignatureByModuleIndex(index);
   sig->param_types.insert(sig->param_types.end(), param_types,
@@ -570,12 +573,12 @@ Result BinaryReaderInterpreter::OnType(uint32_t index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnImportCount(uint32_t count) {
+Result BinaryReaderInterpreter::OnImportCount(Index count) {
   module->imports.resize(count);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnImport(uint32_t index,
+Result BinaryReaderInterpreter::OnImport(Index index,
                                          StringSlice module_name,
                                          StringSlice field_name) {
   InterpreterImport* import = &module->imports[index];
@@ -612,21 +615,21 @@ Result BinaryReaderInterpreter::OnImport(uint32_t index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::CheckLocal(uint32_t local_index) {
-  uint32_t max_local_index = current_func->param_and_local_types.size();
+Result BinaryReaderInterpreter::CheckLocal(Index local_index) {
+  Index max_local_index = current_func->param_and_local_types.size();
   if (local_index >= max_local_index) {
-    PrintError("invalid local_index: %d (max %d)", local_index,
-               max_local_index);
+    PrintError("invalid local_index: %" PRIindex " (max %" PRIindex ")",
+               local_index, max_local_index);
     return Result::Error;
   }
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::CheckGlobal(uint32_t global_index) {
-  uint32_t max_global_index = global_index_mapping.size();
+Result BinaryReaderInterpreter::CheckGlobal(Index global_index) {
+  Index max_global_index = global_index_mapping.size();
   if (global_index >= max_global_index) {
-    PrintError("invalid global_index: %d (max %d)", global_index,
-               max_global_index);
+    PrintError("invalid global_index: %" PRIindex " (max %" PRIindex ")",
+               global_index, max_global_index);
     return Result::Error;
   }
   return Result::Ok;
@@ -670,7 +673,7 @@ Result BinaryReaderInterpreter::CheckImportLimits(const Limits* declared_limits,
 
 Result BinaryReaderInterpreter::AppendExport(InterpreterModule* module,
                                              ExternalKind kind,
-                                             uint32_t item_index,
+                                             Index item_index,
                                              StringSlice name) {
   if (module->export_bindings.find_index(name) != -1) {
     PrintError("duplicate export \"" PRIstringslice "\"",
@@ -699,15 +702,15 @@ PrintErrorCallback BinaryReaderInterpreter::MakePrintErrorCallback() {
   return result;
 }
 
-Result BinaryReaderInterpreter::OnImportFunc(uint32_t import_index,
+Result BinaryReaderInterpreter::OnImportFunc(Index import_index,
                                              StringSlice module_name,
                                              StringSlice field_name,
-                                             uint32_t func_index,
-                                             uint32_t sig_index) {
+                                             Index func_index,
+                                             Index sig_index) {
   InterpreterImport* import = &module->imports[import_index];
   import->func.sig_index = TranslateSigIndexToEnv(sig_index);
 
-  uint32_t func_env_index;
+  Index func_env_index;
   if (is_host_import) {
     HostInterpreterFunc* func = new HostInterpreterFunc(
         import->module_name, import->field_name, import->func.sig_index);
@@ -740,13 +743,13 @@ Result BinaryReaderInterpreter::OnImportFunc(uint32_t import_index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnImportTable(uint32_t import_index,
+Result BinaryReaderInterpreter::OnImportTable(Index import_index,
                                               StringSlice module_name,
                                               StringSlice field_name,
-                                              uint32_t table_index,
+                                              Index table_index,
                                               Type elem_type,
                                               const Limits* elem_limits) {
-  if (module->table_index != WABT_INVALID_INDEX) {
+  if (module->table_index != kInvalidIndex) {
     PrintError("only one table allowed");
     return Result::Error;
   }
@@ -778,12 +781,12 @@ Result BinaryReaderInterpreter::OnImportTable(uint32_t import_index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnImportMemory(uint32_t import_index,
+Result BinaryReaderInterpreter::OnImportMemory(Index import_index,
                                                StringSlice module_name,
                                                StringSlice field_name,
-                                               uint32_t memory_index,
+                                               Index memory_index,
                                                const Limits* page_limits) {
-  if (module->memory_index != WABT_INVALID_INDEX) {
+  if (module->memory_index != kInvalidIndex) {
     PrintError("only one memory allowed");
     return Result::Error;
   }
@@ -815,15 +818,15 @@ Result BinaryReaderInterpreter::OnImportMemory(uint32_t import_index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnImportGlobal(uint32_t import_index,
+Result BinaryReaderInterpreter::OnImportGlobal(Index import_index,
                                                StringSlice module_name,
                                                StringSlice field_name,
-                                               uint32_t global_index,
+                                               Index global_index,
                                                Type type,
                                                bool mutable_) {
   InterpreterImport* import = &module->imports[import_index];
 
-  uint32_t global_env_index = env->globals.size() - 1;
+  Index global_env_index = env->globals.size() - 1;
   if (is_host_import) {
     env->globals.emplace_back(InterpreterTypedValue(type), mutable_);
     InterpreterGlobal* global = &env->globals.back();
@@ -848,25 +851,25 @@ Result BinaryReaderInterpreter::OnImportGlobal(uint32_t import_index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnFunctionCount(uint32_t count) {
-  for (uint32_t i = 0; i < count; ++i)
+Result BinaryReaderInterpreter::OnFunctionCount(Index count) {
+  for (Index i = 0; i < count; ++i)
     func_index_mapping.push_back(env->funcs.size() + i);
   env->funcs.reserve(env->funcs.size() + count);
   func_fixups.resize(count);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnFunction(uint32_t index, uint32_t sig_index) {
+Result BinaryReaderInterpreter::OnFunction(Index index, Index sig_index) {
   DefinedInterpreterFunc* func =
       new DefinedInterpreterFunc(TranslateSigIndexToEnv(sig_index));
   env->funcs.emplace_back(func);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnTable(uint32_t index,
+Result BinaryReaderInterpreter::OnTable(Index index,
                                         Type elem_type,
                                         const Limits* elem_limits) {
-  if (module->table_index != WABT_INVALID_INDEX) {
+  if (module->table_index != kInvalidIndex) {
     PrintError("only one table allowed");
     return Result::Error;
   }
@@ -875,9 +878,9 @@ Result BinaryReaderInterpreter::OnTable(uint32_t index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnMemory(uint32_t index,
+Result BinaryReaderInterpreter::OnMemory(Index index,
                                          const Limits* page_limits) {
-  if (module->memory_index != WABT_INVALID_INDEX) {
+  if (module->memory_index != kInvalidIndex) {
     PrintError("only one memory allowed");
     return Result::Error;
   }
@@ -886,14 +889,14 @@ Result BinaryReaderInterpreter::OnMemory(uint32_t index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnGlobalCount(uint32_t count) {
-  for (uint32_t i = 0; i < count; ++i)
+Result BinaryReaderInterpreter::OnGlobalCount(Index count) {
+  for (Index i = 0; i < count; ++i)
     global_index_mapping.push_back(env->globals.size() + i);
   env->globals.resize(env->globals.size() + count);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::BeginGlobal(uint32_t index,
+Result BinaryReaderInterpreter::BeginGlobal(Index index,
                                             Type type,
                                             bool mutable_) {
   InterpreterGlobal* global = GetGlobalByModuleIndex(index);
@@ -903,7 +906,7 @@ Result BinaryReaderInterpreter::BeginGlobal(uint32_t index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::EndGlobalInitExpr(uint32_t index) {
+Result BinaryReaderInterpreter::EndGlobalInitExpr(Index index) {
   InterpreterGlobal* global = GetGlobalByModuleIndex(index);
   if (init_expr_value.type != global->typed_value.type) {
     PrintError("type mismatch in global, expected %s but got %s.",
@@ -915,22 +918,22 @@ Result BinaryReaderInterpreter::EndGlobalInitExpr(uint32_t index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnInitExprF32ConstExpr(uint32_t index,
+Result BinaryReaderInterpreter::OnInitExprF32ConstExpr(Index index,
                                                        uint32_t value_bits) {
   init_expr_value.type = Type::F32;
   init_expr_value.value.f32_bits = value_bits;
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnInitExprF64ConstExpr(uint32_t index,
+Result BinaryReaderInterpreter::OnInitExprF64ConstExpr(Index index,
                                                        uint64_t value_bits) {
   init_expr_value.type = Type::F64;
   init_expr_value.value.f64_bits = value_bits;
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnInitExprGetGlobalExpr(uint32_t index,
-                                                        uint32_t global_index) {
+Result BinaryReaderInterpreter::OnInitExprGetGlobalExpr(Index index,
+                                                        Index global_index) {
   if (global_index >= num_global_imports) {
     PrintError("initializer expression can only reference an imported global");
     return Result::Error;
@@ -944,23 +947,23 @@ Result BinaryReaderInterpreter::OnInitExprGetGlobalExpr(uint32_t index,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnInitExprI32ConstExpr(uint32_t index,
+Result BinaryReaderInterpreter::OnInitExprI32ConstExpr(Index index,
                                                        uint32_t value) {
   init_expr_value.type = Type::I32;
   init_expr_value.value.i32 = value;
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnInitExprI64ConstExpr(uint32_t index,
+Result BinaryReaderInterpreter::OnInitExprI64ConstExpr(Index index,
                                                        uint64_t value) {
   init_expr_value.type = Type::I64;
   init_expr_value.value.i64 = value;
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnExport(uint32_t index,
+Result BinaryReaderInterpreter::OnExport(Index index,
                                          ExternalKind kind,
-                                         uint32_t item_index,
+                                         Index item_index,
                                          StringSlice name) {
   switch (kind) {
     case ExternalKind::Func:
@@ -988,8 +991,8 @@ Result BinaryReaderInterpreter::OnExport(uint32_t index,
   return AppendExport(module, kind, item_index, name);
 }
 
-Result BinaryReaderInterpreter::OnStartFunction(uint32_t func_index) {
-  uint32_t start_func_index = TranslateFuncIndexToEnv(func_index);
+Result BinaryReaderInterpreter::OnStartFunction(Index func_index) {
+  Index start_func_index = TranslateFuncIndexToEnv(func_index);
   InterpreterFunc* start_func = GetFuncByEnvIndex(start_func_index);
   InterpreterFuncSignature* sig = GetSignatureByEnvIndex(start_func->sig_index);
   if (sig->param_types.size() != 0) {
@@ -1004,7 +1007,7 @@ Result BinaryReaderInterpreter::OnStartFunction(uint32_t func_index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::EndElemSegmentInitExpr(uint32_t index) {
+Result BinaryReaderInterpreter::EndElemSegmentInitExpr(Index index) {
   if (init_expr_value.type != Type::I32) {
     PrintError("type mismatch in elem segment, expected i32 but got %s",
                get_type_name(init_expr_value.type));
@@ -1014,11 +1017,9 @@ Result BinaryReaderInterpreter::EndElemSegmentInitExpr(uint32_t index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnElemSegmentFunctionIndex(
-
-    uint32_t index,
-    uint32_t func_index) {
-  assert(module->table_index != WABT_INVALID_INDEX);
+Result BinaryReaderInterpreter::OnElemSegmentFunctionIndex(Index index,
+                                                           Index func_index) {
+  assert(module->table_index != kInvalidIndex);
   InterpreterTable* table = &env->tables[module->table_index];
   if (table_offset >= table->func_indexes.size()) {
     PrintError("elem segment offset is out of bounds: %u >= max value %" PRIzd,
@@ -1026,9 +1027,10 @@ Result BinaryReaderInterpreter::OnElemSegmentFunctionIndex(
     return Result::Error;
   }
 
-  uint32_t max_func_index = func_index_mapping.size();
+  Index max_func_index = func_index_mapping.size();
   if (func_index >= max_func_index) {
-    PrintError("invalid func_index: %d (max %d)", func_index, max_func_index);
+    PrintError("invalid func_index: %" PRIindex " (max %" PRIindex ")",
+               func_index, max_func_index);
     return Result::Error;
   }
 
@@ -1037,21 +1039,21 @@ Result BinaryReaderInterpreter::OnElemSegmentFunctionIndex(
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnDataSegmentData(uint32_t index,
+Result BinaryReaderInterpreter::OnDataSegmentData(Index index,
                                                   const void* src_data,
-                                                  uint32_t size) {
-  assert(module->memory_index != WABT_INVALID_INDEX);
+                                                  Address size) {
+  assert(module->memory_index != kInvalidIndex);
   InterpreterMemory* memory = &env->memories[module->memory_index];
   if (init_expr_value.type != Type::I32) {
     PrintError("type mismatch in data segment, expected i32 but got %s",
                get_type_name(init_expr_value.type));
     return Result::Error;
   }
-  uint32_t address = init_expr_value.value.i32;
+  Address address = init_expr_value.value.i32;
   uint64_t end_address =
       static_cast<uint64_t>(address) + static_cast<uint64_t>(size);
   if (end_address > memory->data.size()) {
-    PrintError("data segment is out of bounds: [%u, %" PRIu64
+    PrintError("data segment is out of bounds: [%" PRIaddress ", %" PRIu64
                ") >= max value %" PRIzd,
                address, end_address, memory->data.size());
     return Result::Error;
@@ -1063,8 +1065,8 @@ Result BinaryReaderInterpreter::OnDataSegmentData(uint32_t index,
   return Result::Ok;
 }
 
-void BinaryReaderInterpreter::PushLabel(uint32_t offset,
-                                        uint32_t fixup_offset) {
+void BinaryReaderInterpreter::PushLabel(IstreamOffset offset,
+                                        IstreamOffset fixup_offset) {
   label_stack.emplace_back(offset, fixup_offset);
 }
 
@@ -1078,7 +1080,7 @@ void BinaryReaderInterpreter::PopLabel() {
   }
 }
 
-Result BinaryReaderInterpreter::BeginFunctionBody(uint32_t index) {
+Result BinaryReaderInterpreter::BeginFunctionBody(Index index) {
   DefinedInterpreterFunc* func = GetFuncByModuleIndex(index)->as_defined();
   InterpreterFuncSignature* sig = GetSignatureByEnvIndex(func->sig_index);
 
@@ -1091,9 +1093,9 @@ Result BinaryReaderInterpreter::BeginFunctionBody(uint32_t index) {
   label_stack.clear();
 
   /* fixup function references */
-  uint32_t defined_index = TranslateModuleFuncIndexToDefined(index);
-  Uint32Vector& fixups = func_fixups[defined_index];
-  for (uint32_t fixup : fixups)
+  Index defined_index = TranslateModuleFuncIndexToDefined(index);
+  IstreamOffsetVector& fixups = func_fixups[defined_index];
+  for (IstreamOffset fixup : fixups)
     CHECK_RESULT(EmitI32At(fixup, func->offset));
 
   /* append param types */
@@ -1103,13 +1105,13 @@ Result BinaryReaderInterpreter::BeginFunctionBody(uint32_t index) {
   CHECK_RESULT(typechecker_begin_function(&typechecker, &sig->result_types));
 
   /* push implicit func label (equivalent to return) */
-  PushLabel(WABT_INVALID_OFFSET, WABT_INVALID_OFFSET);
+  PushLabel(kInvalidIstreamOffset, kInvalidIstreamOffset);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::EndFunctionBody(uint32_t index) {
+Result BinaryReaderInterpreter::EndFunctionBody(Index index) {
   FixupTopLabel();
-  uint32_t drop_count, keep_count;
+  Index drop_count, keep_count;
   CHECK_RESULT(GetReturnDropKeepCount(&drop_count, &keep_count));
   CHECK_RESULT(typechecker_end_function(&typechecker));
   CHECK_RESULT(EmitDropKeep(drop_count, keep_count));
@@ -1119,17 +1121,17 @@ Result BinaryReaderInterpreter::EndFunctionBody(uint32_t index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnLocalDeclCount(uint32_t count) {
+Result BinaryReaderInterpreter::OnLocalDeclCount(Index count) {
   current_func->local_decl_count = count;
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnLocalDecl(uint32_t decl_index,
-                                            uint32_t count,
+Result BinaryReaderInterpreter::OnLocalDecl(Index decl_index,
+                                            Index count,
                                             Type type) {
   current_func->local_count += count;
 
-  for (uint32_t i = 0; i < count; ++i)
+  for (Index i = 0; i < count; ++i)
     current_func->param_and_local_types.push_back(type);
 
   if (decl_index == current_func->local_decl_count - 1) {
@@ -1141,7 +1143,7 @@ Result BinaryReaderInterpreter::OnLocalDecl(uint32_t decl_index,
 }
 
 Result BinaryReaderInterpreter::CheckHasMemory(Opcode opcode) {
-  if (module->memory_index == WABT_INVALID_INDEX) {
+  if (module->memory_index == kInvalidIndex) {
     PrintError("%s requires an imported or defined memory.",
                get_opcode_name(opcode));
     return Result::Error;
@@ -1150,7 +1152,7 @@ Result BinaryReaderInterpreter::CheckHasMemory(Opcode opcode) {
 }
 
 Result BinaryReaderInterpreter::CheckAlign(uint32_t alignment_log2,
-                                           uint32_t natural_alignment) {
+                                           Address natural_alignment) {
   if (alignment_log2 >= 32 || (1U << alignment_log2) > natural_alignment) {
     PrintError("alignment must not be larger than natural alignment (%u)",
                natural_alignment);
@@ -1171,39 +1173,37 @@ Result BinaryReaderInterpreter::OnBinaryExpr(Opcode opcode) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnBlockExpr(uint32_t num_types,
-                                            Type* sig_types) {
+Result BinaryReaderInterpreter::OnBlockExpr(Index num_types, Type* sig_types) {
   TypeVector sig(sig_types, sig_types + num_types);
   CHECK_RESULT(typechecker_on_block(&typechecker, &sig));
-  PushLabel(WABT_INVALID_OFFSET, WABT_INVALID_OFFSET);
+  PushLabel(kInvalidIstreamOffset, kInvalidIstreamOffset);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnLoopExpr(uint32_t num_types,
-                                           Type* sig_types) {
+Result BinaryReaderInterpreter::OnLoopExpr(Index num_types, Type* sig_types) {
   TypeVector sig(sig_types, sig_types + num_types);
   CHECK_RESULT(typechecker_on_loop(&typechecker, &sig));
-  PushLabel(GetIstreamOffset(), WABT_INVALID_OFFSET);
+  PushLabel(GetIstreamOffset(), kInvalidIstreamOffset);
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnIfExpr(uint32_t num_types, Type* sig_types) {
+Result BinaryReaderInterpreter::OnIfExpr(Index num_types, Type* sig_types) {
   TypeVector sig(sig_types, sig_types + num_types);
   CHECK_RESULT(typechecker_on_if(&typechecker, &sig));
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::BrUnless));
-  uint32_t fixup_offset = GetIstreamOffset();
-  CHECK_RESULT(EmitI32(WABT_INVALID_OFFSET));
-  PushLabel(WABT_INVALID_OFFSET, fixup_offset);
+  IstreamOffset fixup_offset = GetIstreamOffset();
+  CHECK_RESULT(EmitI32(kInvalidIstreamOffset));
+  PushLabel(kInvalidIstreamOffset, fixup_offset);
   return Result::Ok;
 }
 
 Result BinaryReaderInterpreter::OnElseExpr() {
   CHECK_RESULT(typechecker_on_else(&typechecker));
   Label* label = TopLabel();
-  uint32_t fixup_cond_offset = label->fixup_offset;
+  IstreamOffset fixup_cond_offset = label->fixup_offset;
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::Br));
   label->fixup_offset = GetIstreamOffset();
-  CHECK_RESULT(EmitI32(WABT_INVALID_OFFSET));
+  CHECK_RESULT(EmitI32(kInvalidIstreamOffset));
   CHECK_RESULT(EmitI32At(fixup_cond_offset, GetIstreamOffset()));
   return Result::Ok;
 }
@@ -1221,43 +1221,43 @@ Result BinaryReaderInterpreter::OnEndExpr() {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnBrExpr(uint32_t depth) {
-  uint32_t drop_count, keep_count;
+Result BinaryReaderInterpreter::OnBrExpr(Index depth) {
+  Index drop_count, keep_count;
   CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count));
   CHECK_RESULT(typechecker_on_br(&typechecker, depth));
   CHECK_RESULT(EmitBr(depth, drop_count, keep_count));
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnBrIfExpr(uint32_t depth) {
-  uint32_t drop_count, keep_count;
+Result BinaryReaderInterpreter::OnBrIfExpr(Index depth) {
+  Index drop_count, keep_count;
   CHECK_RESULT(typechecker_on_br_if(&typechecker, depth));
   CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count));
   /* flip the br_if so if <cond> is true it can drop values from the stack */
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::BrUnless));
-  uint32_t fixup_br_offset = GetIstreamOffset();
-  CHECK_RESULT(EmitI32(WABT_INVALID_OFFSET));
+  IstreamOffset fixup_br_offset = GetIstreamOffset();
+  CHECK_RESULT(EmitI32(kInvalidIstreamOffset));
   CHECK_RESULT(EmitBr(depth, drop_count, keep_count));
   CHECK_RESULT(EmitI32At(fixup_br_offset, GetIstreamOffset()));
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnBrTableExpr(uint32_t num_targets,
-                                              uint32_t* target_depths,
-                                              uint32_t default_target_depth) {
+Result BinaryReaderInterpreter::OnBrTableExpr(Index num_targets,
+                                              Index* target_depths,
+                                              Index default_target_depth) {
   CHECK_RESULT(typechecker_begin_br_table(&typechecker));
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::BrTable));
   CHECK_RESULT(EmitI32(num_targets));
-  uint32_t fixup_table_offset = GetIstreamOffset();
-  CHECK_RESULT(EmitI32(WABT_INVALID_OFFSET));
+  IstreamOffset fixup_table_offset = GetIstreamOffset();
+  CHECK_RESULT(EmitI32(kInvalidIstreamOffset));
   /* not necessary for the interpreter, but it makes it easier to disassemble.
    * This opcode specifies how many bytes of data follow. */
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::Data));
   CHECK_RESULT(EmitI32((num_targets + 1) * WABT_TABLE_ENTRY_SIZE));
   CHECK_RESULT(EmitI32At(fixup_table_offset, GetIstreamOffset()));
 
-  for (uint32_t i = 0; i <= num_targets; ++i) {
-    uint32_t depth = i != num_targets ? target_depths[i] : default_target_depth;
+  for (Index i = 0; i <= num_targets; ++i) {
+    Index depth = i != num_targets ? target_depths[i] : default_target_depth;
     CHECK_RESULT(typechecker_on_br_table_target(&typechecker, depth));
     CHECK_RESULT(EmitBrTableOffset(depth));
   }
@@ -1266,7 +1266,7 @@ Result BinaryReaderInterpreter::OnBrTableExpr(uint32_t num_targets,
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnCallExpr(uint32_t func_index) {
+Result BinaryReaderInterpreter::OnCallExpr(Index func_index) {
   InterpreterFunc* func = GetFuncByModuleIndex(func_index);
   InterpreterFuncSignature* sig = GetSignatureByEnvIndex(func->sig_index);
   CHECK_RESULT(
@@ -1283,8 +1283,8 @@ Result BinaryReaderInterpreter::OnCallExpr(uint32_t func_index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnCallIndirectExpr(uint32_t sig_index) {
-  if (module->table_index == WABT_INVALID_INDEX) {
+Result BinaryReaderInterpreter::OnCallIndirectExpr(Index sig_index) {
+  if (module->table_index == kInvalidIndex) {
     PrintError("found call_indirect operator, but no table");
     return Result::Error;
   }
@@ -1340,7 +1340,7 @@ Result BinaryReaderInterpreter::OnF64ConstExpr(uint64_t value_bits) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnGetGlobalExpr(uint32_t global_index) {
+Result BinaryReaderInterpreter::OnGetGlobalExpr(Index global_index) {
   CHECK_RESULT(CheckGlobal(global_index));
   Type type = GetGlobalTypeByModuleIndex(global_index);
   CHECK_RESULT(typechecker_on_get_global(&typechecker, type));
@@ -1349,11 +1349,11 @@ Result BinaryReaderInterpreter::OnGetGlobalExpr(uint32_t global_index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnSetGlobalExpr(uint32_t global_index) {
+Result BinaryReaderInterpreter::OnSetGlobalExpr(Index global_index) {
   CHECK_RESULT(CheckGlobal(global_index));
   InterpreterGlobal* global = GetGlobalByModuleIndex(global_index);
   if (!global->mutable_) {
-    PrintError("can't set_global on immutable global at index %u.",
+    PrintError("can't set_global on immutable global at index %" PRIindex ".",
                global_index);
     return Result::Error;
   }
@@ -1364,25 +1364,25 @@ Result BinaryReaderInterpreter::OnSetGlobalExpr(uint32_t global_index) {
   return Result::Ok;
 }
 
-uint32_t BinaryReaderInterpreter::TranslateLocalIndex(uint32_t local_index) {
+Index BinaryReaderInterpreter::TranslateLocalIndex(Index local_index) {
   return typechecker.type_stack.size() +
          current_func->param_and_local_types.size() - local_index;
 }
 
-Result BinaryReaderInterpreter::OnGetLocalExpr(uint32_t local_index) {
+Result BinaryReaderInterpreter::OnGetLocalExpr(Index local_index) {
   CHECK_RESULT(CheckLocal(local_index));
   Type type = GetLocalTypeByIndex(current_func, local_index);
   /* Get the translated index before calling typechecker_on_get_local
    * because it will update the type stack size. We need the index to be
    * relative to the old stack size. */
-  uint32_t translated_local_index = TranslateLocalIndex(local_index);
+  Index translated_local_index = TranslateLocalIndex(local_index);
   CHECK_RESULT(typechecker_on_get_local(&typechecker, type));
   CHECK_RESULT(EmitOpcode(InterpreterOpcode::GetLocal));
   CHECK_RESULT(EmitI32(translated_local_index));
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnSetLocalExpr(uint32_t local_index) {
+Result BinaryReaderInterpreter::OnSetLocalExpr(Index local_index) {
   CHECK_RESULT(CheckLocal(local_index));
   Type type = GetLocalTypeByIndex(current_func, local_index);
   CHECK_RESULT(typechecker_on_set_local(&typechecker, type));
@@ -1391,7 +1391,7 @@ Result BinaryReaderInterpreter::OnSetLocalExpr(uint32_t local_index) {
   return Result::Ok;
 }
 
-Result BinaryReaderInterpreter::OnTeeLocalExpr(uint32_t local_index) {
+Result BinaryReaderInterpreter::OnTeeLocalExpr(Index local_index) {
   CHECK_RESULT(CheckLocal(local_index));
   Type type = GetLocalTypeByIndex(current_func, local_index);
   CHECK_RESULT(typechecker_on_tee_local(&typechecker, type));
@@ -1410,7 +1410,7 @@ Result BinaryReaderInterpreter::OnGrowMemoryExpr() {
 
 Result BinaryReaderInterpreter::OnLoadExpr(Opcode opcode,
                                            uint32_t alignment_log2,
-                                           uint32_t offset) {
+                                           Address offset) {
   CHECK_RESULT(CheckHasMemory(opcode));
   CHECK_RESULT(CheckAlign(alignment_log2, get_opcode_memory_size(opcode)));
   CHECK_RESULT(typechecker_on_load(&typechecker, opcode));
@@ -1422,7 +1422,7 @@ Result BinaryReaderInterpreter::OnLoadExpr(Opcode opcode,
 
 Result BinaryReaderInterpreter::OnStoreExpr(Opcode opcode,
                                             uint32_t alignment_log2,
-                                            uint32_t offset) {
+                                            Address offset) {
   CHECK_RESULT(CheckHasMemory(opcode));
   CHECK_RESULT(CheckAlign(alignment_log2, get_opcode_memory_size(opcode)));
   CHECK_RESULT(typechecker_on_store(&typechecker, opcode));
@@ -1445,7 +1445,7 @@ Result BinaryReaderInterpreter::OnNopExpr() {
 }
 
 Result BinaryReaderInterpreter::OnReturnExpr() {
-  uint32_t drop_count, keep_count;
+  Index drop_count, keep_count;
   CHECK_RESULT(GetReturnDropKeepCount(&drop_count, &keep_count));
   CHECK_RESULT(typechecker_on_return(&typechecker));
   CHECK_RESULT(EmitDropKeep(drop_count, keep_count));
@@ -1483,7 +1483,7 @@ Result read_binary_interpreter(InterpreterEnvironment* env,
                                const ReadBinaryOptions* options,
                                BinaryErrorHandler* error_handler,
                                DefinedInterpreterModule** out_module) {
-  size_t istream_offset = env->istream->data.size();
+  IstreamOffset istream_offset = env->istream->data.size();
   DefinedInterpreterModule* module =
       new DefinedInterpreterModule(istream_offset);