[wasm] Remove special memory type for (internal) globals and use local type instead.

src/wasm/module-decoder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/wasm/module-decoder.h"
 
 #include "src/base/functional.h"
 #include "src/base/platform/platform.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
@@ skipping 215 matching lines @@
           break;
         }
         case WasmSection::Code::Globals: {
           uint32_t globals_count = consume_u32v("globals count");
           module->globals.reserve(SafeReserve(globals_count));
           // Decode globals.
           for (uint32_t i = 0; i < globals_count; ++i) {
             if (failed()) break;
             TRACE("DecodeGlobal[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
-            module->globals.push_back({0, 0, MachineType::Int32(), 0, false});
+            module->globals.push_back({0, 0, kAstStmt, 0, false});

[ahaas, 2016/07/21 12:06:46]

Could you add a comment which says what this line is good for?

[titzer, 2016/07/21 12:15:10]

Done.

             WasmGlobal* global = &module->globals.back();
             DecodeGlobalInModule(global);
           }
           break;
         }
         case WasmSection::Code::DataSegments: {
           uint32_t data_segments_count = consume_u32v("data segments count");
           module->data_segments.reserve(SafeReserve(data_segments_count));
           // Decode data segments.
           for (uint32_t i = 0; i < data_segments_count; ++i) {
@@ skipping 227 matching lines @@
   ModuleResult result_;
   ModuleOrigin origin_;
 
   uint32_t off(const byte* ptr) { return static_cast<uint32_t>(ptr - start_); }
 
   // Decodes a single global entry inside a module starting at {pc_}.
   void DecodeGlobalInModule(WasmGlobal* global) {
     global->name_offset = consume_string(&global->name_length, false);
     DCHECK(unibrow::Utf8::Validate(start_ + global->name_offset,
                                    global->name_length));
-    global->type = mem_type();
+    global->type = consume_local_type();
     global->offset = 0;
     global->exported = consume_u8("exported") != 0;
   }
 
   bool IsWithinLimit(uint32_t limit, uint32_t offset, uint32_t size) {
     if (offset > limit) return false;
     if ((offset + size) < offset) return false;  // overflow
     return (offset + size) <= limit;
   }
 
@@ skipping 25 matching lines @@
   }
 
   // Calculate individual global offsets and total size of globals table.
   void CalculateGlobalsOffsets(WasmModule* module) {
     uint32_t offset = 0;
     if (module->globals.size() == 0) {
       module->globals_size = 0;
       return;
     }
     for (WasmGlobal& global : module->globals) {
-      byte size = WasmOpcodes::MemSize(global.type);
+      byte size =
+          WasmOpcodes::MemSize(WasmOpcodes::MachineTypeFor(global.type));
       offset = (offset + size - 1) & ~(size - 1);  // align
       global.offset = offset;
       offset += size;
     }
     module->globals_size = offset;
   }
 
   // Verifies the body (code) of a given function.
   void VerifyFunctionBody(uint32_t func_num, ModuleEnv* menv,
                           WasmFunction* function) {
@@ skipping 87 matching lines @@
       case kLocalF32:
         return kAstF32;
       case kLocalF64:
         return kAstF64;
       default:
         error(pc_ - 1, "invalid local type");
         return kAstStmt;
     }
   }
 
-  // Reads a single 8-bit integer, interpreting it as a memory type.
-  MachineType mem_type() {
-    byte val = consume_u8("memory type");
-    MemTypeCode t = static_cast<MemTypeCode>(val);
-    switch (t) {
-      case kMemI8:
-        return MachineType::Int8();
-      case kMemU8:
-        return MachineType::Uint8();
-      case kMemI16:
-        return MachineType::Int16();
-      case kMemU16:
-        return MachineType::Uint16();
-      case kMemI32:
-        return MachineType::Int32();
-      case kMemU32:
-        return MachineType::Uint32();
-      case kMemI64:
-        return MachineType::Int64();
-      case kMemU64:
-        return MachineType::Uint64();
-      case kMemF32:
-        return MachineType::Float32();
-      case kMemF64:
-        return MachineType::Float64();
-      case kMemS128:
-        return MachineType::Simd128();
-      default:
-        error(pc_ - 1, "invalid memory type");
-        return MachineType::None();
-    }
-  }
-
   // Parses a type entry, which is currently limited to functions only.
   FunctionSig* consume_sig() {
     const byte* pos = pc_;
     byte form = consume_u8("type form");
     if (form != kWasmFunctionTypeForm) {
       error(pos, pos, "expected function type form (0x%02x), got: 0x%02x",
             kWasmFunctionTypeForm, form);
       return nullptr;
     }
     // parse parameter types
@@ skipping 158 matching lines @@
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8