Home | History | Annotate | Download | only in runtime 
      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 "src/arguments.h"
      8 #include "src/ast/prettyprinter.h"
      9 #include "src/bootstrapper.h"
     10 #include "src/conversions.h"
     11 #include "src/debug/debug.h"
     12 #include "src/frames-inl.h"
     13 #include "src/isolate-inl.h"
     14 #include "src/messages.h"
     15 #include "src/parsing/parser.h"
     16 #include "src/wasm/wasm-module.h"
     17 
     18 namespace v8 {
     19 namespace internal {
     20 
     21 RUNTIME_FUNCTION(Runtime_CheckIsBootstrapping) {
     22   SealHandleScope shs(isolate);
     23   DCHECK(args.length() == 0);
     24   CHECK(isolate->bootstrapper()->IsActive());
     25   return isolate->heap()->undefined_value();
     26 }
     27 
     28 
     29 RUNTIME_FUNCTION(Runtime_ExportFromRuntime) {
     30   HandleScope scope(isolate);
     31   DCHECK(args.length() == 1);
     32   CONVERT_ARG_HANDLE_CHECKED(JSObject, container, 0);
     33   CHECK(isolate->bootstrapper()->IsActive());
     34   JSObject::NormalizeProperties(container, KEEP_INOBJECT_PROPERTIES, 10,
     35                                 "ExportFromRuntime");
     36   Bootstrapper::ExportFromRuntime(isolate, container);
     37   JSObject::MigrateSlowToFast(container, 0, "ExportFromRuntime");
     38   return *container;
     39 }
     40 
     41 
     42 RUNTIME_FUNCTION(Runtime_ExportExperimentalFromRuntime) {
     43   HandleScope scope(isolate);
     44   DCHECK(args.length() == 1);
     45   CONVERT_ARG_HANDLE_CHECKED(JSObject, container, 0);
     46   CHECK(isolate->bootstrapper()->IsActive());
     47   JSObject::NormalizeProperties(container, KEEP_INOBJECT_PROPERTIES, 10,
     48                                 "ExportExperimentalFromRuntime");
     49   Bootstrapper::ExportExperimentalFromRuntime(isolate, container);
     50   JSObject::MigrateSlowToFast(container, 0, "ExportExperimentalFromRuntime");
     51   return *container;
     52 }
     53 
     54 
     55 RUNTIME_FUNCTION(Runtime_InstallToContext) {
     56   HandleScope scope(isolate);
     57   DCHECK(args.length() == 1);
     58   CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
     59   CHECK(array->HasFastElements());
     60   CHECK(isolate->bootstrapper()->IsActive());
     61   Handle<Context> native_context = isolate->native_context();
     62   Handle<FixedArray> fixed_array(FixedArray::cast(array->elements()));
     63   int length = Smi::cast(array->length())->value();
     64   for (int i = 0; i < length; i += 2) {
     65     CHECK(fixed_array->get(i)->IsString());
     66     Handle<String> name(String::cast(fixed_array->get(i)));
     67     CHECK(fixed_array->get(i + 1)->IsJSObject());
     68     Handle<JSObject> object(JSObject::cast(fixed_array->get(i + 1)));
     69     int index = Context::ImportedFieldIndexForName(name);
     70     if (index == Context::kNotFound) {
     71       index = Context::IntrinsicIndexForName(name);
     72     }
     73     CHECK(index != Context::kNotFound);
     74     native_context->set(index, *object);
     75   }
     76   return isolate->heap()->undefined_value();
     77 }
     78 
     79 
     80 RUNTIME_FUNCTION(Runtime_Throw) {
     81   HandleScope scope(isolate);
     82   DCHECK(args.length() == 1);
     83   return isolate->Throw(args[0]);
     84 }
     85 
     86 
     87 RUNTIME_FUNCTION(Runtime_ReThrow) {
     88   HandleScope scope(isolate);
     89   DCHECK(args.length() == 1);
     90   return isolate->ReThrow(args[0]);
     91 }
     92 
     93 
     94 RUNTIME_FUNCTION(Runtime_ThrowStackOverflow) {
     95   SealHandleScope shs(isolate);
     96   DCHECK_LE(0, args.length());
     97   return isolate->StackOverflow();
     98 }
     99 
    100 RUNTIME_FUNCTION(Runtime_ThrowWasmError) {
    101   HandleScope scope(isolate);
    102   DCHECK_EQ(2, args.length());
    103   CONVERT_SMI_ARG_CHECKED(message_id, 0);
    104   CONVERT_SMI_ARG_CHECKED(byte_offset, 1);
    105   Handle<Object> error_obj = isolate->factory()->NewError(
    106       static_cast<MessageTemplate::Template>(message_id));
    107 
    108   // For wasm traps, the byte offset (a.k.a source position) can not be
    109   // determined from relocation info, since the explicit checks for traps
    110   // converge in one singe block which calls this runtime function.
    111   // We hence pass the byte offset explicitely, and patch it into the top-most
    112   // frame (a wasm frame) on the collected stack trace.
    113   // TODO(wasm): This implementation is temporary, see bug #5007:
    114   // https://bugs.chromium.org/p/v8/issues/detail?id=5007
    115   Handle<JSObject> error = Handle<JSObject>::cast(error_obj);
    116   Handle<Object> stack_trace_obj = JSReceiver::GetDataProperty(
    117       error, isolate->factory()->stack_trace_symbol());
    118   // Patch the stack trace (array of <receiver, function, code, position>).
    119   if (stack_trace_obj->IsJSArray()) {
    120     Handle<FixedArray> stack_elements(
    121         FixedArray::cast(JSArray::cast(*stack_trace_obj)->elements()));
    122     DCHECK_EQ(1, stack_elements->length() % 4);
    123     DCHECK(Code::cast(stack_elements->get(3))->kind() == Code::WASM_FUNCTION);
    124     DCHECK(stack_elements->get(4)->IsSmi() &&
    125            Smi::cast(stack_elements->get(4))->value() >= 0);
    126     stack_elements->set(4, Smi::FromInt(-1 - byte_offset));
    127   }
    128   Handle<Object> detailed_stack_trace_obj = JSReceiver::GetDataProperty(
    129       error, isolate->factory()->detailed_stack_trace_symbol());
    130   // Patch the detailed stack trace (array of JSObjects with various
    131   // properties).
    132   if (detailed_stack_trace_obj->IsJSArray()) {
    133     Handle<FixedArray> stack_elements(
    134         FixedArray::cast(JSArray::cast(*detailed_stack_trace_obj)->elements()));
    135     DCHECK_GE(stack_elements->length(), 1);
    136     Handle<JSObject> top_frame(JSObject::cast(stack_elements->get(0)));
    137     Handle<String> wasm_offset_key =
    138         isolate->factory()->InternalizeOneByteString(
    139             STATIC_CHAR_VECTOR("column"));
    140     LookupIterator it(top_frame, wasm_offset_key, top_frame,
    141                       LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
    142     if (it.IsFound()) {
    143       DCHECK(JSReceiver::GetDataProperty(&it)->IsSmi());
    144       // Make column number 1-based here.
    145       Maybe<bool> data_set = JSReceiver::SetDataProperty(
    146           &it, handle(Smi::FromInt(byte_offset + 1), isolate));
    147       DCHECK(data_set.IsJust() && data_set.FromJust() == true);
    148       USE(data_set);
    149     }
    150   }
    151 
    152   return isolate->Throw(*error_obj);
    153 }
    154 
    155 RUNTIME_FUNCTION(Runtime_UnwindAndFindExceptionHandler) {
    156   SealHandleScope shs(isolate);
    157   DCHECK(args.length() == 0);
    158   return isolate->UnwindAndFindHandler();
    159 }
    160 
    161 
    162 RUNTIME_FUNCTION(Runtime_PromoteScheduledException) {
    163   SealHandleScope shs(isolate);
    164   DCHECK(args.length() == 0);
    165   return isolate->PromoteScheduledException();
    166 }
    167 
    168 
    169 RUNTIME_FUNCTION(Runtime_ThrowReferenceError) {
    170   HandleScope scope(isolate);
    171   DCHECK(args.length() == 1);
    172   CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
    173   THROW_NEW_ERROR_RETURN_FAILURE(
    174       isolate, NewReferenceError(MessageTemplate::kNotDefined, name));
    175 }
    176 
    177 
    178 RUNTIME_FUNCTION(Runtime_NewTypeError) {
    179   HandleScope scope(isolate);
    180   DCHECK(args.length() == 2);
    181   CONVERT_INT32_ARG_CHECKED(template_index, 0);
    182   CONVERT_ARG_HANDLE_CHECKED(Object, arg0, 1);
    183   auto message_template =
    184       static_cast<MessageTemplate::Template>(template_index);
    185   return *isolate->factory()->NewTypeError(message_template, arg0);
    186 }
    187 
    188 
    189 RUNTIME_FUNCTION(Runtime_NewReferenceError) {
    190   HandleScope scope(isolate);
    191   DCHECK(args.length() == 2);
    192   CONVERT_INT32_ARG_CHECKED(template_index, 0);
    193   CONVERT_ARG_HANDLE_CHECKED(Object, arg0, 1);
    194   auto message_template =
    195       static_cast<MessageTemplate::Template>(template_index);
    196   return *isolate->factory()->NewReferenceError(message_template, arg0);
    197 }
    198 
    199 
    200 RUNTIME_FUNCTION(Runtime_NewSyntaxError) {
    201   HandleScope scope(isolate);
    202   DCHECK(args.length() == 2);
    203   CONVERT_INT32_ARG_CHECKED(template_index, 0);
    204   CONVERT_ARG_HANDLE_CHECKED(Object, arg0, 1);
    205   auto message_template =
    206       static_cast<MessageTemplate::Template>(template_index);
    207   return *isolate->factory()->NewSyntaxError(message_template, arg0);
    208 }
    209 
    210 
    211 RUNTIME_FUNCTION(Runtime_ThrowIllegalInvocation) {
    212   HandleScope scope(isolate);
    213   DCHECK(args.length() == 0);
    214   THROW_NEW_ERROR_RETURN_FAILURE(
    215       isolate, NewTypeError(MessageTemplate::kIllegalInvocation));
    216 }
    217 
    218 RUNTIME_FUNCTION(Runtime_ThrowIncompatibleMethodReceiver) {
    219   HandleScope scope(isolate);
    220   DCHECK_EQ(2, args.length());
    221   CONVERT_ARG_HANDLE_CHECKED(Object, arg0, 0);
    222   CONVERT_ARG_HANDLE_CHECKED(Object, arg1, 1);
    223   THROW_NEW_ERROR_RETURN_FAILURE(
    224       isolate,
    225       NewTypeError(MessageTemplate::kIncompatibleMethodReceiver, arg0, arg1));
    226 }
    227 
    228 RUNTIME_FUNCTION(Runtime_ThrowIteratorResultNotAnObject) {
    229   HandleScope scope(isolate);
    230   DCHECK(args.length() == 1);
    231   CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);
    232   THROW_NEW_ERROR_RETURN_FAILURE(
    233       isolate,
    234       NewTypeError(MessageTemplate::kIteratorResultNotAnObject, value));
    235 }
    236 
    237 RUNTIME_FUNCTION(Runtime_ThrowGeneratorRunning) {
    238   HandleScope scope(isolate);
    239   DCHECK_EQ(0, args.length());
    240   THROW_NEW_ERROR_RETURN_FAILURE(
    241       isolate, NewTypeError(MessageTemplate::kGeneratorRunning));
    242 }
    243 
    244 RUNTIME_FUNCTION(Runtime_ThrowApplyNonFunction) {
    245   HandleScope scope(isolate);
    246   DCHECK_EQ(1, args.length());
    247   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
    248   Handle<String> type = Object::TypeOf(isolate, object);
    249   THROW_NEW_ERROR_RETURN_FAILURE(
    250       isolate, NewTypeError(MessageTemplate::kApplyNonFunction, object, type));
    251 }
    252 
    253 
    254 RUNTIME_FUNCTION(Runtime_PromiseRejectEvent) {
    255   DCHECK(args.length() == 3);
    256   HandleScope scope(isolate);
    257   CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
    258   CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
    259   CONVERT_BOOLEAN_ARG_CHECKED(debug_event, 2);
    260   if (debug_event) isolate->debug()->OnPromiseReject(promise, value);
    261   Handle<Symbol> key = isolate->factory()->promise_has_handler_symbol();
    262   // Do not report if we actually have a handler.
    263   if (JSReceiver::GetDataProperty(promise, key)->IsUndefined(isolate)) {
    264     isolate->ReportPromiseReject(promise, value,
    265                                  v8::kPromiseRejectWithNoHandler);
    266   }
    267   return isolate->heap()->undefined_value();
    268 }
    269 
    270 
    271 RUNTIME_FUNCTION(Runtime_PromiseRevokeReject) {
    272   DCHECK(args.length() == 1);
    273   HandleScope scope(isolate);
    274   CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
    275   Handle<Symbol> key = isolate->factory()->promise_has_handler_symbol();
    276   // At this point, no revocation has been issued before
    277   CHECK(JSReceiver::GetDataProperty(promise, key)->IsUndefined(isolate));
    278   isolate->ReportPromiseReject(promise, Handle<Object>(),
    279                                v8::kPromiseHandlerAddedAfterReject);
    280   return isolate->heap()->undefined_value();
    281 }
    282 
    283 
    284 RUNTIME_FUNCTION(Runtime_StackGuard) {
    285   SealHandleScope shs(isolate);
    286   DCHECK(args.length() == 0);
    287 
    288   // First check if this is a real stack overflow.
    289   StackLimitCheck check(isolate);
    290   if (check.JsHasOverflowed()) {
    291     return isolate->StackOverflow();
    292   }
    293 
    294   return isolate->stack_guard()->HandleInterrupts();
    295 }
    296 
    297 
    298 RUNTIME_FUNCTION(Runtime_Interrupt) {
    299   SealHandleScope shs(isolate);
    300   DCHECK(args.length() == 0);
    301   return isolate->stack_guard()->HandleInterrupts();
    302 }
    303 
    304 
    305 RUNTIME_FUNCTION(Runtime_AllocateInNewSpace) {
    306   HandleScope scope(isolate);
    307   DCHECK(args.length() == 1);
    308   CONVERT_SMI_ARG_CHECKED(size, 0);
    309   CHECK(IsAligned(size, kPointerSize));
    310   CHECK(size > 0);
    311   CHECK(size <= Page::kMaxRegularHeapObjectSize);
    312   return *isolate->factory()->NewFillerObject(size, false, NEW_SPACE);
    313 }
    314 
    315 
    316 RUNTIME_FUNCTION(Runtime_AllocateInTargetSpace) {
    317   HandleScope scope(isolate);
    318   DCHECK(args.length() == 2);
    319   CONVERT_SMI_ARG_CHECKED(size, 0);
    320   CONVERT_SMI_ARG_CHECKED(flags, 1);
    321   CHECK(IsAligned(size, kPointerSize));
    322   CHECK(size > 0);
    323   CHECK(size <= Page::kMaxRegularHeapObjectSize);
    324   bool double_align = AllocateDoubleAlignFlag::decode(flags);
    325   AllocationSpace space = AllocateTargetSpace::decode(flags);
    326   return *isolate->factory()->NewFillerObject(size, double_align, space);
    327 }
    328 
    329 RUNTIME_FUNCTION(Runtime_AllocateSeqOneByteString) {
    330   HandleScope scope(isolate);
    331   DCHECK_EQ(1, args.length());
    332   CONVERT_SMI_ARG_CHECKED(length, 0);
    333   Handle<SeqOneByteString> result;
    334   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
    335       isolate, result, isolate->factory()->NewRawOneByteString(length));
    336   return *result;
    337 }
    338 
    339 RUNTIME_FUNCTION(Runtime_AllocateSeqTwoByteString) {
    340   HandleScope scope(isolate);
    341   DCHECK_EQ(1, args.length());
    342   CONVERT_SMI_ARG_CHECKED(length, 0);
    343   Handle<SeqTwoByteString> result;
    344   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
    345       isolate, result, isolate->factory()->NewRawTwoByteString(length));
    346   return *result;
    347 }
    348 
    349 // Collect the raw data for a stack trace.  Returns an array of 4
    350 // element segments each containing a receiver, function, code and
    351 // native code offset.
    352 RUNTIME_FUNCTION(Runtime_CollectStackTrace) {
    353   HandleScope scope(isolate);
    354   DCHECK(args.length() == 2);
    355   CONVERT_ARG_HANDLE_CHECKED(JSReceiver, error_object, 0);
    356   CONVERT_ARG_HANDLE_CHECKED(Object, caller, 1);
    357 
    358   if (!isolate->bootstrapper()->IsActive()) {
    359     // Optionally capture a more detailed stack trace for the message.
    360     RETURN_FAILURE_ON_EXCEPTION(
    361         isolate, isolate->CaptureAndSetDetailedStackTrace(error_object));
    362     // Capture a simple stack trace for the stack property.
    363     RETURN_FAILURE_ON_EXCEPTION(
    364         isolate, isolate->CaptureAndSetSimpleStackTrace(error_object, caller));
    365   }
    366   return isolate->heap()->undefined_value();
    367 }
    368 
    369 
    370 RUNTIME_FUNCTION(Runtime_MessageGetStartPosition) {
    371   SealHandleScope shs(isolate);
    372   DCHECK(args.length() == 1);
    373   CONVERT_ARG_CHECKED(JSMessageObject, message, 0);
    374   return Smi::FromInt(message->start_position());
    375 }
    376 
    377 
    378 RUNTIME_FUNCTION(Runtime_MessageGetScript) {
    379   SealHandleScope shs(isolate);
    380   DCHECK(args.length() == 1);
    381   CONVERT_ARG_CHECKED(JSMessageObject, message, 0);
    382   return message->script();
    383 }
    384 
    385 
    386 RUNTIME_FUNCTION(Runtime_FormatMessageString) {
    387   HandleScope scope(isolate);
    388   DCHECK(args.length() == 4);
    389   CONVERT_INT32_ARG_CHECKED(template_index, 0);
    390   CONVERT_ARG_HANDLE_CHECKED(String, arg0, 1);
    391   CONVERT_ARG_HANDLE_CHECKED(String, arg1, 2);
    392   CONVERT_ARG_HANDLE_CHECKED(String, arg2, 3);
    393   isolate->native_context()->IncrementErrorsThrown();
    394   RETURN_RESULT_OR_FAILURE(isolate, MessageTemplate::FormatMessage(
    395                                         template_index, arg0, arg1, arg2));
    396 }
    397 
    398 #define CALLSITE_GET(NAME, RETURN)                          \
    399   RUNTIME_FUNCTION(Runtime_CallSite##NAME##RT) {            \
    400     HandleScope scope(isolate);                             \
    401     DCHECK(args.length() == 1);                             \
    402     CONVERT_ARG_HANDLE_CHECKED(JSObject, call_site_obj, 0); \
    403     Handle<String> result;                                  \
    404     CallSite call_site(isolate, call_site_obj);             \
    405     CHECK(call_site.IsJavaScript() || call_site.IsWasm());  \
    406     return RETURN(call_site.NAME(), isolate);               \
    407   }
    408 
    409 static inline Object* ReturnDereferencedHandle(Handle<Object> obj,
    410                                                Isolate* isolate) {
    411   return *obj;
    412 }
    413 
    414 
    415 static inline Object* ReturnPositiveNumberOrNull(int value, Isolate* isolate) {
    416   if (value >= 0) return *isolate->factory()->NewNumberFromInt(value);
    417   return isolate->heap()->null_value();
    418 }
    419 
    420 
    421 static inline Object* ReturnBoolean(bool value, Isolate* isolate) {
    422   return isolate->heap()->ToBoolean(value);
    423 }
    424 
    425 
    426 CALLSITE_GET(GetFileName, ReturnDereferencedHandle)
    427 CALLSITE_GET(GetFunctionName, ReturnDereferencedHandle)
    428 CALLSITE_GET(GetScriptNameOrSourceUrl, ReturnDereferencedHandle)
    429 CALLSITE_GET(GetMethodName, ReturnDereferencedHandle)
    430 CALLSITE_GET(GetLineNumber, ReturnPositiveNumberOrNull)
    431 CALLSITE_GET(GetColumnNumber, ReturnPositiveNumberOrNull)
    432 CALLSITE_GET(IsNative, ReturnBoolean)
    433 CALLSITE_GET(IsToplevel, ReturnBoolean)
    434 CALLSITE_GET(IsEval, ReturnBoolean)
    435 CALLSITE_GET(IsConstructor, ReturnBoolean)
    436 
    437 #undef CALLSITE_GET
    438 
    439 
    440 RUNTIME_FUNCTION(Runtime_IS_VAR) {
    441   UNREACHABLE();  // implemented as macro in the parser
    442   return NULL;
    443 }
    444 
    445 
    446 namespace {
    447 
    448 bool ComputeLocation(Isolate* isolate, MessageLocation* target) {
    449   JavaScriptFrameIterator it(isolate);
    450   if (!it.done()) {
    451     JavaScriptFrame* frame = it.frame();
    452     JSFunction* fun = frame->function();
    453     Object* script = fun->shared()->script();
    454     if (script->IsScript() &&
    455         !(Script::cast(script)->source()->IsUndefined(isolate))) {
    456       Handle<Script> casted_script(Script::cast(script), isolate);
    457       // Compute the location from the function and the relocation info of the
    458       // baseline code. For optimized code this will use the deoptimization
    459       // information to get canonical location information.
    460       List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
    461       it.frame()->Summarize(&frames);
    462       FrameSummary& summary = frames.last();
    463       int pos = summary.abstract_code()->SourcePosition(summary.code_offset());
    464       *target = MessageLocation(casted_script, pos, pos + 1, handle(fun));
    465       return true;
    466     }
    467   }
    468   return false;
    469 }
    470 
    471 
    472 Handle<String> RenderCallSite(Isolate* isolate, Handle<Object> object) {
    473   MessageLocation location;
    474   if (ComputeLocation(isolate, &location)) {
    475     Zone zone(isolate->allocator());
    476     base::SmartPointer<ParseInfo> info(
    477         location.function()->shared()->is_function()
    478             ? new ParseInfo(&zone, location.function())
    479             : new ParseInfo(&zone, location.script()));
    480     if (Parser::ParseStatic(info.get())) {
    481       CallPrinter printer(isolate, location.function()->shared()->IsBuiltin());
    482       const char* string = printer.Print(info->literal(), location.start_pos());
    483       if (strlen(string) > 0) {
    484         return isolate->factory()->NewStringFromAsciiChecked(string);
    485       }
    486     } else {
    487       isolate->clear_pending_exception();
    488     }
    489   }
    490   return Object::TypeOf(isolate, object);
    491 }
    492 
    493 }  // namespace
    494 
    495 
    496 RUNTIME_FUNCTION(Runtime_ThrowCalledNonCallable) {
    497   HandleScope scope(isolate);
    498   DCHECK_EQ(1, args.length());
    499   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
    500   Handle<String> callsite = RenderCallSite(isolate, object);
    501   THROW_NEW_ERROR_RETURN_FAILURE(
    502       isolate, NewTypeError(MessageTemplate::kCalledNonCallable, callsite));
    503 }
    504 
    505 RUNTIME_FUNCTION(Runtime_ThrowCalledOnNullOrUndefined) {
    506   HandleScope scope(isolate);
    507   DCHECK_EQ(1, args.length());
    508   CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
    509   THROW_NEW_ERROR_RETURN_FAILURE(
    510       isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined, name));
    511 }
    512 
    513 RUNTIME_FUNCTION(Runtime_ThrowConstructedNonConstructable) {
    514   HandleScope scope(isolate);
    515   DCHECK_EQ(1, args.length());
    516   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
    517   Handle<String> callsite = RenderCallSite(isolate, object);
    518   THROW_NEW_ERROR_RETURN_FAILURE(
    519       isolate, NewTypeError(MessageTemplate::kNotConstructor, callsite));
    520 }
    521 
    522 
    523 RUNTIME_FUNCTION(Runtime_ThrowDerivedConstructorReturnedNonObject) {
    524   HandleScope scope(isolate);
    525   DCHECK_EQ(0, args.length());
    526   THROW_NEW_ERROR_RETURN_FAILURE(
    527       isolate, NewTypeError(MessageTemplate::kDerivedConstructorReturn));
    528 }
    529 
    530 
    531 // ES6 section 7.3.17 CreateListFromArrayLike (obj)
    532 RUNTIME_FUNCTION(Runtime_CreateListFromArrayLike) {
    533   HandleScope scope(isolate);
    534   DCHECK_EQ(1, args.length());
    535   CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
    536   RETURN_RESULT_OR_FAILURE(isolate, Object::CreateListFromArrayLike(
    537                                         isolate, object, ElementTypes::kAll));
    538 }
    539 
    540 
    541 RUNTIME_FUNCTION(Runtime_IncrementUseCounter) {
    542   HandleScope scope(isolate);
    543   DCHECK_EQ(1, args.length());
    544   CONVERT_SMI_ARG_CHECKED(counter, 0);
    545   isolate->CountUsage(static_cast<v8::Isolate::UseCounterFeature>(counter));
    546   return isolate->heap()->undefined_value();
    547 }
    548 
    549 RUNTIME_FUNCTION(Runtime_GetAndResetRuntimeCallStats) {
    550   HandleScope scope(isolate);
    551   if (args.length() == 0) {
    552     // Without arguments, the result is returned as a string.
    553     DCHECK_EQ(0, args.length());
    554     std::stringstream stats_stream;
    555     isolate->counters()->runtime_call_stats()->Print(stats_stream);
    556     Handle<String> result = isolate->factory()->NewStringFromAsciiChecked(
    557         stats_stream.str().c_str());
    558     isolate->counters()->runtime_call_stats()->Reset();
    559     return *result;
    560   } else {
    561     DCHECK_LE(args.length(), 2);
    562     std::FILE* f;
    563     if (args[0]->IsString()) {
    564       // With a string argument, the results are appended to that file.
    565       CONVERT_ARG_HANDLE_CHECKED(String, arg0, 0);
    566       String::FlatContent flat = arg0->GetFlatContent();
    567       const char* filename =
    568           reinterpret_cast<const char*>(&(flat.ToOneByteVector()[0]));
    569       f = std::fopen(filename, "a");
    570       DCHECK_NOT_NULL(f);
    571     } else {
    572       // With an integer argument, the results are written to stdout/stderr.
    573       CONVERT_SMI_ARG_CHECKED(fd, 0);
    574       DCHECK(fd == 1 || fd == 2);
    575       f = fd == 1 ? stdout : stderr;
    576     }
    577     // The second argument (if any) is a message header to be printed.
    578     if (args.length() >= 2) {
    579       CONVERT_ARG_HANDLE_CHECKED(String, arg1, 1);
    580       arg1->PrintOn(f);
    581       std::fputc('\n', f);
    582       std::fflush(f);
    583     }
    584     OFStream stats_stream(f);
    585     isolate->counters()->runtime_call_stats()->Print(stats_stream);
    586     isolate->counters()->runtime_call_stats()->Reset();
    587     if (args[0]->IsString())
    588       std::fclose(f);
    589     else
    590       std::fflush(f);
    591     return isolate->heap()->undefined_value();
    592   }
    593 }
    594 
    595 RUNTIME_FUNCTION(Runtime_EnqueueMicrotask) {
    596   HandleScope scope(isolate);
    597   DCHECK(args.length() == 1);
    598   CONVERT_ARG_HANDLE_CHECKED(JSFunction, microtask, 0);
    599   isolate->EnqueueMicrotask(microtask);
    600   return isolate->heap()->undefined_value();
    601 }
    602 
    603 RUNTIME_FUNCTION(Runtime_RunMicrotasks) {
    604   HandleScope scope(isolate);
    605   DCHECK(args.length() == 0);
    606   isolate->RunMicrotasks();
    607   return isolate->heap()->undefined_value();
    608 }
    609 
    610 RUNTIME_FUNCTION(Runtime_OrdinaryHasInstance) {
    611   HandleScope scope(isolate);
    612   DCHECK_EQ(2, args.length());
    613   CONVERT_ARG_HANDLE_CHECKED(Object, callable, 0);
    614   CONVERT_ARG_HANDLE_CHECKED(Object, object, 1);
    615   RETURN_RESULT_OR_FAILURE(
    616       isolate, Object::OrdinaryHasInstance(isolate, callable, object));
    617 }
    618 
    619 RUNTIME_FUNCTION(Runtime_IsWasmObject) {
    620   HandleScope scope(isolate);
    621   DCHECK_EQ(1, args.length());
    622   CONVERT_ARG_CHECKED(Object, object, 0);
    623   bool is_wasm_object =
    624       object->IsJSObject() && wasm::IsWasmObject(JSObject::cast(object));
    625   return *isolate->factory()->ToBoolean(is_wasm_object);
    626 }
    627 
    628 }  // namespace internal
    629 }  // namespace v8
    630