LCOV - code coverage report
Current view: top level - src/runtime - runtime-test.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 401 474 84.6 %
Date: 2017-04-26 Functions: 74 160 46.2 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/runtime/runtime-utils.h"
       6             : 
       7             : #include <memory>
       8             : 
       9             : #include "src/arguments.h"
      10             : #include "src/assembler-inl.h"
      11             : #include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
      12             : #include "src/compiler.h"
      13             : #include "src/deoptimizer.h"
      14             : #include "src/frames-inl.h"
      15             : #include "src/full-codegen/full-codegen.h"
      16             : #include "src/isolate-inl.h"
      17             : #include "src/runtime-profiler.h"
      18             : #include "src/snapshot/code-serializer.h"
      19             : #include "src/snapshot/natives.h"
      20             : #include "src/wasm/wasm-module.h"
      21             : #include "src/wasm/wasm-objects.h"
      22             : 
      23             : namespace {
      24          14 : struct WasmCompileControls {
      25             :   uint32_t MaxWasmBufferSize = std::numeric_limits<uint32_t>::max();
      26             :   bool AllowAnySizeForAsync = true;
      27             : };
      28             : 
      29             : // We need per-isolate controls, because we sometimes run tests in multiple
      30             : // isolates
      31             : // concurrently.
      32             : // To avoid upsetting the static initializer count, we lazy initialize this.
      33             : v8::base::LazyInstance<std::map<v8::Isolate*, WasmCompileControls>>::type
      34             :     g_PerIsolateWasmControls = LAZY_INSTANCE_INITIALIZER;
      35             : 
      36         120 : bool IsWasmCompileAllowed(v8::Isolate* isolate, v8::Local<v8::Value> value,
      37             :                           bool is_async) {
      38             :   DCHECK_GT(g_PerIsolateWasmControls.Get().count(isolate), 0);
      39         120 :   const WasmCompileControls& ctrls = g_PerIsolateWasmControls.Get().at(isolate);
      40         225 :   return (is_async && ctrls.AllowAnySizeForAsync) ||
      41         105 :          (v8::Local<v8::ArrayBuffer>::Cast(value)->ByteLength() <=
      42         120 :           ctrls.MaxWasmBufferSize);
      43             : }
      44             : 
      45             : // Use the compile controls for instantiation, too
      46          83 : bool IsWasmInstantiateAllowed(v8::Isolate* isolate,
      47             :                               v8::Local<v8::Value> module_or_bytes,
      48             :                               bool is_async) {
      49             :   DCHECK_GT(g_PerIsolateWasmControls.Get().count(isolate), 0);
      50          83 :   const WasmCompileControls& ctrls = g_PerIsolateWasmControls.Get().at(isolate);
      51          83 :   if (is_async && ctrls.AllowAnySizeForAsync) return true;
      52          68 :   if (!module_or_bytes->IsWebAssemblyCompiledModule()) {
      53          30 :     return IsWasmCompileAllowed(isolate, module_or_bytes, is_async);
      54             :   }
      55             :   v8::Local<v8::WasmCompiledModule> module =
      56             :       v8::Local<v8::WasmCompiledModule>::Cast(module_or_bytes);
      57         114 :   return static_cast<uint32_t>(module->GetWasmWireBytes()->Length()) <=
      58          38 :          ctrls.MaxWasmBufferSize;
      59             : }
      60             : 
      61          90 : v8::Local<v8::Value> NewRangeException(v8::Isolate* isolate,
      62             :                                        const char* message) {
      63             :   return v8::Exception::RangeError(
      64             :       v8::String::NewFromOneByte(isolate,
      65             :                                  reinterpret_cast<const uint8_t*>(message),
      66             :                                  v8::NewStringType::kNormal)
      67         180 :           .ToLocalChecked());
      68             : }
      69             : 
      70          60 : void ThrowRangeException(v8::Isolate* isolate, const char* message) {
      71          60 :   isolate->ThrowException(NewRangeException(isolate, message));
      72          60 : }
      73             : 
      74          30 : void RejectPromiseWithRangeError(
      75          60 :     const v8::FunctionCallbackInfo<v8::Value>& args, const char* message) {
      76             :   v8::Isolate* isolate = args.GetIsolate();
      77          30 :   v8::HandleScope scope(isolate);
      78             : 
      79          30 :   v8::Local<v8::Context> context = isolate->GetCurrentContext();
      80             :   v8::Local<v8::Promise::Resolver> resolver;
      81          60 :   if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) return;
      82             :   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
      83          30 :   return_value.Set(resolver->GetPromise());
      84             : 
      85          30 :   auto maybe = resolver->Reject(context, NewRangeException(isolate, message));
      86          60 :   CHECK(!maybe.IsNothing());
      87          30 :   return;
      88             : }
      89             : 
      90         150 : bool WasmModuleOverride(const v8::FunctionCallbackInfo<v8::Value>& args) {
      91          60 :   if (IsWasmCompileAllowed(args.GetIsolate(), args[0], false)) return false;
      92          30 :   ThrowRangeException(args.GetIsolate(), "Sync compile not allowed");
      93          30 :   return true;
      94             : }
      95             : 
      96          60 : bool WasmCompileOverride(const v8::FunctionCallbackInfo<v8::Value>& args) {
      97          30 :   if (IsWasmCompileAllowed(args.GetIsolate(), args[0], true)) return false;
      98          15 :   RejectPromiseWithRangeError(args, "Async compile not allowed");
      99          15 :   return true;
     100             : }
     101             : 
     102         136 : bool WasmInstanceOverride(const v8::FunctionCallbackInfo<v8::Value>& args) {
     103          53 :   if (IsWasmInstantiateAllowed(args.GetIsolate(), args[0], false)) return false;
     104          30 :   ThrowRangeException(args.GetIsolate(), "Sync instantiate not allowed");
     105          30 :   return true;
     106             : }
     107             : 
     108          60 : bool WasmInstantiateOverride(const v8::FunctionCallbackInfo<v8::Value>& args) {
     109          30 :   if (IsWasmInstantiateAllowed(args.GetIsolate(), args[0], true)) return false;
     110          15 :   RejectPromiseWithRangeError(args, "Async instantiate not allowed");
     111          15 :   return true;
     112             : }
     113             : 
     114          45 : bool GetWasmFromArray(const v8::FunctionCallbackInfo<v8::Value>& args) {
     115          15 :   CHECK(args.Length() == 1);
     116          15 :   v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
     117             :   v8::Local<v8::Value> module =
     118          30 :       v8::Local<v8::Object>::Cast(args[0])->Get(context, 0).ToLocalChecked();
     119             : 
     120             :   v8::Local<v8::Promise::Resolver> resolver =
     121          15 :       v8::Promise::Resolver::New(context).ToLocalChecked();
     122          15 :   args.GetReturnValue().Set(resolver->GetPromise());
     123          15 :   USE(resolver->Resolve(context, module));
     124          15 :   return true;
     125             : }
     126             : 
     127          15 : bool NoExtension(const v8::FunctionCallbackInfo<v8::Value>&) { return false; }
     128             : 
     129             : }  // namespace
     130             : 
     131             : namespace v8 {
     132             : namespace internal {
     133             : 
     134        1456 : RUNTIME_FUNCTION(Runtime_ConstructDouble) {
     135         728 :   HandleScope scope(isolate);
     136             :   DCHECK_EQ(2, args.length());
     137        1456 :   CONVERT_NUMBER_CHECKED(uint32_t, hi, Uint32, args[0]);
     138        1456 :   CONVERT_NUMBER_CHECKED(uint32_t, lo, Uint32, args[1]);
     139         728 :   uint64_t result = (static_cast<uint64_t>(hi) << 32) | lo;
     140        1456 :   return *isolate->factory()->NewNumber(uint64_to_double(result));
     141             : }
     142             : 
     143          30 : RUNTIME_FUNCTION(Runtime_ConstructConsString) {
     144          15 :   HandleScope scope(isolate);
     145             :   DCHECK_EQ(2, args.length());
     146          30 :   CONVERT_ARG_HANDLE_CHECKED(String, left, 0);
     147          30 :   CONVERT_ARG_HANDLE_CHECKED(String, right, 1);
     148             : 
     149          15 :   CHECK(left->IsOneByteRepresentation());
     150          15 :   CHECK(right->IsOneByteRepresentation());
     151             : 
     152             :   const bool kIsOneByte = true;
     153          30 :   const int length = left->length() + right->length();
     154          30 :   return *isolate->factory()->NewConsString(left, right, length, kIsOneByte);
     155             : }
     156             : 
     157      179548 : RUNTIME_FUNCTION(Runtime_DeoptimizeFunction) {
     158       89774 :   HandleScope scope(isolate);
     159             :   DCHECK_EQ(1, args.length());
     160             : 
     161             :   // This function is used by fuzzers to get coverage in compiler.
     162             :   // Ignore calls on non-function objects to avoid runtime errors.
     163       89774 :   CONVERT_ARG_HANDLE_CHECKED(Object, function_object, 0);
     164       89774 :   if (!function_object->IsJSFunction()) {
     165           0 :     return isolate->heap()->undefined_value();
     166             :   }
     167       89774 :   Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
     168             : 
     169             :   // If the function is not optimized, just return.
     170       89774 :   if (!function->IsOptimized()) return isolate->heap()->undefined_value();
     171             : 
     172             :   // TODO(turbofan): Deoptimization is not supported yet.
     173        7877 :   if (function->code()->is_turbofanned() &&
     174        3520 :       function->shared()->asm_function()) {
     175         169 :     return isolate->heap()->undefined_value();
     176             :   }
     177             : 
     178        4188 :   Deoptimizer::DeoptimizeFunction(*function);
     179             : 
     180        4188 :   return isolate->heap()->undefined_value();
     181             : }
     182             : 
     183             : 
     184     3003804 : RUNTIME_FUNCTION(Runtime_DeoptimizeNow) {
     185     1501902 :   HandleScope scope(isolate);
     186             :   DCHECK_EQ(0, args.length());
     187             : 
     188             :   Handle<JSFunction> function;
     189             : 
     190             :   // Find the JavaScript function on the top of the stack.
     191     3003804 :   JavaScriptFrameIterator it(isolate);
     192     1501902 :   if (!it.done()) function = Handle<JSFunction>(it.frame()->function());
     193     1501902 :   if (function.is_null()) return isolate->heap()->undefined_value();
     194             : 
     195             :   // If the function is not optimized, just return.
     196     1501902 :   if (!function->IsOptimized()) return isolate->heap()->undefined_value();
     197             : 
     198             :   // TODO(turbofan): Deoptimization is not supported yet.
     199        1230 :   if (function->code()->is_turbofanned() &&
     200         569 :       function->shared()->asm_function()) {
     201           0 :     return isolate->heap()->undefined_value();
     202             :   }
     203             : 
     204         661 :   Deoptimizer::DeoptimizeFunction(*function);
     205             : 
     206     1502563 :   return isolate->heap()->undefined_value();
     207             : }
     208             : 
     209             : 
     210          28 : RUNTIME_FUNCTION(Runtime_RunningInSimulator) {
     211             :   SealHandleScope shs(isolate);
     212             :   DCHECK_EQ(0, args.length());
     213             : #if defined(USE_SIMULATOR)
     214             :   return isolate->heap()->true_value();
     215             : #else
     216          14 :   return isolate->heap()->false_value();
     217             : #endif
     218             : }
     219             : 
     220             : 
     221         160 : RUNTIME_FUNCTION(Runtime_IsConcurrentRecompilationSupported) {
     222             :   SealHandleScope shs(isolate);
     223             :   DCHECK_EQ(0, args.length());
     224             :   return isolate->heap()->ToBoolean(
     225          80 :       isolate->concurrent_recompilation_enabled());
     226             : }
     227             : 
     228         240 : RUNTIME_FUNCTION(Runtime_TypeProfile) {
     229         120 :   HandleScope scope(isolate);
     230             :   DCHECK_EQ(1, args.length());
     231             : 
     232         120 :   if (!FLAG_type_profile) {
     233           0 :     return isolate->heap()->undefined_value();
     234             :   }
     235             : 
     236         240 :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
     237         120 :   if (function->has_feedback_vector()) {
     238          98 :     FeedbackVector* vector = function->feedback_vector();
     239          98 :     if (vector->metadata()->HasTypeProfileSlot()) {
     240          98 :       FeedbackSlot slot = vector->GetTypeProfileSlot();
     241          98 :       CollectTypeProfileNexus nexus(vector, slot);
     242          98 :       return nexus.GetTypeProfile();
     243             :     }
     244             :   }
     245          44 :   return *isolate->factory()->NewJSObject(isolate->object_function());
     246             : }
     247             : 
     248      527902 : RUNTIME_FUNCTION(Runtime_OptimizeFunctionOnNextCall) {
     249      263889 :   HandleScope scope(isolate);
     250             : 
     251             :   // This function is used by fuzzers, ignore calls with bogus arguments count.
     252      263889 :   if (args.length() != 1 && args.length() != 2) {
     253           0 :     return isolate->heap()->undefined_value();
     254             :   }
     255             : 
     256             :   // This function is used by fuzzers to get coverage for optimizations
     257             :   // in compiler. Ignore calls on non-function objects to avoid runtime errors.
     258      263889 :   CONVERT_ARG_HANDLE_CHECKED(Object, function_object, 0);
     259      263889 :   if (!function_object->IsJSFunction()) {
     260           0 :     return isolate->heap()->undefined_value();
     261             :   }
     262      263889 :   Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
     263             : 
     264             :   // The following condition was lifted from the DCHECK inside
     265             :   // JSFunction::MarkForOptimization().
     266      527778 :   if (!(function->shared()->allows_lazy_compilation() ||
     267          46 :         (function->code()->kind() == Code::FUNCTION &&
     268      263935 :          !function->shared()->optimization_disabled()))) {
     269          46 :     return isolate->heap()->undefined_value();
     270             :   }
     271             : 
     272             :   // If function isn't compiled, compile it now.
     273      265399 :   if (!function->shared()->is_compiled() &&
     274        1556 :       !Compiler::Compile(function, Compiler::CLEAR_EXCEPTION)) {
     275           0 :     return isolate->heap()->undefined_value();
     276             :   }
     277             : 
     278             :   // If the function is already optimized, just return.
     279      263843 :   if (function->IsOptimized()) return isolate->heap()->undefined_value();
     280             : 
     281      199900 :   function->MarkForOptimization();
     282             : 
     283      199900 :   if (args.length() == 2) {
     284         248 :     CONVERT_ARG_HANDLE_CHECKED(String, type, 1);
     285         372 :     if (type->IsOneByteEqualTo(STATIC_CHAR_VECTOR("concurrent")) &&
     286         124 :         isolate->concurrent_recompilation_enabled()) {
     287         124 :       function->AttemptConcurrentOptimization();
     288             :     }
     289             :   }
     290             : 
     291      199900 :   return isolate->heap()->undefined_value();
     292             : }
     293             : 
     294       84789 : RUNTIME_FUNCTION(Runtime_OptimizeOsr) {
     295       34995 :   HandleScope scope(isolate);
     296             :   DCHECK(args.length() == 0 || args.length() == 1);
     297             : 
     298             :   Handle<JSFunction> function;
     299             : 
     300             :   // The optional parameter determines the frame being targeted.
     301       34995 :   int stack_depth = args.length() == 1 ? args.smi_at(0) : 0;
     302             : 
     303             :   // Find the JavaScript function on the top of the stack.
     304       69990 :   JavaScriptFrameIterator it(isolate);
     305         294 :   while (!it.done() && stack_depth--) it.Advance();
     306       34995 :   if (!it.done()) function = Handle<JSFunction>(it.frame()->function());
     307       34995 :   if (function.is_null()) return isolate->heap()->undefined_value();
     308             : 
     309             :   // If the function is already optimized, just return.
     310       34995 :   if (function->IsOptimized()) return isolate->heap()->undefined_value();
     311             : 
     312             :   // Make the profiler arm all back edges in unoptimized code.
     313       44846 :   if (it.frame()->type() == StackFrame::JAVA_SCRIPT ||
     314       19763 :       it.frame()->type() == StackFrame::INTERPRETED) {
     315             :     isolate->runtime_profiler()->AttemptOnStackReplacement(
     316       29598 :         it.frame(), AbstractCode::kMaxLoopNestingMarker);
     317             :   }
     318             : 
     319       60078 :   return isolate->heap()->undefined_value();
     320             : }
     321             : 
     322             : 
     323        4336 : RUNTIME_FUNCTION(Runtime_NeverOptimizeFunction) {
     324        2168 :   HandleScope scope(isolate);
     325             :   DCHECK_EQ(1, args.length());
     326        4336 :   CONVERT_ARG_CHECKED(JSFunction, function, 0);
     327             :   function->shared()->set_disable_optimization_reason(
     328        2168 :       kOptimizationDisabledForTest);
     329        2168 :   function->shared()->set_optimization_disabled(true);
     330        2168 :   return isolate->heap()->undefined_value();
     331             : }
     332             : 
     333       13806 : RUNTIME_FUNCTION(Runtime_GetOptimizationStatus) {
     334        4592 :   HandleScope scope(isolate);
     335             :   DCHECK(args.length() == 1 || args.length() == 2);
     336             :   int status = 0;
     337        4592 :   if (!isolate->use_crankshaft()) {
     338             :     status |= static_cast<int>(OptimizationStatus::kNeverOptimize);
     339             :   }
     340        4592 :   if (FLAG_always_opt || FLAG_prepare_always_opt) {
     341        2242 :     status |= static_cast<int>(OptimizationStatus::kAlwaysOptimize);
     342             :   }
     343        4592 :   if (FLAG_deopt_every_n_times) {
     344           0 :     status |= static_cast<int>(OptimizationStatus::kMaybeDeopted);
     345             :   }
     346             : 
     347             :   // This function is used by fuzzers to get coverage for optimizations
     348             :   // in compiler. Ignore calls on non-function objects to avoid runtime errors.
     349        4592 :   CONVERT_ARG_HANDLE_CHECKED(Object, function_object, 0);
     350        4592 :   if (!function_object->IsJSFunction()) {
     351          14 :     return Smi::FromInt(status);
     352             :   }
     353        4578 :   Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
     354        4578 :   status |= static_cast<int>(OptimizationStatus::kIsFunction);
     355             : 
     356             :   bool sync_with_compiler_thread = true;
     357        4578 :   if (args.length() == 2) {
     358        4272 :     CONVERT_ARG_HANDLE_CHECKED(Object, sync_object, 1);
     359        4272 :     if (!sync_object->IsString()) return isolate->heap()->undefined_value();
     360        4272 :     Handle<String> sync = Handle<String>::cast(sync_object);
     361        8544 :     if (sync->IsOneByteEqualTo(STATIC_CHAR_VECTOR("no sync"))) {
     362             :       sync_with_compiler_thread = false;
     363             :     }
     364             :   }
     365             : 
     366        4578 :   if (isolate->concurrent_recompilation_enabled() &&
     367             :       sync_with_compiler_thread) {
     368        4270 :     while (function->IsInOptimizationQueue()) {
     369          44 :       isolate->optimizing_compile_dispatcher()->InstallOptimizedFunctions();
     370          44 :       base::OS::Sleep(base::TimeDelta::FromMilliseconds(50));
     371             :     }
     372             :   }
     373        4578 :   if (function->IsOptimized()) {
     374        3912 :     status |= static_cast<int>(OptimizationStatus::kOptimized);
     375        3912 :     if (function->code()->is_turbofanned()) {
     376        2437 :       status |= static_cast<int>(OptimizationStatus::kTurboFanned);
     377             :     }
     378             :   }
     379        4578 :   if (function->IsInterpreted()) {
     380         386 :     status |= static_cast<int>(OptimizationStatus::kInterpreted);
     381             :   }
     382        4578 :   return Smi::FromInt(status);
     383             : }
     384             : 
     385             : 
     386         146 : RUNTIME_FUNCTION(Runtime_UnblockConcurrentRecompilation) {
     387             :   DCHECK_EQ(0, args.length());
     388         146 :   if (FLAG_block_concurrent_recompilation &&
     389          73 :       isolate->concurrent_recompilation_enabled()) {
     390          58 :     isolate->optimizing_compile_dispatcher()->Unblock();
     391             :   }
     392          73 :   return isolate->heap()->undefined_value();
     393             : }
     394             : 
     395             : 
     396      334416 : RUNTIME_FUNCTION(Runtime_GetOptimizationCount) {
     397      167208 :   HandleScope scope(isolate);
     398             :   DCHECK_EQ(1, args.length());
     399      334416 :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
     400      167208 :   return Smi::FromInt(function->shared()->opt_count());
     401             : }
     402             : 
     403         182 : RUNTIME_FUNCTION(Runtime_GetDeoptCount) {
     404          91 :   HandleScope scope(isolate);
     405             :   DCHECK_EQ(1, args.length());
     406         182 :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
     407          91 :   return Smi::FromInt(function->shared()->deopt_count());
     408             : }
     409             : 
     410           0 : static void ReturnThis(const v8::FunctionCallbackInfo<v8::Value>& args) {
     411             :   args.GetReturnValue().Set(args.This());
     412           0 : }
     413             : 
     414         390 : RUNTIME_FUNCTION(Runtime_GetUndetectable) {
     415         195 :   HandleScope scope(isolate);
     416             :   DCHECK_EQ(0, args.length());
     417             :   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     418             : 
     419         195 :   Local<v8::ObjectTemplate> desc = v8::ObjectTemplate::New(v8_isolate);
     420         195 :   desc->MarkAsUndetectable();
     421         195 :   desc->SetCallAsFunctionHandler(ReturnThis);
     422             :   Local<v8::Object> obj;
     423         390 :   if (!desc->NewInstance(v8_isolate->GetCurrentContext()).ToLocal(&obj)) {
     424             :     return nullptr;
     425             :   }
     426         390 :   return *Utils::OpenHandle(*obj);
     427             : }
     428             : 
     429         300 : static void call_as_function(const v8::FunctionCallbackInfo<v8::Value>& args) {
     430             :   double v1 = args[0]
     431         150 :                   ->NumberValue(v8::Isolate::GetCurrent()->GetCurrentContext())
     432         300 :                   .ToChecked();
     433             :   double v2 = args[1]
     434         150 :                   ->NumberValue(v8::Isolate::GetCurrent()->GetCurrentContext())
     435         300 :                   .ToChecked();
     436             :   args.GetReturnValue().Set(
     437         150 :       v8::Number::New(v8::Isolate::GetCurrent(), v1 - v2));
     438         150 : }
     439             : 
     440             : // Returns a callable object. The object returns the difference of its two
     441             : // parameters when it is called.
     442          30 : RUNTIME_FUNCTION(Runtime_GetCallable) {
     443          15 :   HandleScope scope(isolate);
     444             :   DCHECK_EQ(0, args.length());
     445             :   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     446          15 :   Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(v8_isolate);
     447          15 :   Local<ObjectTemplate> instance_template = t->InstanceTemplate();
     448          15 :   instance_template->SetCallAsFunctionHandler(call_as_function);
     449          15 :   v8_isolate->GetCurrentContext();
     450             :   Local<v8::Object> instance =
     451          15 :       t->GetFunction(v8_isolate->GetCurrentContext())
     452          15 :           .ToLocalChecked()
     453          15 :           ->NewInstance(v8_isolate->GetCurrentContext())
     454          15 :           .ToLocalChecked();
     455          30 :   return *Utils::OpenHandle(*instance);
     456             : }
     457             : 
     458      169936 : RUNTIME_FUNCTION(Runtime_ClearFunctionFeedback) {
     459       84968 :   HandleScope scope(isolate);
     460             :   DCHECK_EQ(1, args.length());
     461      169936 :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
     462       84968 :   function->ClearTypeFeedbackInfo();
     463       84968 :   Code* unoptimized = function->shared()->code();
     464       84968 :   if (unoptimized->kind() == Code::FUNCTION) {
     465       34078 :     unoptimized->ClearInlineCaches();
     466             :   }
     467       84968 :   return isolate->heap()->undefined_value();
     468             : }
     469             : 
     470          30 : RUNTIME_FUNCTION(Runtime_SetWasmCompileFromPromiseOverload) {
     471          15 :   isolate->set_wasm_compile_callback(GetWasmFromArray);
     472          15 :   return isolate->heap()->undefined_value();
     473             : }
     474             : 
     475          30 : RUNTIME_FUNCTION(Runtime_ResetWasmOverloads) {
     476          15 :   isolate->set_wasm_compile_callback(NoExtension);
     477          15 :   return isolate->heap()->undefined_value();
     478             : }
     479             : 
     480          30 : RUNTIME_FUNCTION(Runtime_CheckWasmWrapperElision) {
     481             :   // This only supports the case where the function being exported
     482             :   // calls an intermediate function, and the intermediate function
     483             :   // calls exactly one imported function
     484          15 :   HandleScope scope(isolate);
     485          15 :   CHECK(args.length() == 2);
     486             :   // It takes two parameters, the first one is the JSFunction,
     487             :   // The second one is the type
     488          30 :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
     489             :   // If type is 0, it means that it is supposed to be a direct call into a WASM
     490             :   // function
     491             :   // If type is 1, it means that it is supposed to have wrappers
     492          30 :   CONVERT_ARG_HANDLE_CHECKED(Smi, type, 1);
     493          15 :   Handle<Code> export_code = handle(function->code());
     494          15 :   CHECK(export_code->kind() == Code::JS_TO_WASM_FUNCTION);
     495          15 :   int const mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
     496             :   // check the type of the $export_fct
     497             :   Handle<Code> export_fct;
     498             :   int count = 0;
     499          62 :   for (RelocIterator it(*export_code, mask); !it.done(); it.next()) {
     500          47 :     RelocInfo* rinfo = it.rinfo();
     501             :     Address target_address = rinfo->target_address();
     502          47 :     Code* target = Code::GetCodeFromTargetAddress(target_address);
     503          47 :     if (target->kind() == Code::WASM_FUNCTION) {
     504          15 :       ++count;
     505             :       export_fct = handle(target);
     506             :     }
     507             :   }
     508          15 :   CHECK(count == 1);
     509             :   // check the type of the intermediate_fct
     510             :   Handle<Code> intermediate_fct;
     511             :   count = 0;
     512          45 :   for (RelocIterator it(*export_fct, mask); !it.done(); it.next()) {
     513          30 :     RelocInfo* rinfo = it.rinfo();
     514             :     Address target_address = rinfo->target_address();
     515          30 :     Code* target = Code::GetCodeFromTargetAddress(target_address);
     516          30 :     if (target->kind() == Code::WASM_FUNCTION) {
     517          15 :       ++count;
     518             :       intermediate_fct = handle(target);
     519             :     }
     520             :   }
     521          15 :   CHECK(count == 1);
     522             :   // check the type of the imported exported function, it should be also a WASM
     523             :   // function in our case
     524             :   Handle<Code> imported_fct;
     525          15 :   CHECK(type->value() == 0 || type->value() == 1);
     526             : 
     527             :   Code::Kind target_kind =
     528          15 :       type->value() == 0 ? Code::WASM_FUNCTION : Code::WASM_TO_JS_FUNCTION;
     529             :   count = 0;
     530          45 :   for (RelocIterator it(*intermediate_fct, mask); !it.done(); it.next()) {
     531          30 :     RelocInfo* rinfo = it.rinfo();
     532             :     Address target_address = rinfo->target_address();
     533          30 :     Code* target = Code::GetCodeFromTargetAddress(target_address);
     534          30 :     if (target->kind() == target_kind) {
     535          15 :       ++count;
     536             :       imported_fct = handle(target);
     537             :     }
     538             :   }
     539          15 :   CHECK_LE(count, 1);
     540          15 :   return isolate->heap()->ToBoolean(count == 1);
     541             : }
     542             : 
     543         240 : RUNTIME_FUNCTION(Runtime_SetWasmCompileControls) {
     544         120 :   HandleScope scope(isolate);
     545         120 :   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     546         120 :   CHECK(args.length() == 2);
     547         240 :   CONVERT_ARG_HANDLE_CHECKED(Smi, block_size, 0);
     548         240 :   CONVERT_BOOLEAN_ARG_CHECKED(allow_async, 1);
     549         120 :   WasmCompileControls& ctrl = (*g_PerIsolateWasmControls.Pointer())[v8_isolate];
     550         120 :   ctrl.AllowAnySizeForAsync = allow_async;
     551         120 :   ctrl.MaxWasmBufferSize = static_cast<uint32_t>(block_size->value());
     552         120 :   v8_isolate->SetWasmModuleCallback(WasmModuleOverride);
     553         120 :   v8_isolate->SetWasmCompileCallback(WasmCompileOverride);
     554         120 :   return isolate->heap()->undefined_value();
     555             : }
     556             : 
     557          30 : RUNTIME_FUNCTION(Runtime_SetWasmInstantiateControls) {
     558          15 :   HandleScope scope(isolate);
     559             :   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     560          15 :   CHECK(args.length() == 0);
     561          15 :   v8_isolate->SetWasmInstanceCallback(WasmInstanceOverride);
     562          15 :   v8_isolate->SetWasmInstantiateCallback(WasmInstantiateOverride);
     563          15 :   return isolate->heap()->undefined_value();
     564             : }
     565             : 
     566         178 : RUNTIME_FUNCTION(Runtime_NotifyContextDisposed) {
     567          89 :   HandleScope scope(isolate);
     568             :   DCHECK_EQ(0, args.length());
     569          89 :   isolate->heap()->NotifyContextDisposed(true);
     570          89 :   return isolate->heap()->undefined_value();
     571             : }
     572             : 
     573             : 
     574         974 : RUNTIME_FUNCTION(Runtime_SetAllocationTimeout) {
     575             :   SealHandleScope shs(isolate);
     576             :   DCHECK(args.length() == 2 || args.length() == 3);
     577             : #ifdef DEBUG
     578             :   CONVERT_INT32_ARG_CHECKED(interval, 0);
     579             :   CONVERT_INT32_ARG_CHECKED(timeout, 1);
     580             :   isolate->heap()->set_allocation_timeout(timeout);
     581             :   FLAG_gc_interval = interval;
     582             :   if (args.length() == 3) {
     583             :     // Enable/disable inline allocation if requested.
     584             :     CONVERT_BOOLEAN_ARG_CHECKED(inline_allocation, 2);
     585             :     if (inline_allocation) {
     586             :       isolate->heap()->EnableInlineAllocation();
     587             :     } else {
     588             :       isolate->heap()->DisableInlineAllocation();
     589             :     }
     590             :   }
     591             : #endif
     592         487 :   return isolate->heap()->undefined_value();
     593             : }
     594             : 
     595             : 
     596        2444 : RUNTIME_FUNCTION(Runtime_DebugPrint) {
     597             :   SealHandleScope shs(isolate);
     598             :   DCHECK_EQ(1, args.length());
     599             : 
     600        2444 :   OFStream os(stdout);
     601             : #ifdef DEBUG
     602             :   if (args[0]->IsString() && isolate->context() != nullptr) {
     603             :     // If we have a string, assume it's a code "marker"
     604             :     // and print some interesting cpu debugging info.
     605             :     args[0]->Print(os);
     606             :     JavaScriptFrameIterator it(isolate);
     607             :     JavaScriptFrame* frame = it.frame();
     608             :     os << "fp = " << static_cast<void*>(frame->fp())
     609             :        << ", sp = " << static_cast<void*>(frame->sp())
     610             :        << ", caller_sp = " << static_cast<void*>(frame->caller_sp()) << ": ";
     611             :   } else {
     612             :     os << "DebugPrint: ";
     613             :     args[0]->Print(os);
     614             :   }
     615             :   if (args[0]->IsHeapObject()) {
     616             :     HeapObject::cast(args[0])->map()->Print(os);
     617             :   }
     618             : #else
     619             :   // ShortPrint is available in release mode. Print is not.
     620        1222 :   os << Brief(args[0]);
     621             : #endif
     622        1222 :   os << std::endl;
     623             : 
     624        1222 :   return args[0];  // return TOS
     625             : }
     626             : 
     627             : 
     628          28 : RUNTIME_FUNCTION(Runtime_DebugTrace) {
     629             :   SealHandleScope shs(isolate);
     630             :   DCHECK_EQ(0, args.length());
     631          14 :   isolate->PrintStack(stdout);
     632          14 :   return isolate->heap()->undefined_value();
     633             : }
     634             : 
     635             : 
     636             : // This will not allocate (flatten the string), but it may run
     637             : // very slowly for very deeply nested ConsStrings.  For debugging use only.
     638         324 : RUNTIME_FUNCTION(Runtime_GlobalPrint) {
     639             :   SealHandleScope shs(isolate);
     640             :   DCHECK_EQ(1, args.length());
     641             : 
     642         324 :   CONVERT_ARG_CHECKED(String, string, 0);
     643         162 :   StringCharacterStream stream(string);
     644         702 :   while (stream.HasMore()) {
     645         540 :     uint16_t character = stream.GetNext();
     646         540 :     PrintF("%c", character);
     647             :   }
     648             :   return string;
     649             : }
     650             : 
     651             : 
     652           0 : RUNTIME_FUNCTION(Runtime_SystemBreak) {
     653             :   // The code below doesn't create handles, but when breaking here in GDB
     654             :   // having a handle scope might be useful.
     655           0 :   HandleScope scope(isolate);
     656             :   DCHECK_EQ(0, args.length());
     657           0 :   base::OS::DebugBreak();
     658           0 :   return isolate->heap()->undefined_value();
     659             : }
     660             : 
     661             : 
     662             : // Sets a v8 flag.
     663         150 : RUNTIME_FUNCTION(Runtime_SetFlags) {
     664             :   SealHandleScope shs(isolate);
     665             :   DCHECK_EQ(1, args.length());
     666         150 :   CONVERT_ARG_CHECKED(String, arg, 0);
     667             :   std::unique_ptr<char[]> flags =
     668         150 :       arg->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     669          75 :   FlagList::SetFlagsFromString(flags.get(), StrLength(flags.get()));
     670          75 :   return isolate->heap()->undefined_value();
     671             : }
     672             : 
     673             : 
     674           0 : RUNTIME_FUNCTION(Runtime_Abort) {
     675             :   SealHandleScope shs(isolate);
     676             :   DCHECK_EQ(1, args.length());
     677           0 :   CONVERT_SMI_ARG_CHECKED(message_id, 0);
     678             :   const char* message =
     679           0 :       GetBailoutReason(static_cast<BailoutReason>(message_id));
     680           0 :   base::OS::PrintError("abort: %s\n", message);
     681           0 :   isolate->PrintStack(stderr);
     682           0 :   base::OS::Abort();
     683             :   UNREACHABLE();
     684             :   return NULL;
     685             : }
     686             : 
     687             : 
     688           0 : RUNTIME_FUNCTION(Runtime_AbortJS) {
     689           0 :   HandleScope scope(isolate);
     690             :   DCHECK_EQ(1, args.length());
     691           0 :   CONVERT_ARG_HANDLE_CHECKED(String, message, 0);
     692           0 :   base::OS::PrintError("abort: %s\n", message->ToCString().get());
     693           0 :   isolate->PrintStack(stderr);
     694           0 :   base::OS::Abort();
     695             :   UNREACHABLE();
     696             :   return NULL;
     697             : }
     698             : 
     699             : 
     700          12 : RUNTIME_FUNCTION(Runtime_NativeScriptsCount) {
     701             :   DCHECK_EQ(0, args.length());
     702           6 :   return Smi::FromInt(Natives::GetBuiltinsCount());
     703             : }
     704             : 
     705             : // TODO(5510): remove this.
     706           0 : RUNTIME_FUNCTION(Runtime_GetV8Version) {
     707           0 :   HandleScope scope(isolate);
     708             :   DCHECK_EQ(0, args.length());
     709             : 
     710           0 :   const char* version_string = v8::V8::GetVersion();
     711             : 
     712           0 :   return *isolate->factory()->NewStringFromAsciiChecked(version_string);
     713             : }
     714             : 
     715             : 
     716          30 : RUNTIME_FUNCTION(Runtime_DisassembleFunction) {
     717          15 :   HandleScope scope(isolate);
     718             : #ifdef DEBUG
     719             :   DCHECK_EQ(1, args.length());
     720             :   // Get the function and make sure it is compiled.
     721             :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, func, 0);
     722             :   if (!Compiler::Compile(func, Compiler::KEEP_EXCEPTION)) {
     723             :     return isolate->heap()->exception();
     724             :   }
     725             :   OFStream os(stdout);
     726             :   func->code()->Print(os);
     727             :   os << std::endl;
     728             : #endif  // DEBUG
     729          15 :   return isolate->heap()->undefined_value();
     730             : }
     731             : 
     732             : namespace {
     733             : 
     734           0 : int StackSize(Isolate* isolate) {
     735             :   int n = 0;
     736           0 :   for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) n++;
     737           0 :   return n;
     738             : }
     739             : 
     740           0 : void PrintIndentation(Isolate* isolate) {
     741             :   const int nmax = 80;
     742           0 :   int n = StackSize(isolate);
     743           0 :   if (n <= nmax) {
     744           0 :     PrintF("%4d:%*s", n, n, "");
     745             :   } else {
     746           0 :     PrintF("%4d:%*s", n, nmax, "...");
     747             :   }
     748           0 : }
     749             : 
     750             : }  // namespace
     751             : 
     752           0 : RUNTIME_FUNCTION(Runtime_TraceEnter) {
     753             :   SealHandleScope shs(isolate);
     754             :   DCHECK_EQ(0, args.length());
     755           0 :   PrintIndentation(isolate);
     756           0 :   JavaScriptFrame::PrintTop(isolate, stdout, true, false);
     757           0 :   PrintF(" {\n");
     758           0 :   return isolate->heap()->undefined_value();
     759             : }
     760             : 
     761             : 
     762           0 : RUNTIME_FUNCTION(Runtime_TraceExit) {
     763             :   SealHandleScope shs(isolate);
     764             :   DCHECK_EQ(1, args.length());
     765           0 :   CONVERT_ARG_CHECKED(Object, obj, 0);
     766           0 :   PrintIndentation(isolate);
     767           0 :   PrintF("} -> ");
     768           0 :   obj->ShortPrint();
     769           0 :   PrintF("\n");
     770             :   return obj;  // return TOS
     771             : }
     772             : 
     773           0 : RUNTIME_FUNCTION(Runtime_TraceTailCall) {
     774             :   SealHandleScope shs(isolate);
     775             :   DCHECK_EQ(0, args.length());
     776           0 :   PrintIndentation(isolate);
     777           0 :   PrintF("} -> tail call ->\n");
     778           0 :   return isolate->heap()->undefined_value();
     779             : }
     780             : 
     781           0 : RUNTIME_FUNCTION(Runtime_GetExceptionDetails) {
     782           0 :   HandleScope shs(isolate);
     783             :   DCHECK_EQ(1, args.length());
     784           0 :   CONVERT_ARG_HANDLE_CHECKED(JSObject, exception_obj, 0);
     785             : 
     786           0 :   Factory* factory = isolate->factory();
     787             :   Handle<JSMessageObject> message_obj =
     788           0 :       isolate->CreateMessage(exception_obj, nullptr);
     789             : 
     790           0 :   Handle<JSObject> message = factory->NewJSObject(isolate->object_function());
     791             : 
     792             :   Handle<String> key;
     793             :   Handle<Object> value;
     794             : 
     795           0 :   key = factory->NewStringFromAsciiChecked("start_pos");
     796           0 :   value = handle(Smi::FromInt(message_obj->start_position()), isolate);
     797           0 :   JSObject::SetProperty(message, key, value, STRICT).Assert();
     798             : 
     799           0 :   key = factory->NewStringFromAsciiChecked("end_pos");
     800           0 :   value = handle(Smi::FromInt(message_obj->end_position()), isolate);
     801           0 :   JSObject::SetProperty(message, key, value, STRICT).Assert();
     802             : 
     803           0 :   return *message;
     804             : }
     805             : 
     806       27672 : RUNTIME_FUNCTION(Runtime_HaveSameMap) {
     807             :   SealHandleScope shs(isolate);
     808             :   DCHECK_EQ(2, args.length());
     809       27672 :   CONVERT_ARG_CHECKED(JSObject, obj1, 0);
     810       27672 :   CONVERT_ARG_CHECKED(JSObject, obj2, 1);
     811       13836 :   return isolate->heap()->ToBoolean(obj1->map() == obj2->map());
     812             : }
     813             : 
     814             : 
     815           0 : RUNTIME_FUNCTION(Runtime_InNewSpace) {
     816             :   SealHandleScope shs(isolate);
     817             :   DCHECK_EQ(1, args.length());
     818           0 :   CONVERT_ARG_CHECKED(Object, obj, 0);
     819           0 :   return isolate->heap()->ToBoolean(isolate->heap()->InNewSpace(obj));
     820             : }
     821             : 
     822       13832 : RUNTIME_FUNCTION(Runtime_IsAsmWasmCode) {
     823             :   SealHandleScope shs(isolate);
     824             :   DCHECK_EQ(1, args.length());
     825       13832 :   CONVERT_ARG_CHECKED(JSFunction, function, 0);
     826        6916 :   if (!function->shared()->HasAsmWasmData()) {
     827             :     // Doesn't have wasm data.
     828        1393 :     return isolate->heap()->false_value();
     829             :   }
     830       11046 :   if (function->shared()->code() !=
     831        5523 :       isolate->builtins()->builtin(Builtins::kInstantiateAsmJs)) {
     832             :     // Hasn't been compiled yet.
     833           0 :     return isolate->heap()->false_value();
     834             :   }
     835        5523 :   return isolate->heap()->true_value();
     836             : }
     837             : 
     838             : namespace {
     839           0 : bool DisallowCodegenFromStringsCallback(v8::Local<v8::Context> context) {
     840           0 :   return false;
     841             : }
     842             : }
     843             : 
     844          30 : RUNTIME_FUNCTION(Runtime_DisallowCodegenFromStrings) {
     845             :   SealHandleScope shs(isolate);
     846             :   DCHECK_EQ(0, args.length());
     847             :   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     848             :   v8_isolate->SetAllowCodeGenerationFromStringsCallback(
     849          15 :       DisallowCodegenFromStringsCallback);
     850          15 :   return isolate->heap()->undefined_value();
     851             : }
     852             : 
     853         120 : RUNTIME_FUNCTION(Runtime_IsWasmCode) {
     854             :   SealHandleScope shs(isolate);
     855             :   DCHECK_EQ(1, args.length());
     856         120 :   CONVERT_ARG_CHECKED(JSFunction, function, 0);
     857          60 :   bool is_js_to_wasm = function->code()->kind() == Code::JS_TO_WASM_FUNCTION;
     858          60 :   return isolate->heap()->ToBoolean(is_js_to_wasm);
     859             : }
     860             : 
     861             : #define ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(Name)       \
     862             :   RUNTIME_FUNCTION(Runtime_Has##Name) {                  \
     863             :     CONVERT_ARG_CHECKED(JSObject, obj, 0);               \
     864             :     return isolate->heap()->ToBoolean(obj->Has##Name()); \
     865             :   }
     866             : 
     867     3007342 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastSmiElements)
     868     4529958 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastObjectElements)
     869     4500000 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastSmiOrObjectElements)
     870     4510274 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastDoubleElements)
     871    16501492 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastHoleyElements)
     872         704 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(DictionaryElements)
     873         206 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(SloppyArgumentsElements)
     874           0 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FixedTypedArrayElements)
     875             : // Properties test sitting with elements tests - not fooling anyone.
     876       17362 : ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastProperties)
     877             : 
     878             : #undef ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION
     879             : 
     880             : 
     881             : #define FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION(Type, type, TYPE, ctype, s) \
     882             :   RUNTIME_FUNCTION(Runtime_HasFixed##Type##Elements) {                        \
     883             :     CONVERT_ARG_CHECKED(JSObject, obj, 0);                                    \
     884             :     return isolate->heap()->ToBoolean(obj->HasFixed##Type##Elements());       \
     885             :   }
     886             : 
     887        1260 : TYPED_ARRAYS(FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION)
     888             : 
     889             : #undef FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION
     890             : 
     891             : 
     892         224 : RUNTIME_FUNCTION(Runtime_SpeciesProtector) {
     893             :   SealHandleScope shs(isolate);
     894             :   DCHECK_EQ(0, args.length());
     895         112 :   return isolate->heap()->ToBoolean(isolate->IsArraySpeciesLookupChainIntact());
     896             : }
     897             : 
     898             : #define CONVERT_ARG_HANDLE_CHECKED_2(Type, name, index) \
     899             :   CHECK(Type::Is##Type(args[index]));                   \
     900             :   Handle<Type> name = args.at<Type>(index);
     901             : 
     902             : // Take a compiled wasm module, serialize it and copy the buffer into an array
     903             : // buffer, which is then returned.
     904         270 : RUNTIME_FUNCTION(Runtime_SerializeWasmModule) {
     905          90 :   HandleScope shs(isolate);
     906             :   DCHECK_EQ(1, args.length());
     907          90 :   CONVERT_ARG_HANDLE_CHECKED_2(WasmModuleObject, module_obj, 0);
     908             : 
     909          90 :   Handle<WasmCompiledModule> orig(module_obj->compiled_module());
     910             :   std::unique_ptr<ScriptData> data =
     911         180 :       WasmCompiledModuleSerializer::SerializeWasmModule(isolate, orig);
     912          90 :   void* buff = isolate->array_buffer_allocator()->Allocate(data->length());
     913          90 :   Handle<JSArrayBuffer> ret = isolate->factory()->NewJSArrayBuffer();
     914          90 :   JSArrayBuffer::Setup(ret, isolate, false, buff, data->length());
     915          90 :   memcpy(buff, data->data(), data->length());
     916          90 :   return *ret;
     917             : }
     918             : 
     919             : // Take an array buffer and attempt to reconstruct a compiled wasm module.
     920             : // Return undefined if unsuccessful.
     921         210 : RUNTIME_FUNCTION(Runtime_DeserializeWasmModule) {
     922         105 :   HandleScope shs(isolate);
     923             :   DCHECK_EQ(2, args.length());
     924         210 :   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, buffer, 0);
     925         210 :   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, wire_bytes, 1);
     926             : 
     927         105 :   Address mem_start = static_cast<Address>(buffer->backing_store());
     928         105 :   int mem_size = static_cast<int>(buffer->byte_length()->Number());
     929             : 
     930             :   // DeserializeWasmModule will allocate. We assume JSArrayBuffer doesn't
     931             :   // get relocated.
     932         210 :   ScriptData sc(mem_start, mem_size);
     933         105 :   bool already_external = wire_bytes->is_external();
     934         105 :   if (!already_external) {
     935         105 :     wire_bytes->set_is_external(true);
     936         105 :     isolate->heap()->UnregisterArrayBuffer(*wire_bytes);
     937             :   }
     938             :   MaybeHandle<FixedArray> maybe_compiled_module =
     939             :       WasmCompiledModuleSerializer::DeserializeWasmModule(
     940             :           isolate, &sc,
     941             :           Vector<const uint8_t>(
     942         105 :               reinterpret_cast<uint8_t*>(wire_bytes->backing_store()),
     943         210 :               static_cast<int>(wire_bytes->byte_length()->Number())));
     944         105 :   if (!already_external) {
     945         105 :     wire_bytes->set_is_external(false);
     946         105 :     isolate->heap()->RegisterNewArrayBuffer(*wire_bytes);
     947             :   }
     948             :   Handle<FixedArray> compiled_module;
     949         105 :   if (!maybe_compiled_module.ToHandle(&compiled_module)) {
     950          15 :     return isolate->heap()->undefined_value();
     951             :   }
     952             :   return *WasmModuleObject::New(
     953         285 :       isolate, Handle<WasmCompiledModule>::cast(compiled_module));
     954             : }
     955             : 
     956         180 : RUNTIME_FUNCTION(Runtime_ValidateWasmInstancesChain) {
     957          90 :   HandleScope shs(isolate);
     958             :   DCHECK_EQ(2, args.length());
     959          90 :   CONVERT_ARG_HANDLE_CHECKED_2(WasmModuleObject, module_obj, 0);
     960         180 :   CONVERT_ARG_HANDLE_CHECKED(Smi, instance_count, 1);
     961             :   wasm::testing::ValidateInstancesChain(isolate, module_obj,
     962          90 :                                         instance_count->value());
     963          90 :   return isolate->heap()->ToBoolean(true);
     964             : }
     965             : 
     966          60 : RUNTIME_FUNCTION(Runtime_ValidateWasmModuleState) {
     967          30 :   HandleScope shs(isolate);
     968             :   DCHECK_EQ(1, args.length());
     969          30 :   CONVERT_ARG_HANDLE_CHECKED_2(WasmModuleObject, module_obj, 0);
     970          30 :   wasm::testing::ValidateModuleState(isolate, module_obj);
     971          30 :   return isolate->heap()->ToBoolean(true);
     972             : }
     973             : 
     974          30 : RUNTIME_FUNCTION(Runtime_ValidateWasmOrphanedInstance) {
     975          15 :   HandleScope shs(isolate);
     976             :   DCHECK_EQ(1, args.length());
     977          15 :   CONVERT_ARG_HANDLE_CHECKED_2(WasmInstanceObject, instance, 0);
     978          15 :   wasm::testing::ValidateOrphanedInstance(isolate, instance);
     979          15 :   return isolate->heap()->ToBoolean(true);
     980             : }
     981             : 
     982        2850 : RUNTIME_FUNCTION(Runtime_HeapObjectVerify) {
     983        1425 :   HandleScope shs(isolate);
     984             :   DCHECK_EQ(1, args.length());
     985        1425 :   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
     986             : #ifdef VERIFY_HEAP
     987             :   object->ObjectVerify();
     988             : #else
     989        1425 :   CHECK(object->IsObject());
     990        1425 :   if (object->IsHeapObject()) {
     991        2760 :     CHECK(HeapObject::cast(*object)->map()->IsMap());
     992             :   } else {
     993          45 :     CHECK(object->IsSmi());
     994             :   }
     995             : #endif
     996        1425 :   return isolate->heap()->ToBoolean(true);
     997             : }
     998             : 
     999         900 : RUNTIME_FUNCTION(Runtime_WasmNumInterpretedCalls) {
    1000             :   DCHECK_EQ(1, args.length());
    1001         450 :   HandleScope scope(isolate);
    1002         900 :   CONVERT_ARG_HANDLE_CHECKED(JSObject, instance_obj, 0);
    1003         450 :   CHECK(WasmInstanceObject::IsWasmInstanceObject(*instance_obj));
    1004             :   Handle<WasmInstanceObject> instance =
    1005         450 :       Handle<WasmInstanceObject>::cast(instance_obj);
    1006         450 :   if (!instance->has_debug_info()) return 0;
    1007         450 :   uint64_t num = instance->debug_info()->NumInterpretedCalls();
    1008         900 :   return *isolate->factory()->NewNumberFromSize(static_cast<size_t>(num));
    1009             : }
    1010             : 
    1011          60 : RUNTIME_FUNCTION(Runtime_RedirectToWasmInterpreter) {
    1012             :   DCHECK_EQ(2, args.length());
    1013          30 :   HandleScope scope(isolate);
    1014          60 :   CONVERT_ARG_HANDLE_CHECKED(JSObject, instance_obj, 0);
    1015          60 :   CONVERT_SMI_ARG_CHECKED(function_index, 1);
    1016          30 :   CHECK(WasmInstanceObject::IsWasmInstanceObject(*instance_obj));
    1017             :   Handle<WasmInstanceObject> instance =
    1018          30 :       Handle<WasmInstanceObject>::cast(instance_obj);
    1019             :   Handle<WasmDebugInfo> debug_info =
    1020          30 :       WasmInstanceObject::GetOrCreateDebugInfo(instance);
    1021             :   WasmDebugInfo::RedirectToInterpreter(debug_info,
    1022          30 :                                        Vector<int>(&function_index, 1));
    1023          30 :   return isolate->heap()->undefined_value();
    1024             : }
    1025             : 
    1026        1890 : RUNTIME_FUNCTION(Runtime_IncrementWaitCount) {
    1027         945 :   isolate->IncrementWaitCountForTesting();
    1028         945 :   return isolate->heap()->undefined_value();
    1029             : }
    1030             : 
    1031        1890 : RUNTIME_FUNCTION(Runtime_DecrementWaitCount) {
    1032         945 :   isolate->DecrementWaitCountForTesting();
    1033         945 :   return isolate->heap()->undefined_value();
    1034             : }
    1035             : 
    1036             : }  // namespace internal
    1037             : }  // namespace v8

Generated by: LCOV version 1.10