[wasm] Remove three fields from wasm object

src/wasm/wasm-debug.cc

 // Copyright 2016 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/wasm-debug.h"
 
 #include "src/assert-scope.h"
 #include "src/debug/debug.h"
 #include "src/factory.h"
 #include "src/isolate.h"
@@ skipping 13 matching lines @@
   kWasmDebugInfoNumEntries
 };
 
 ByteArray *GetOrCreateFunctionOffsetTable(Handle<WasmDebugInfo> debug_info) {
   Object *offset_table = debug_info->get(kWasmDebugInfoFunctionByteOffsets);
   Isolate *isolate = debug_info->GetIsolate();
   if (!offset_table->IsUndefined(isolate)) return ByteArray::cast(offset_table);
 
   FunctionOffsetsResult function_offsets;
   {
-    DisallowHeapAllocation no_gc;
     Handle<JSObject> wasm_object(debug_info->wasm_object(), isolate);
     uint32_t num_imported_functions =
-        wasm::GetNumImportedFunctions(wasm_object);
-    SeqOneByteString *wasm_bytes =
-        wasm::GetWasmBytes(debug_info->wasm_object());
+        static_cast<uint32_t>(wasm::GetNumImportedFunctions(wasm_object));
+    Handle<SeqOneByteString> wasm_bytes = wasm::GetWasmBytes(wasm_object);
+    DisallowHeapAllocation no_gc;
     const byte *bytes_start = wasm_bytes->GetChars();
     const byte *bytes_end = bytes_start + wasm_bytes->length();
     function_offsets = wasm::DecodeWasmFunctionOffsets(bytes_start, bytes_end,
                                                        num_imported_functions);
   }
   DCHECK(function_offsets.ok());
   size_t array_size = 2 * kIntSize * function_offsets.val.size();
   CHECK_LE(array_size, static_cast<size_t>(kMaxInt));
   ByteArray *arr =
       *isolate->factory()->NewByteArray(static_cast<int>(array_size));
@@ skipping 15 matching lines @@
 
   int offset = arr->get_int(2 * func_index);
   int length = arr->get_int(2 * func_index + 1);
   // Assert that it's distinguishable from the "illegal function index" return.
   DCHECK(offset > 0 && length > 0);
   return {offset, length};
 }
 
 Vector<const uint8_t> GetFunctionBytes(Handle<WasmDebugInfo> debug_info,
                                        int func_index) {
-  SeqOneByteString *module_bytes =
-      wasm::GetWasmBytes(debug_info->wasm_object());
+  Handle<JSObject> wasm_object(debug_info->wasm_object());
+  Handle<SeqOneByteString> module_bytes = wasm::GetWasmBytes(wasm_object);
   std::pair<int, int> offset_and_length =
       GetFunctionOffsetAndLength(debug_info, func_index);
   return Vector<const uint8_t>(
       module_bytes->GetChars() + offset_and_length.first,
       offset_and_length.second);
 }
 
 }  // namespace
 
 Handle<WasmDebugInfo> WasmDebugInfo::New(Handle<JSObject> wasm) {
   Isolate *isolate = wasm->GetIsolate();
   Factory *factory = isolate->factory();
   Handle<FixedArray> arr =
       factory->NewFixedArray(kWasmDebugInfoNumEntries, TENURED);
   arr->set(kWasmDebugInfoWasmObj, *wasm);
   int hash = 0;
-  Handle<SeqOneByteString> wasm_bytes(GetWasmBytes(*wasm), isolate);
+  Handle<SeqOneByteString> wasm_bytes = GetWasmBytes(wasm);
   {
     DisallowHeapAllocation no_gc;
     hash = StringHasher::HashSequentialString(
         wasm_bytes->GetChars(), wasm_bytes->length(), kZeroHashSeed);
   }
   Handle<Object> hash_obj = factory->NewNumberFromInt(hash, TENURED);
   arr->set(kWasmDebugInfoWasmBytesHash, *hash_obj);
 
   return Handle<WasmDebugInfo>::cast(arr);
 }
@@ skipping 19 matching lines @@
 JSObject *WasmDebugInfo::wasm_object() {
   return JSObject::cast(get(kWasmDebugInfoWasmObj));
 }
 
 Script *WasmDebugInfo::GetFunctionScript(Handle<WasmDebugInfo> debug_info,
                                          int func_index) {
   Isolate *isolate = debug_info->GetIsolate();
   Object *scripts_obj = debug_info->get(kWasmDebugInfoFunctionScripts);
   Handle<FixedArray> scripts;
   if (scripts_obj->IsUndefined(isolate)) {
-    int num_functions = wasm::GetNumberOfFunctions(debug_info->wasm_object());
+    Handle<JSObject> wasm_object(debug_info->wasm_object(), isolate);
+    int num_functions = wasm::GetNumberOfFunctions(wasm_object);
     scripts = isolate->factory()->NewFixedArray(num_functions, TENURED);
     debug_info->set(kWasmDebugInfoFunctionScripts, *scripts);
   } else {
     scripts = handle(FixedArray::cast(scripts_obj), isolate);
   }
 
   DCHECK(func_index >= 0 && func_index < scripts->length());
   Object *script_or_undef = scripts->get(func_index);
   if (!script_or_undef->IsUndefined(isolate)) {
     return Script::cast(script_or_undef);
@@ skipping 85 matching lines @@
   int idx = 0;
   for (std::tuple<uint32_t, int, int> elem : offset_table_vec) {
     offset_table->set(idx++, Smi::FromInt(std::get<0>(elem)));
     offset_table->set(idx++, Smi::FromInt(std::get<1>(elem)));
     offset_table->set(idx++, Smi::FromInt(std::get<2>(elem)));
   }
   DCHECK_EQ(idx, offset_table->length());
 
   return offset_table;
 }