Introduce IsUndefined(Isolate*) and IsTheHole(Isolate*)

src/wasm/wasm-module.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/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 836 matching lines @@
   // Run the start function if one was specified.
   if (this->start_function_index >= 0) {
     HandleScope scope(isolate);
     uint32_t index = static_cast<uint32_t>(this->start_function_index);
     Handle<String> name = isolate->factory()->NewStringFromStaticChars("start");
     Handle<Code> code = instance.function_code[index];
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
         isolate, &module_env, name, code, instance.js_object, index);
 
     // Call the JS function.
-    Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
+    Handle<Object> undefined = isolate->factory()->undefined_value();
     MaybeHandle<Object> retval =
         Execution::Call(isolate, jsfunc, undefined, 0, nullptr);
 
     if (retval.is_null()) {
       thrower.Error("WASM.instantiateModule(): start function failed");
     }
   }
   return instance.js_object;
 }
 
@@ skipping 88 matching lines @@
 
   // Wrap the main code so it can be called as a JS function.
   uint32_t main_index = module->export_table.back().func_index;
   Handle<Code> main_code = instance.function_code[main_index];
   Handle<String> name = isolate->factory()->NewStringFromStaticChars("main");
   Handle<JSObject> module_object = Handle<JSObject>(0, isolate);
   Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
       isolate, &module_env, name, main_code, module_object, main_index);
 
   // Call the JS function.
-  Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
+  Handle<Object> undefined = isolate->factory()->undefined_value();
   MaybeHandle<Object> retval =
       Execution::Call(isolate, jsfunc, undefined, 0, nullptr);
 
   // The result should be a number.
   if (retval.is_null()) {
     thrower.Error("WASM.compileRun() failed: Invocation was null");
     return -1;
   }
   Handle<Object> result = retval.ToHandleChecked();
   if (result->IsSmi()) {
     return Smi::cast(*result)->value();
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 MaybeHandle<String> GetWasmFunctionName(Handle<JSObject> wasm,
                                         uint32_t func_index) {
   DCHECK(IsWasmObject(wasm));
   Object* func_names_arr_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
-  if (func_names_arr_obj->IsUndefined()) return Handle<String>::null();
+  Isolate* isolate = wasm->GetIsolate();
+  if (func_names_arr_obj->IsUndefined(isolate)) return Handle<String>::null();
   return GetWasmFunctionNameFromTable(
-      handle(ByteArray::cast(func_names_arr_obj)), func_index);
+      handle(ByteArray::cast(func_names_arr_obj), isolate), func_index);
 }
 
 bool IsWasmObject(Handle<JSObject> object) {
   // TODO(clemensh): Check wasm byte header once we store a copy of the bytes.
   return object->GetInternalFieldCount() == kWasmModuleInternalFieldCount &&
          object->GetInternalField(kWasmModuleCodeTable)->IsFixedArray() &&
          object->GetInternalField(kWasmMemArrayBuffer)->IsJSArrayBuffer() &&
          (object->GetInternalField(kWasmFunctionNamesArray)->IsByteArray() ||
-          object->GetInternalField(kWasmFunctionNamesArray)->IsUndefined());
+          object->GetInternalField(kWasmFunctionNamesArray)
+              ->IsUndefined(object->GetIsolate()));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8