Lines Matching defs:object
64 // Cast the given object to a value of the specified type and store
65 // it in a variable with the given name. If the object is not of the
75 // Cast the given object to a boolean and store it in a variable with
76 // the given name. If the object is not a boolean call IllegalOperation
82 // Cast the given object to a Smi and store its value in an int variable
83 // with the given name. If the object is not a Smi call IllegalOperation
89 // Cast the given object to a double and store it in a variable with
90 // the given name. If the object is not a number (as opposed to
96 // Call the specified converter on the object *comand store the result in
98 // object is not a Number call IllegalOperation and return.
110 Object* result;
120 Object* value = properties->get(i);
131 Object* value = copy->InObjectPropertyAt(i);
152 // Only deep copy fields from the object literal expression.
156 Object* value =
164 // Creating object copy for literals. No strict mode needed.
173 // Pixel elements cannot be created using an object literal.
187 Object* value = elements->get(i);
204 Object* k = element_dictionary->KeyAt(i);
206 Object* value = element_dictionary->ValueAt(i);
250 Object* key = constant_properties->get(p);
275 Object* key = constant_properties->get(p);
293 static Handle<Object> CreateLiteralBoilerplate(
299 static Handle<Object> CreateObjectLiteralBoilerplate(
306 // context in which the function was created and we use the object
307 // function from this context to create the object literal. We do
308 // not use the object function from the current global context
309 // because this might be the object function from another context
314 // In case we have function literals, we want the object to be in
335 // Normalize the properties of object to avoid n^2 behavior
336 // when extending the object multiple properties. Indicate the number of
342 Handle<Object> key(constant_properties->get(index+0), isolate);
343 Handle<Object> value(constant_properties->get(index+1), isolate);
346 // simple object or array literal.
351 Handle<Object> result;
391 // Transform to fast properties if necessary. For object literals with
404 static Handle<Object> CreateArrayLiteralBoilerplate(
411 Handle<Object> object = isolate->factory()->NewJSObject(constructor);
430 // simple object or array literal.
432 Handle<Object> result =
441 Handle<JSArray>::cast(object)->SetContent(*content);
442 return object;
446 static Handle<Object> CreateLiteralBoilerplate(
469 return Handle<Object>::null();
486 Handle<Object> object =
488 if (object.is_null()) return Failure::Exception();
491 literals->set(literals_index, *object);
492 return *object;
507 Handle<Object> boilerplate(literals->get(literals_index), isolate);
533 Handle<Object> boilerplate(literals->get(literals_index), isolate);
556 Handle<Object> boilerplate(literals->get(literals_index), isolate);
575 Handle<Object> boilerplate(literals->get(literals_index), isolate);
593 Object* value = args[1];
594 // Create a catch context extension object.
598 Object* object;
600 if (!maybe_object->ToObject(&object)) return maybe_object;
606 JSObject::cast(object)->SetProperty(
610 return object;
617 Object* obj = args[0];
627 Object* O = args[0];
628 Object* V = args[1];
630 Object* prototype = V->GetPrototype();
638 // Inserts an object as the hidden prototype of another object.
653 Object* map_or_failure;
668 // Set proto's prototype to be the old prototype of the object.
673 // Set the object's prototype to proto.
696 Object* proto = obj->GetPrototype();
708 Object* callback = result->GetCallbackObject();
758 // If the object has an interceptor, try real named properties.
828 // 15.5.5.2. Note that this might be a string object with elements
846 Handle<Object> value = GetElement(obj, index);
858 Object* proto = obj->GetPrototype();
884 Handle<Object> value = GetElement(obj, index);
934 Object* value;
957 Object* proto = obj->GetPrototype();
973 Handle<Object> result = RegExpImpl::Compile(re, pattern, flags);
989 Object* arg = args[0];
1016 CONVERT_CHECKED(HeapObject, object, args[0]);
1017 Map* old_map = object->map();
1021 Object* new_map;
1027 object->set_map(Map::cast(new_map));
1036 CONVERT_CHECKED(HeapObject, object, args[0]);
1037 Map* old_map = object->map();
1040 Object* new_map;
1046 object->set_map(Map::cast(new_map));
1056 Handle<Object> type_handle =
1058 Handle<Object> args[2] = { type_handle, name };
1059 Handle<Object> error =
1089 Handle<Object> value(pairs->get(i + 1), isolate);
1097 // Lookup the property in the global object, and don't set the
1103 // against the global object. The information will be used to
1217 Handle<Object> initial_value(args[3], isolate);
1225 Handle<Object> holder =
1243 // the function context or the arguments object.
1251 // The holder is an arguments object.
1253 Handle<Object> result = SetElement(arguments, index, initial_value,
1289 Handle<Object> value(isolate->heap()->undefined_value(), isolate);
1336 // Lookup the property locally in the global object. If it isn't
1386 Object* value = (assign) ? args[2] : isolate->heap()->undefined_value();
1391 Object* proto = real_holder->GetPrototype();
1415 Handle<Object> value = args.at<Object>(1);
1417 // Get the current global object from top.
1425 // Lookup the property locally in the global object. If it isn't
1454 // Restore global object from context (in case of GC) and continue
1503 Handle<Object> value(args[0], isolate);
1514 Handle<Object> holder =
1518 // declaration should be present in the context extension object.
1540 // The holder is an arguments object.
1562 // The property was present in a context extension object.
1592 // The property was found in a different context extension object.
1610 CONVERT_ARG_CHECKED(JSObject, object, 0);
1612 if (object->HasFastProperties()) {
1613 NormalizeProperties(object, KEEP_INOBJECT_PROPERTIES, properties);
1615 return *object;
1632 Handle<Object> result = RegExpImpl::Exec(regexp,
1647 Object* new_object;
1667 // Write in-object properties after the length of the array.
1680 Object* global = args[2];
1683 Object* ignoreCase = args[3];
1686 Object* multiline = args[4];
1690 Object* constructor = map->constructor();
1693 // If we still have the original map, set in-object properties directly.
1787 // Returns a real global receiver, not one of builtins object.
1812 Handle<Object> regexp =
1849 Object* obj = f->RemovePrototype();
1861 Handle<Object> script = Handle<Object>(fun->shared()->script(), isolate);
1928 Object* obj;
1962 Handle<Object> code = args.at<Object>(1);
1988 // Array, and Object, and some web code
2003 // Insert the object, regexp and array functions in the literals
2005 // creating object, regexp and array literals.
2032 Object* char_code) {
2048 Object* index = args[1];
2065 Object* flat;
2125 void Add(Object* value) {
2295 void AddElement(Object* element) {
2589 Handle<Object> match = RegExpImpl::Exec(regexp_handle,
2697 Handle<Object> match = RegExpImpl::Exec(regexp_handle,
2818 Object* flat_subject;
2829 Object* flat_replacement;
2922 Object* index = args[2];
2974 Object* index = args[2];
3077 Object* from = args[1];
3078 Object* to = args[2];
3107 Handle<Object> match = RegExpImpl::Exec(regexp, subject, 0, regexp_info);
3636 static Handle<Object> GetCharAt(Handle<String> string, uint32_t index) {
3647 Handle<Object> object,
3650 if (object->IsString()) {
3651 Handle<Object> result = GetCharAt(Handle<String>::cast(object), index);
3656 if (object->IsStringObjectWithCharacterAt(index)) {
3657 Handle<JSValue> js_value = Handle<JSValue>::cast(object);
3658 Handle<Object> result =
3663 if (object->IsString() || object->IsNumber() || object->IsBoolean()) {
3664 Handle<Object> prototype = GetPrototype(object);
3668 return GetElement(object, index);
3672 MaybeObject* Runtime::GetElement(Handle<Object> object, uint32_t index) {
3673 return object->GetElement(index);
3678 Handle<Object> object,
3679 Object> key) {
3682 if (object->IsUndefined() || object->IsNull()) {
3683 Handle<Object> args[2] = { key, object };
3684 Handle<Object> error =
3693 return GetElementOrCharAt(isolate, object, index);
3702 Handle<Object> converted =
3711 return GetElementOrCharAt(isolate, object, index);
3714 return object->GetProperty(*name, &attr);
3723 Handle<Object> object = args.at<Object>(0);
3724 Handle<Object> key = args.at<Object>(1);
3726 return Runtime::GetObjectProperty(isolate, object, key);
3739 // the global proxy object can return a valid result even though the
3740 // global proxy object never has properties. This is the case
3741 // because the global proxy object forwards everything to its hidden
3758 Object* value = receiver->FastPropertyAt(offset);
3775 Object* value = dictionary->ValueAt(entry);
3788 Handle<Object> result = GetCharAt(str, index);
3795 args.at<Object>(0),
3796 args.at<Object>(1));
3811 Object* fun = args[3];
3827 Object* ok;
3847 Handle<Object> obj_value = args.at<Object>(2);
3868 Handle<Object> proto(js_object->GetPrototype());
3925 Handle<Object> object,
3926 Handle<Object> key,
3927 Handle<Object> value,
3932 if (object->IsUndefined() || object->IsNull()) {
3933 Handle<Object> args[2] = { key, object };
3934 Handle<Object> error =
3940 // If the object isn't a JavaScript object, we ignore the store.
3941 if (!object->IsJSObject()) return *value;
3943 Handle<JSObject> js_object = Handle<JSObject>::cast(object);
3951 // In the case of a String object we just need to redirect the assignment to
3959 Handle<Object> result = SetElement(js_object, index, value, strict_mode);
3965 Handle<Object> result;
3979 Handle<Object> converted = Execution::ToString(key, &has_pending_exception);
3993 Handle<Object> key,
3994 Handle<Object> value,
4004 // In the case of a String object we just need to redirect the assignment to
4029 Handle<Object> converted = Execution::ToString(key, &has_pending_exception);
4043 Handle<Object> key) {
4051 // String object we just need to redirect the deletion to the
4068 Handle<Object> converted = Execution::ToString(key, &has_pending_exception);
4082 Handle<Object> object = args.at<Object>(0);
4083 Handle<Object> key = args.at<Object>(1);
4084 Handle<Object> value = args.at<Object>(2);
4101 object,
4114 CONVERT_CHECKED(JSObject, object, args[0]);
4127 return object->
4136 CONVERT_CHECKED(JSObject, object, args[0]);
4139 return object->DeleteProperty(key, (strict == kStrictMode)
4145 static Object* HasLocalPropertyImplementation(Isolate* isolate,
4146 Handle<JSObject> object,
4148 if (object->HasLocalProperty(*key)) return isolate->heap()->true_value();
4151 // look like they are on this object.
4152 Handle<Object> proto(object->GetPrototype());
4168 Object* obj = args[0];
4171 JSObject* object = JSObject::cast(obj);
4173 if (object->HasRealNamedProperty(key)) return isolate->heap()->true_value();
4178 Handle<JSObject>(object),
4199 JSObject* object = JSObject::cast(args[0]);
4201 if (object->HasProperty(key)) return isolate->heap()->true_value();
4213 JSObject* object = JSObject::cast(args[0]);
4216 if (object->HasElement(index)) return isolate->heap()->true_value();
4226 CONVERT_CHECKED(JSObject, object, args[0]);
4231 return isolate->heap()->ToBoolean(object->HasElement(index));
4234 PropertyAttributes att = object->GetLocalPropertyAttribute(key);
4242 CONVERT_ARG_CHECKED(JSObject, object, 0);
4243 return *GetKeysFor(object);
4248 // or, if the given object has an enum cache that contains
4249 // all enumerable properties of the object and its prototypes
4250 // have none, the map of the object. This is used to speed up
4260 Handle<JSObject> object(raw_object);
4261 Handle<FixedArray> content = GetKeysInFixedArrayFor(object,
4265 if (object->IsSimpleEnum()) return object->map();
4272 // prototype object is hidden it is to be viewed as part of the the object it
4276 Object* proto = obj->GetPrototype();
4287 // args[0]: object
4297 // real global object.
4354 // Filter out name of hidden propeties object.
4361 Object* name = old_names->get(i);
4374 // args[0]: object
4390 // Return information on whether an object has a named or indexed interceptor.
4391 // args[0]: object
4409 // args[0]: object
4424 // args[0]: object
4442 Handle<JSObject> object(raw_object);
4444 if (object->IsJSGlobalProxy()) {
4445 // Do access checks before going to the global object.
4446 if (object->IsAccessCheckNeeded() &&
4447 !isolate->MayNamedAccess(*object, isolate->heap()->undefined_value(),
4449 isolate->ReportFailedAccessCheck(*object, v8::ACCESS_KEYS);
4453 Handle<Object> proto(object->GetPrototype());
4456 object = Handle<JSObject>::cast(proto);
4459 Handle<FixedArray> contents = GetKeysInFixedArrayFor(object,
4467 Object* entry = contents->get(i);
4473 Handle<Object> entry_handle(entry, isolate);
4474 Handle<Object> entry_str =
4505 Handle<Object> converted =
4506 Execution::ToString(args.at<Object>(0), &exception);
4522 Object* function = frame->function();
4526 "strict_arguments_callee", HandleVector<Object>(NULL, 0)));
4531 // Lookup in the initial Object.prototype object.
4540 Handle<Object> object = args.at<Object>(0);
4541 if (object->IsJSObject()) {
4542 Handle<JSObject> js_object = Handle<JSObject>::cast(object);
4548 return *object;
4556 Handle<Object> object = args.at<Object>(0);
4557 if (object->IsJSObject() && !object->IsJSGlobalProxy()) {
4558 Handle<JSObject> js_object = Handle<JSObject>::cast(object);
4561 return *object;
4578 Object* obj = args[0];
4582 // typeof an undetectable object is 'undefined'
4605 // For any kind of object not handled above, the spec rule for
4606 // host objects gives that it is okay to return "object"
4699 Object* element;
4717 Object* object = NULL;
4718 if (!maybe_object->ToObject(&object)) return maybe_object;
4719 String* result = String::cast(object);
4721 Object* element;
4804 Object* o;
4911 Object* o;
5033 Object* new_object;
5076 Object* new_object;
5137 Object* flat;
5159 Object* flat;
5197 // Create a number object from the value.
5220 Object* o;
5259 // the result string is the last object allocated we could
5454 Object* o;
5464 Object* answer;
5654 Object* undefined = heap->undefined_value();
5657 Object* value = ascii_cache->get(chars[i]);
5668 Object* element = elements->get(j);
5690 Object* obj;
5706 Handle<Object> str = LookupSingleCharacterStringFromCode(chars[i]);
5712 Handle<Object> str = LookupSingleCharacterStringFromCode(s->Get(i));
5746 Object* number = args[0];
5757 Object* number = args[0];
5826 Object* obj = args[0];
5913 // NumberFromDouble may return a Smi instead of a Number object
5935 Object* element = fixed_array->get(i);
5947 Object* obj = fixed_array->get(++i);
5993 Object* first = fixed_array->get(0);
6001 Object* elt = fixed_array->get(i);
6019 Object* next_smi = fixed_array->get(i);
6052 Object* object;
6057 if (!maybe_object->ToObject(&object)) return maybe_object;
6059 SeqAsciiString* answer = SeqAsciiString::cast(object);
6068 if (!maybe_object->ToObject(&object)) return maybe_object;
6070 SeqTwoByteString* answer = SeqTwoByteString::cast(object);
6102 Object* first = fixed_array->get(0);
6115 Object* element_obj = fixed_array->get(i);
6129 Object* object;
6132 if (!maybe_object->ToObject(&object)) return maybe_object;
6134 SeqTwoByteString* answer = SeqTwoByteString::cast(object);
6242 Object* result;
6345 static Object* StringInputBufferCompare(RuntimeState* state,
6365 static Object* FlatStringCompare(String* x, String* y) {
6368 Object* equal_prefix_result = Smi::FromInt(EQUAL);
6396 Object* result;
6430 Object* obj;
7022 Object** parameters = reinterpret_cast<Object**>(args[1]);
7025 Object* result;
7033 Object* obj;
7073 static SmartPointer<Object**> GetNonBoundArguments(int bound_argc,
7090 SmartPointer<Object**> param_data(NewArray<Object**>(*total_argc));
7092 Handle<Object> val = args_slots[i].GetValue();
7102 SmartPointer<Object**> param_data(NewArray<Object**>(*total_argc));
7104 Handle<Object> val = Handle<Object>(frame->GetParameter(i));
7129 SmartPointer<Object**> param_data =
7132 Handle<Object> val = Handle<Object>(bound_args->get(i));
7137 Handle<Object> result =
7150 Handle<Object> prototype = isolate->factory()->null_value();
7152 prototype = Handle<Object>(function->instance_prototype(), isolate);
7169 Handle<Object> constructor = args.at<Object>(0);
7173 Vector< Handle<Object> > arguments = HandleVector(&constructor, 1);
7174 Handle<Object> type_error =
7184 Vector< Handle<Object> > arguments = HandleVector(&constructor, 1);
7185 Handle<Object> type_error =
7194 debug->HandleStepIn(function, Handle<Object>::null(), 0, true);
7200 // The 'Function' function ignores the receiver object when
7201 // called using 'new' and creates a new JSFunction object that
7202 // is returned. The receiver object is only used for error
7207 // ignored anyway, we use the global object as the receiver
7208 // instead of a new JSFunction object. This way, errors are
7339 Handle<Object> arguments;
7345 arguments = Handle<Object>(
7426 // We're not prepared to handle a function with arguments object.
7430 // selected for on-stack replacement. Find the unoptimized code object.
7539 return *Execution::GetFunctionDelegate(args.at<Object>(0));
7547 return *Execution::GetConstructorDelegate(args.at<Object>(0));
7557 Object* result;
7570 Object* object,
7572 // Convert the object to a proper JavaScript object.
7573 Object* js_object = object;
7581 Handle<Object> handle(object, isolate);
7582 Handle<Object> result =
7589 Object* result;
7626 Handle<Object> holder = context->Lookup(name, flags, &index, &attributes);
7638 // The slot was found in a JSObject, either a context extension object,
7639 // the global object, or an arguments object. Try to delete it
7643 // arguments object. The slot was found on an arguments object if the
7645 Handle<JSObject> object = Handle<JSObject>::cast(holder);
7647 return object->DeleteElement(index, JSObject::NORMAL_DELETION);
7649 return object->DeleteProperty(*name, JSObject::NORMAL_DELETION);
7654 // A mechanism to return a pair of Object pointers in registers (if possible).
7699 // If the holder isn't a context extension object, we just return it
7703 Object* constructor = holder->map()->constructor();
7705 // Fall back to using the global object as the receiver if the
7707 // extension object - introduced via eval.
7727 Handle<Object> holder = context->Lookup(name, flags, &index, &attributes);
7730 // variable or a parameter. Read it from the context object or the
7731 // arguments object.
7734 // argument in a context, the receiver is the global object; see
7747 JSObject* object = JSObject::cast(*holder);
7749 if (object->IsGlobalObject()) {
7750 receiver = GlobalObject::cast(object)->global_receiver();
7754 receiver = ComputeReceiverForNonGlobal(isolate, object);
7758 MaybeObject* value = object->GetProperty(*name);
7764 Handle<Object> reference_error =
7790 Handle<Object> value(args[0], isolate);
7801 Handle<Object> holder = context->Lookup(name, flags, &index, &attributes);
7811 Handle<Object> error =
7818 Handle<Object> result =
7841 Handle<Object> error =
7852 // extension object itself.
7860 Handle<Object> error =
7895 Handle<Object> name(args[0], isolate);
7896 Handle<Object> reference_error =
7929 static void PrintObject(Object* obj) {
7959 static void PrintTransition(Object* result) {
7975 Object* fun = frame->function();
8061 // the number in a Date object representing a particular instant in
8132 Object* global = args[0];
8143 Handle<Object> result = JsonParser::Parse(source);
8175 Handle<Object> receiver,
8196 Handle<Object> callee = args.at<Object>(0);
8197 Handle<Object> receiver; // Will be overwritten.
8231 Handle<Object> name = isolate->factory()->eval_symbol();
8232 Handle<Object> reference_error =
8243 receiver = Handle<Object>(context->get(index), isolate);
8262 args.at<Object>(2),
8272 Handle<Object> callee = args.at<Object>(0);
8285 args.at<Object>(2),
8293 // object ("new Function(...)") by changing the map.
8323 Object* allocation;
8333 // Push an object unto an array of objects if it is not already in the
8346 Object* obj;
8382 void visit(uint32_t i, Handle<Object> elm) {
8419 Handle<Object> length =
8443 Handle<Object> element(current_storage->get(i));
8459 Handle<Object>::cast(storage_).location());
8496 Handle<Object> key(dictionary->KeyAt(i));
8540 Handle<Object> e =
8549 Handle<Object> e = isolate->factory()->NewNumber(array->get(j));
8564 static void CollectElementIndices(Handle<JSObject> object,
8567 JSObject::ElementsKind kind = object->GetElementsKind();
8570 Handle<FixedArray> elements(FixedArray::cast(object->elements()));
8581 Handle<NumberDictionary> dict(NumberDictionary::cast(object->elements()));
8585 Handle<Object> k(dict->KeyAt(j));
8601 ExternalPixelArray::cast(object->elements())->length();
8606 ExternalByteArray::cast(object->elements())->length();
8611 ExternalUnsignedByteArray::cast(object->elements())->length();
8616 ExternalShortArray::cast(object->elements())->length();
8621 ExternalUnsignedShortArray::cast(object->elements())->length();
8626 ExternalIntArray::cast(object->elements())->length();
8631 ExternalUnsignedIntArray::cast(object->elements())->length();
8636 ExternalFloatArray::cast(object->elements())->length();
8659 Handle<Object> prototype(object->GetPrototype());
8691 Handle<Object> element_value(elements->get(j), isolate);
8707 // Collect all indices in the object and the prototypes less
8716 Handle<Object> element = GetElement(receiver, index);
8804 Handle<Object> obj(elements->get(i));
8855 Handle<Object> obj(elements->get(i));
8886 // Moves all own elements of an object, that are below a limit, to positions
8893 CONVERT_CHECKED(JSObject, object, args[0]);
8895 return object->PrepareElementsForSort(limit);
8912 Object* new_map;
8917 Object* obj;
8926 // How many elements does this object/array have?
8929 CONVERT_CHECKED(JSObject, object, args[0]);
8930 HeapObject* elements = object->elements();
8933 } else if (object->IsJSArray()) {
8934 return JSArray::cast(object)->length();
8946 CONVERT_ARG_CHECKED(JSObject, object, 0);
8947 Handle<Object> key1 = args.at<Object>(1);
8948 Handle<Object> key2 = args.at<Object>(2);
8956 Handle<JSObject> jsobject = Handle<JSObject>::cast(object);
8957 Handle<Object> tmp1 = GetElement(jsobject, index1);
8959 Handle<Object> tmp2 = GetElement(jsobject, index2);
8975 // Intervals can span over some keys that are not in the object.
8987 Object* key = keys->get(i);
9003 Handle<Object> length_object =
9067 // args[1]: object supplied during callback
9073 Handle<Object> callback = args.at<Object>(0);
9074 Handle<Object> data = args.at<Object>(1);
9089 Object* receiver,
9093 Object* value;
9112 Object* structure = result->GetCallbackObject();
9145 // Get debugger related details for an object property.
9146 // args[0]: object holding property
9177 // real global object.
9188 Object* element_or_char;
9209 // LookupResult is not GC safe as it holds raw object pointers.
9213 Handle<Object> result_callback_obj;
9215 result_callback_obj = Handle<Object>(result.GetCallbackObject(),
9222 Object* raw_value;
9228 Handle<Object> value(raw_value, isolate);
9230 // If the callback object is a fixed array then it contains JavaScript
9305 // args[0]: object
9320 // args[0]: object
9352 Object* result;
9403 Object* check;
9437 Handle<Object> frame_id(WrapFrameId(it.frame()->id()), isolate);
9501 Handle<Object> return_value = isolate->factory()->undefined_value();
9517 Handle<Object>(Memory::Object_at(internal_frame_sp),
9619 Handle<Object> receiver(it.frame()->receiver(), isolate);
9622 // where a value object is not converted into a wrapped JS objects.
9624 // by creating correct wrapper object based on the calling frame's
9639 // Copy all the context locals into an object used to materialize a scope.
9660 Handle<Object>(context->get(context_index), isolate),
9691 Handle<Object>(frame->GetParameter(i), isolate),
9703 Handle<Object>(frame->GetExpression(i), isolate),
9759 // Check whether the arguments shadow object exists.
9765 // object.
9770 Object* element = arguments_shadow->GetElement(i)->ToObjectUnchecked();
9775 Handle<Object>(element, isolate),
9825 // holding exception object. Such with blocks are treated as scopes of their
9843 // saved with the code object does not otherwise have that information.
9910 // If the extension object here is a JSContextExtensionObject then
9919 // Return the JavaScript object with the content of the current scope.
9931 // Return the with object.
10031 Object* check;
10064 // 1: Scope object
10070 Object* check;
10128 Object* result;
10164 Object* check;
10225 Handle<Object> break_locations = Debug::GetSourceBreakLocations(shared);
10236 // args[2]: number: break point object
10244 Handle<Object> break_point_object_arg = args.at<Object>(2);
10254 Object* Runtime::FindSharedFunctionInfoInScript(Isolate* isolate,
10337 // args[2]: number: break point object
10344 Handle<Object> break_point_object_arg = args.at<Object>(2);
10350 Object* result = Runtime::FindSharedFunctionInfoInScript(
10371 // args[0]: number: break point object
10375 Handle<Object> break_point_object_arg = args.at<Object>(0);
10426 Object* check;
10488 // Helper function to find or create the arguments object for
10490 static Handle<Object> GetArgumentsObject(Isolate* isolate,
10498 // does not support eval) then create an 'arguments' object.
10503 return Handle<Object>(frame->GetExpression(index), isolate);
10511 return Handle<Object>(function_context->get(index), isolate);
10551 Object* check_result;
10561 Handle<Object> additional_context(args[4]);
10589 // are looked at before the extension object.
10605 // object build.
10643 Handle<Object> receiver(frame->receiver(), isolate);
10644 Handle<Object> evaluation_function =
10649 Handle<Object> arguments = GetArgumentsObject(isolate, frame,
10655 Object** argv[argc] = { arguments.location(),
10656 Handle<Object>::cast(source).location() };
10657 Handle<Object> result =
10663 // real global object.
10678 Object* check_result;
10687 Handle<Object> additional_context(args[3]);
10734 Handle<Object> receiver = isolate->global();
10735 Object> result =
10772 Object* instance_filter, int max_references,
10795 // Check if the JS object has a reference to the object looked for.
10800 Object* V = obj;
10802 Object* prototype = V->GetPrototype();
10807 obj = NULL; // Don't add this object.
10827 // Check for circular reference only. This can happen when the object is only
10829 // object is not really alive and would have been garbage collected if not
10840 // Scan the heap for objects with direct references to an object
10841 // args[0]: the object to find references to
10852 Object* instance_filter = args[1];
10870 Object* object;
10872 if (!maybe_object->ToObject(&object)) return maybe_object;
10874 FixedArray* instances = FixedArray::cast(object);
10881 Object* result;
10940 Object* object;
10942 if (!maybe_object->ToObject(&object)) return maybe_object;
10944 FixedArray* instances = FixedArray::cast(object);
10950 Object* result;
10960 // Find the effective prototype object as returned by __proto__.
10961 // args[0]: the object to find the prototype for.
11104 Handle<Object> old_script_name(args[2], isolate);
11110 Object* old_script = LiveEdit::ChangeScriptSource(original_script,
11145 Handle<Object> function_object(args[0], isolate);
11146 Handle<Object> script_object(args[1], isolate);
11152 script_object = Handle<Object>(script, isolate);
11165 // In a code of a parent function replaces original function as embedded object
11268 Handle<Object> result;
11316 // Captures a live object list from the present heap.
11326 // Captures a live object list from the present heap.
11336 // Deletes the specified live object list.
11350 // contained in the difference between the captured live object lists
11370 // Gets the specified object as requested by the debugger.
11371 // This is only used for obj ids shown in live object lists.
11375 Object* result = LiveObjectList::GetObj(obj_id);
11384 // This is only used for obj ids shown in live object lists.
11389 Object* result = LiveObjectList::GetObjId(address);
11397 // Gets the retainers that references the specified object alive.
11450 Object* result =
11460 // previously captured live object lists.
11472 // Gets a dump of the specified object as requested by the debugger.
11473 // This is only used for obj ids shown in live object lists.
11478 Object* result = LiveObjectList::PrintObj(obj_id);
11486 // Resets and releases all previously captured live object lists.
11498 // of objects in the difference between the captured live object lists
11543 // Finds the script object from the script data. NOTE: This operation uses
11549 static Handle<Object> Runtime_GetScriptFromScriptName(
11575 // Get the script object from script data. NOTE: Regarding performance
11586 Handle<Object> result =
11598 static bool ShowFrameInStackTrace(StackFrame* raw_frame, Object* caller,
11604 Object* raw_fun = frame->function();
11625 Handle<Object> caller = args.at<Object>(0);
11663 Handle<Object> recv = frames[i].receiver();
11708 Object* key = args[1];
11711 Object* o = cache->get(finger_index);
11742 Handle<Object> key_handle(key);
11743 Handle<Object> value;
11748 Handle<Object> receiver(isolate->global_context()->global());
11750 Object** argv[] = { key_handle.location() };
11919 Object* dictionary) {
11924 Object* name_symbol;
11949 Object* smi_index = heap->intrinsic_function_names()->ValueAt(entry);
11962 void Runtime::PerformGC(Object* result) {
