v8::internal::Runtime Class Reference

#include <runtime.h>

Inheritance diagram for v8::internal::Runtime:

Collaboration diagram for v8::internal::Runtime:

Classes
struct	Function

Public Types
enum	FunctionId { RUNTIME_FUNCTION_LIST , kFirstInlineFunction = kInlineIsSmi }
enum	IntrinsicType { RUNTIME , INLINE , INLINE_OPTIMIZED }
enum	TypedArrayId {   ARRAY_ID_UINT8 = 1 , ARRAY_ID_INT8 = 2 , ARRAY_ID_UINT16 = 3 , ARRAY_ID_INT16 = 4 ,   ARRAY_ID_UINT32 = 5 , ARRAY_ID_INT32 = 6 , ARRAY_ID_FLOAT32 = 7 , ARRAY_ID_FLOAT64 = 8 ,   ARRAY_ID_UINT8_CLAMPED = 9 , ARRAY_ID_FIRST = ARRAY_ID_UINT8 , ARRAY_ID_LAST = ARRAY_ID_UINT8_CLAMPED }

Static Public Member Functions
static void	InitializeIntrinsicFunctionNames (Isolate *isolate, Handle< NameDictionary > dict)
static const Function *	FunctionForName (Handle< String > name)
static const Function *	FunctionForId (FunctionId id)
static const Function *	FunctionForEntry (Address ref)
static int	StringMatch (Isolate *isolate, Handle< String > sub, Handle< String > pat, int index)
static MUST_USE_RESULT MaybeHandle< Object >	GetElementOrCharAt (Isolate *isolate, Handle< Object > object, uint32_t index)
static MUST_USE_RESULT MaybeHandle< Object >	SetObjectProperty (Isolate *isolate, Handle< Object > object, Handle< Object > key, Handle< Object > value, StrictMode strict_mode)
static MUST_USE_RESULT MaybeHandle< Object >	DefineObjectProperty (Handle< JSObject > object, Handle< Object > key, Handle< Object > value, PropertyAttributes attr)
static MUST_USE_RESULT MaybeHandle< Object >	DeleteObjectProperty (Isolate *isolate, Handle< JSReceiver > object, Handle< Object > key, JSReceiver::DeleteMode mode)
static MUST_USE_RESULT MaybeHandle< Object >	HasObjectProperty (Isolate *isolate, Handle< JSReceiver > object, Handle< Object > key)
static MUST_USE_RESULT MaybeHandle< Object >	GetObjectProperty (Isolate *isolate, Handle< Object > object, Handle< Object > key)
static void	SetupArrayBuffer (Isolate *isolate, Handle< JSArrayBuffer > array_buffer, bool is_external, void *data, size_t allocated_length)
static bool	SetupArrayBufferAllocatingData (Isolate *isolate, Handle< JSArrayBuffer > array_buffer, size_t allocated_length, bool initialize=true)
static void	NeuterArrayBuffer (Handle< JSArrayBuffer > array_buffer)
static void	FreeArrayBuffer (Isolate *isolate, JSArrayBuffer *phantom_array_buffer)
static void	ArrayIdToTypeAndSize (int array_id, ExternalArrayType *type, ElementsKind *external_elements_kind, ElementsKind *fixed_elements_kind, size_t *element_size)
static MUST_USE_RESULT MaybeHandle< Object >	CreateArrayLiteralBoilerplate (Isolate *isolate, Handle< FixedArray > literals, Handle< FixedArray > elements)

Static Public Attributes
static const int	kNotFound = -1

Detailed Description

Definition at line 772 of file runtime.h.

Member Enumeration Documentation

FunctionId

enum v8::internal::Runtime::FunctionId

Enumerator
RUNTIME_FUNCTION_LIST
kFirstInlineFunction

Definition at line 774 of file runtime.h.

                  {
#define F(name, nargs, ressize) k##name,
    RUNTIME_FUNCTION_LIST(F) INLINE_OPTIMIZED_FUNCTION_LIST(F)
#undef F
#define F(name, nargs, ressize) kInline##name,
    INLINE_FUNCTION_LIST(F)
#undef F
#define F(name, nargs, ressize) kInlineOptimized##name,
    INLINE_OPTIMIZED_FUNCTION_LIST(F)
#undef F
    kNumFunctions,
    kFirstInlineFunction = kInlineIsSmi
  };

IntrinsicType

enum v8::internal::Runtime::IntrinsicType

Enumerator
RUNTIME
INLINE
INLINE_OPTIMIZED

Definition at line 788 of file runtime.h.

{ RUNTIME, INLINE, INLINE_OPTIMIZED };

TypedArrayId

enum v8::internal::Runtime::TypedArrayId

Enumerator
ARRAY_ID_UINT8
ARRAY_ID_INT8
ARRAY_ID_UINT16
ARRAY_ID_INT16
ARRAY_ID_UINT32
ARRAY_ID_INT32
ARRAY_ID_FLOAT32
ARRAY_ID_FLOAT64
ARRAY_ID_UINT8_CLAMPED
ARRAY_ID_FIRST
ARRAY_ID_LAST

Definition at line 868 of file runtime.h.

                    {
    // arrayIds below should be synchromized with typedarray.js natives.
    ARRAY_ID_UINT8 = 1,
    ARRAY_ID_INT8 = 2,
    ARRAY_ID_UINT16 = 3,
    ARRAY_ID_INT16 = 4,
    ARRAY_ID_UINT32 = 5,
    ARRAY_ID_INT32 = 6,
    ARRAY_ID_FLOAT32 = 7,
    ARRAY_ID_FLOAT64 = 8,
    ARRAY_ID_UINT8_CLAMPED = 9,
    ARRAY_ID_FIRST = ARRAY_ID_UINT8,
    ARRAY_ID_LAST = ARRAY_ID_UINT8_CLAMPED
  };

Member Function Documentation

ArrayIdToTypeAndSize()

void v8::internal::Runtime::ArrayIdToTypeAndSize ( int  array_id, ExternalArrayType *  type, ElementsKind *  external_elements_kind, ElementsKind *  fixed_elements_kind, size_t *  element_size  )

static

Definition at line 186 of file runtime-typedarray.cc.

                                                         {
  switch (arrayId) {
#define ARRAY_ID_CASE(Type, type, TYPE, ctype, size)      \
  case ARRAY_ID_##TYPE:                                   \
    *array_type = kExternal##Type##Array;                 \
    *external_elements_kind = EXTERNAL_##TYPE##_ELEMENTS; \
    *fixed_elements_kind = TYPE##_ELEMENTS;               \
    *element_size = size;                                 \
    break;
 
    TYPED_ARRAYS(ARRAY_ID_CASE)
#undef ARRAY_ID_CASE
 
    default:
      UNREACHABLE();
  }
}

References ARRAY_ID_CASE, TYPED_ARRAYS, and UNREACHABLE.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

CreateArrayLiteralBoilerplate()

MaybeHandle< Object > v8::internal::Runtime::CreateArrayLiteralBoilerplate ( Isolate *  isolate, Handle< FixedArray >  literals, Handle< FixedArray >  elements  )

static

Definition at line 248 of file runtime.cc.

                                 {
  // Create the JSArray.
  Handle<JSFunction> constructor(
      JSFunction::NativeContextFromLiterals(*literals)->array_function());
 
  PretenureFlag pretenure_flag =
      isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
 
  Handle<JSArray> object = Handle<JSArray>::cast(
      isolate->factory()->NewJSObject(constructor, pretenure_flag));
 
  ElementsKind constant_elements_kind =
      static_cast<ElementsKind>(Smi::cast(elements->get(0))->value());
  Handle<FixedArrayBase> constant_elements_values(
      FixedArrayBase::cast(elements->get(1)));
 
  {
    DisallowHeapAllocation no_gc;
    DCHECK(IsFastElementsKind(constant_elements_kind));
    Context* native_context = isolate->context()->native_context();
    Object* maps_array = native_context->js_array_maps();
    DCHECK(!maps_array->IsUndefined());
    Object* map = FixedArray::cast(maps_array)->get(constant_elements_kind);
    object->set_map(Map::cast(map));
  }
 
  Handle<FixedArrayBase> copied_elements_values;
  if (IsFastDoubleElementsKind(constant_elements_kind)) {
    copied_elements_values = isolate->factory()->CopyFixedDoubleArray(
        Handle<FixedDoubleArray>::cast(constant_elements_values));
  } else {
    DCHECK(IsFastSmiOrObjectElementsKind(constant_elements_kind));
    const bool is_cow = (constant_elements_values->map() ==
                         isolate->heap()->fixed_cow_array_map());
    if (is_cow) {
      copied_elements_values = constant_elements_values;
#if DEBUG
      Handle<FixedArray> fixed_array_values =
          Handle<FixedArray>::cast(copied_elements_values);
      for (int i = 0; i < fixed_array_values->length(); i++) {
        DCHECK(!fixed_array_values->get(i)->IsFixedArray());
      }
#endif
    } else {
      Handle<FixedArray> fixed_array_values =
          Handle<FixedArray>::cast(constant_elements_values);
      Handle<FixedArray> fixed_array_values_copy =
          isolate->factory()->CopyFixedArray(fixed_array_values);
      copied_elements_values = fixed_array_values_copy;
      for (int i = 0; i < fixed_array_values->length(); i++) {
        if (fixed_array_values->get(i)->IsFixedArray()) {
          // The value contains the constant_properties of a
          // simple object or array literal.
          Handle<FixedArray> fa(FixedArray::cast(fixed_array_values->get(i)));
          Handle<Object> result;
          ASSIGN_RETURN_ON_EXCEPTION(
              isolate, result, CreateLiteralBoilerplate(isolate, literals, fa),
              Object);
          fixed_array_values_copy->set(i, *result);
        }
      }
    }
  }
  object->set_elements(*copied_elements_values);
  object->set_length(Smi::FromInt(copied_elements_values->length()));
 
  JSObject::ValidateElements(object);
  return object;
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), v8::internal::Isolate::context(), v8::internal::CreateLiteralBoilerplate(), DCHECK, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::Isolate::heap(), v8::internal::Heap::InNewSpace(), v8::internal::IsFastDoubleElementsKind(), v8::internal::IsFastElementsKind(), v8::internal::IsFastSmiOrObjectElementsKind(), literals(), map, v8::internal::Context::native_context(), v8::internal::JSFunction::NativeContextFromLiterals(), v8::internal::NOT_TENURED, v8::internal::TENURED, and v8::internal::JSObject::ValidateElements().

Referenced by v8::internal::CreateLiteralBoilerplate(), and v8::internal::GetLiteralAllocationSite().

Here is the call graph for this function:

Here is the caller graph for this function:

DefineObjectProperty()

MaybeHandle< Object > v8::internal::Runtime::DefineObjectProperty ( Handle< JSObject >  object, Handle< Object >  key, Handle< Object >  value, PropertyAttributes  attr  )

static

Definition at line 2277 of file runtime.cc.

                                                                           {
  Isolate* isolate = js_object->GetIsolate();
  // Check if the given key is an array index.
  uint32_t index;
  if (key->ToArrayIndex(&index)) {
    // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
    // of a string using [] notation.  We need to support this too in
    // JavaScript.
    // In the case of a String object we just need to redirect the assignment to
    // the underlying string if the index is in range.  Since the underlying
    // string does nothing with the assignment then we can ignore such
    // assignments.
    if (js_object->IsStringObjectWithCharacterAt(index)) {
      return value;
    }
 
    return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
                                DEFINE_PROPERTY);
  }
 
  if (key->IsName()) {
    Handle<Name> name = Handle<Name>::cast(key);
    if (name->AsArrayIndex(&index)) {
      return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
                                  DEFINE_PROPERTY);
    } else {
      if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
      return JSObject::SetOwnPropertyIgnoreAttributes(js_object, name, value,
                                                      attr);
    }
  }
 
  // Call-back into JavaScript to convert the key to a string.
  Handle<Object> converted;
  ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
                             Execution::ToString(isolate, key), Object);
  Handle<String> name = Handle<String>::cast(converted);
 
  if (name->AsArrayIndex(&index)) {
    return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
                                DEFINE_PROPERTY);
  } else {
    return JSObject::SetOwnPropertyIgnoreAttributes(js_object, name, value,
                                                    attr);
  }
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), v8::internal::DEFINE_PROPERTY, v8::internal::String::Flatten(), name, v8::internal::JSObject::SetElement(), v8::internal::JSObject::SetOwnPropertyIgnoreAttributes(), and v8::internal::SLOPPY.

Referenced by v8::internal::ScopeInfo::CopyContextLocalsToScopeObject(), v8::Object::ForceSet(), v8::internal::MaterializeArgumentsObject(), v8::internal::MaterializeCatchScope(), v8::internal::MaterializeClosure(), v8::internal::RUNTIME_FUNCTION(), and v8::internal::SetClosureVariableValue().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteObjectProperty()

MaybeHandle< Object > v8::internal::Runtime::DeleteObjectProperty ( Isolate *  isolate, Handle< JSReceiver >  object, Handle< Object >  key, JSReceiver::DeleteMode  mode  )

static

Definition at line 2328 of file runtime.cc.

                                                                             {
  // Check if the given key is an array index.
  uint32_t index;
  if (key->ToArrayIndex(&index)) {
    // In Firefox/SpiderMonkey, Safari and Opera you can access the
    // characters of a string using [] notation.  In the case of a
    // String object we just need to redirect the deletion to the
    // underlying string if the index is in range.  Since the
    // underlying string does nothing with the deletion, we can ignore
    // such deletions.
    if (receiver->IsStringObjectWithCharacterAt(index)) {
      return isolate->factory()->true_value();
    }
 
    return JSReceiver::DeleteElement(receiver, index, mode);
  }
 
  Handle<Name> name;
  if (key->IsName()) {
    name = Handle<Name>::cast(key);
  } else {
    // Call-back into JavaScript to convert the key to a string.
    Handle<Object> converted;
    ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
                               Execution::ToString(isolate, key), Object);
    name = Handle<String>::cast(converted);
  }
 
  if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
  return JSReceiver::DeleteProperty(receiver, name, mode);
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), v8::internal::JSReceiver::DeleteElement(), v8::internal::JSReceiver::DeleteProperty(), v8::internal::Isolate::factory(), v8::internal::String::Flatten(), mode(), and name.

Referenced by v8::Object::Delete(), and v8::Object::ForceDelete().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeArrayBuffer()

void v8::internal::Runtime::FreeArrayBuffer ( Isolate *  isolate, JSArrayBuffer *  phantom_array_buffer  )

static

Definition at line 15 of file runtime-typedarray.cc.

                                                                   {
  if (phantom_array_buffer->should_be_freed()) {
    DCHECK(phantom_array_buffer->is_external());
    free(phantom_array_buffer->backing_store());
  }
  if (phantom_array_buffer->is_external()) return;
 
  size_t allocated_length =
      NumberToSize(isolate, phantom_array_buffer->byte_length());
 
  reinterpret_cast<v8::Isolate*>(isolate)
      ->AdjustAmountOfExternalAllocatedMemory(
          -static_cast<int64_t>(allocated_length));
  CHECK(V8::ArrayBufferAllocator() != NULL);
  V8::ArrayBufferAllocator()->Free(phantom_array_buffer->backing_store(),
                                   allocated_length);
}

References v8::internal::V8::ArrayBufferAllocator(), CHECK, DCHECK, v8::ArrayBuffer::Allocator::Free(), v8::internal::JSArrayBuffer::is_external(), NULL, v8::internal::NumberToSize(), and v8::internal::JSArrayBuffer::should_be_freed().

Referenced by v8::internal::Heap::TearDownArrayBuffers(), and v8::internal::WeakListVisitor< JSArrayBuffer >::VisitPhantomObject().

Here is the call graph for this function:

Here is the caller graph for this function:

FunctionForEntry()

const Runtime::Function * v8::internal::Runtime::FunctionForEntry ( Address  ref )

static

Definition at line 9302 of file runtime.cc.

                                                              {
  for (size_t i = 0; i < arraysize(kIntrinsicFunctions); ++i) {
    if (entry == kIntrinsicFunctions[i].entry) {
      return &(kIntrinsicFunctions[i]);
    }
  }
  return NULL;
}

References arraysize, v8::internal::kIntrinsicFunctions, and NULL.

Referenced by v8::internal::compiler::StaticParameterTraits< ExternalReference >::PrintTo().

Here is the caller graph for this function:

FunctionForId()

const Runtime::Function * v8::internal::Runtime::FunctionForId ( Runtime::FunctionId  id )

static

Definition at line 9312 of file runtime.cc.

                                                                  {
  return &(kIntrinsicFunctions[static_cast<int>(id)]);
}

References v8::internal::kIntrinsicFunctions.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), v8::internal::LCodeGen::CallRuntime(), v8::internal::MacroAssembler::CallRuntime(), v8::internal::MacroAssembler::CallRuntimeSaveDoubles(), v8::internal::compiler::LinkageHelper< LinkageTraits >::GetRuntimeCallDescriptor(), v8::internal::compiler::ChangeLoweringTest::IsAllocateHeapNumber(), v8::internal::Parser::ParseEagerFunctionBody(), v8::internal::Parser::ParseVariableDeclarations(), v8::internal::compiler::StaticParameterTraits< Runtime::FunctionId >::PrintTo(), v8::internal::compiler::JSGenericLowering::ReplaceWithRuntimeCall(), and v8::internal::compiler::JSOperatorBuilder::Runtime().

Here is the caller graph for this function:

FunctionForName()

const Runtime::Function * v8::internal::Runtime::FunctionForName ( Handle< String >  name )

static

Definition at line 9290 of file runtime.cc.

                                                                   {
  Heap* heap = name->GetHeap();
  int entry = heap->intrinsic_function_names()->FindEntry(name);
  if (entry != kNotFound) {
    Object* smi_index = heap->intrinsic_function_names()->ValueAt(entry);
    int function_index = Smi::cast(smi_index)->value();
    return &(kIntrinsicFunctions[function_index]);
  }
  return NULL;
}

References v8::internal::kIntrinsicFunctions, kNotFound, name, and NULL.

Referenced by v8::internal::Parser::ParseV8Intrinsic().

Here is the caller graph for this function:

GetElementOrCharAt()

MaybeHandle< Object > v8::internal::Runtime::GetElementOrCharAt ( Isolate *  isolate, Handle< Object >  object, uint32_t  index  )

static

Definition at line 1850 of file runtime.cc.

                                                                {
  // Handle [] indexing on Strings
  if (object->IsString()) {
    Handle<Object> result = GetCharAt(Handle<String>::cast(object), index);
    if (!result->IsUndefined()) return result;
  }
 
  // Handle [] indexing on String objects
  if (object->IsStringObjectWithCharacterAt(index)) {
    Handle<JSValue> js_value = Handle<JSValue>::cast(object);
    Handle<Object> result =
        GetCharAt(Handle<String>(String::cast(js_value->value())), index);
    if (!result->IsUndefined()) return result;
  }
 
  Handle<Object> result;
  if (object->IsString() || object->IsNumber() || object->IsBoolean()) {
    PrototypeIterator iter(isolate, object);
    return Object::GetElement(isolate, PrototypeIterator::GetCurrent(iter),
                              index);
  } else {
    return Object::GetElement(isolate, object, index);
  }
}

References v8::internal::Handle< T >::cast(), v8::internal::GetCharAt(), v8::internal::PrototypeIterator::GetCurrent(), and v8::internal::Object::GetElement().

Referenced by GetObjectProperty(), v8::internal::GetOwnProperty(), v8::internal::LoadIC::Load(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GetObjectProperty()

MaybeHandle< Object > v8::internal::Runtime::GetObjectProperty ( Isolate *  isolate, Handle< Object >  object, Handle< Object >  key  )

static

Definition at line 1912 of file runtime.cc.

                                                                   {
  if (object->IsUndefined() || object->IsNull()) {
    Handle<Object> args[2] = {key, object};
    THROW_NEW_ERROR(isolate, NewTypeError("non_object_property_load",
                                          HandleVector(args, 2)),
                    Object);
  }
 
  // Check if the given key is an array index.
  uint32_t index;
  if (key->ToArrayIndex(&index)) {
    return GetElementOrCharAt(isolate, object, index);
  }
 
  // Convert the key to a name - possibly by calling back into JavaScript.
  Handle<Name> name;
  ASSIGN_RETURN_ON_EXCEPTION(isolate, name, ToName(isolate, key), Object);
 
  // Check if the name is trivially convertible to an index and get
  // the element if so.
  if (name->AsArrayIndex(&index)) {
    return GetElementOrCharAt(isolate, object, index);
  } else {
    return Object::GetProperty(object, name);
  }
}

References ASSIGN_RETURN_ON_EXCEPTION, GetElementOrCharAt(), v8::internal::Object::GetProperty(), v8::internal::HandleVector(), name, THROW_NEW_ERROR, and v8::internal::ToName().

Referenced by v8::Object::Get(), v8::internal::KeyedLoadIC::Load(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

HasObjectProperty()

MaybeHandle< Object > v8::internal::Runtime::HasObjectProperty ( Isolate *  isolate, Handle< JSReceiver >  object, Handle< Object >  key  )

static

Definition at line 1891 of file runtime.cc.

                                                                   {
  Maybe<bool> maybe;
  // Check if the given key is an array index.
  uint32_t index;
  if (key->ToArrayIndex(&index)) {
    maybe = JSReceiver::HasElement(object, index);
  } else {
    // Convert the key to a name - possibly by calling back into JavaScript.
    Handle<Name> name;
    ASSIGN_RETURN_ON_EXCEPTION(isolate, name, ToName(isolate, key), Object);
 
    maybe = JSReceiver::HasProperty(object, name);
  }
 
  if (!maybe.has_value) return MaybeHandle<Object>();
  return isolate->factory()->ToBoolean(maybe.value);
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Isolate::factory(), v8::internal::JSReceiver::HasElement(), v8::internal::JSReceiver::HasProperty(), v8::maybe(), name, and v8::internal::ToName().

Referenced by v8::Object::Has().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeIntrinsicFunctionNames()

void v8::internal::Runtime::InitializeIntrinsicFunctionNames ( Isolate *  isolate, Handle< NameDictionary >  dict  )

static

Definition at line 9273 of file runtime.cc.

                                                                            {
  DCHECK(dict->NumberOfElements() == 0);
  HandleScope scope(isolate);
  for (int i = 0; i < kNumFunctions; ++i) {
    const char* name = kIntrinsicFunctions[i].name;
    if (name == NULL) continue;
    Handle<NameDictionary> new_dict = NameDictionary::Add(
        dict, isolate->factory()->InternalizeUtf8String(name),
        Handle<Smi>(Smi::FromInt(i), isolate),
        PropertyDetails(NONE, NORMAL, Representation::None()));
    // The dictionary does not need to grow.
    CHECK(new_dict.is_identical_to(dict));
  }
}

References v8::internal::Dictionary< NameDictionary, NameDictionaryShape, Handle< Name > >::Add(), CHECK, DCHECK, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::kIntrinsicFunctions, name, v8::internal::Runtime::Function::name, NONE, v8::internal::Representation::None(), v8::internal::NORMAL, and NULL.

Referenced by v8::internal::Heap::CreateInitialObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

NeuterArrayBuffer()

void v8::internal::Runtime::NeuterArrayBuffer ( Handle< JSArrayBuffer >  array_buffer )

static

Definition at line 86 of file runtime-typedarray.cc.

                                                                  {
  Isolate* isolate = array_buffer->GetIsolate();
  for (Handle<Object> view_obj(array_buffer->weak_first_view(), isolate);
       !view_obj->IsUndefined();) {
    Handle<JSArrayBufferView> view(JSArrayBufferView::cast(*view_obj));
    if (view->IsJSTypedArray()) {
      JSTypedArray::cast(*view)->Neuter();
    } else if (view->IsJSDataView()) {
      JSDataView::cast(*view)->Neuter();
    } else {
      UNREACHABLE();
    }
    view_obj = handle(view->weak_next(), isolate);
  }
  array_buffer->Neuter();
}

References v8::internal::handle(), and UNREACHABLE.

Referenced by v8::ArrayBuffer::Neuter(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

SetObjectProperty()

MaybeHandle< Object > v8::internal::Runtime::SetObjectProperty ( Isolate *  isolate, Handle< Object >  object, Handle< Object >  key, Handle< Object >  value, StrictMode  strict_mode  )

static

Definition at line 2181 of file runtime.cc.

                                                                       {
  if (object->IsUndefined() || object->IsNull()) {
    Handle<Object> args[2] = {key, object};
    THROW_NEW_ERROR(isolate, NewTypeError("non_object_property_store",
                                          HandleVector(args, 2)),
                    Object);
  }
 
  if (object->IsJSProxy()) {
    Handle<Object> name_object;
    if (key->IsSymbol()) {
      name_object = key;
    } else {
      ASSIGN_RETURN_ON_EXCEPTION(isolate, name_object,
                                 Execution::ToString(isolate, key), Object);
    }
    Handle<Name> name = Handle<Name>::cast(name_object);
    return Object::SetProperty(Handle<JSProxy>::cast(object), name, value,
                               strict_mode);
  }
 
  // Check if the given key is an array index.
  uint32_t index;
  if (key->ToArrayIndex(&index)) {
    // TODO(verwaest): Support non-JSObject receivers.
    if (!object->IsJSObject()) return value;
    Handle<JSObject> js_object = Handle<JSObject>::cast(object);
 
    // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
    // of a string using [] notation.  We need to support this too in
    // JavaScript.
    // In the case of a String object we just need to redirect the assignment to
    // the underlying string if the index is in range.  Since the underlying
    // string does nothing with the assignment then we can ignore such
    // assignments.
    if (js_object->IsStringObjectWithCharacterAt(index)) {
      return value;
    }
 
    JSObject::ValidateElements(js_object);
    if (js_object->HasExternalArrayElements() ||
        js_object->HasFixedTypedArrayElements()) {
      if (!value->IsNumber() && !value->IsUndefined()) {
        ASSIGN_RETURN_ON_EXCEPTION(isolate, value,
                                   Execution::ToNumber(isolate, value), Object);
      }
    }
 
    MaybeHandle<Object> result = JSObject::SetElement(
        js_object, index, value, NONE, strict_mode, true, SET_PROPERTY);
    JSObject::ValidateElements(js_object);
 
    return result.is_null() ? result : value;
  }
 
  if (key->IsName()) {
    Handle<Name> name = Handle<Name>::cast(key);
    if (name->AsArrayIndex(&index)) {
      // TODO(verwaest): Support non-JSObject receivers.
      if (!object->IsJSObject()) return value;
      Handle<JSObject> js_object = Handle<JSObject>::cast(object);
      if (js_object->HasExternalArrayElements()) {
        if (!value->IsNumber() && !value->IsUndefined()) {
          ASSIGN_RETURN_ON_EXCEPTION(
              isolate, value, Execution::ToNumber(isolate, value), Object);
        }
      }
      return JSObject::SetElement(js_object, index, value, NONE, strict_mode,
                                  true, SET_PROPERTY);
    } else {
      if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
      return Object::SetProperty(object, name, value, strict_mode);
    }
  }
 
  // Call-back into JavaScript to convert the key to a string.
  Handle<Object> converted;
  ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
                             Execution::ToString(isolate, key), Object);
  Handle<String> name = Handle<String>::cast(converted);
 
  if (name->AsArrayIndex(&index)) {
    // TODO(verwaest): Support non-JSObject receivers.
    if (!object->IsJSObject()) return value;
    Handle<JSObject> js_object = Handle<JSObject>::cast(object);
    return JSObject::SetElement(js_object, index, value, NONE, strict_mode,
                                true, SET_PROPERTY);
  }
  return Object::SetProperty(object, name, value, strict_mode);
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), v8::internal::String::Flatten(), v8::internal::HandleVector(), v8::internal::MaybeHandle< T >::is_null(), name, NONE, v8::internal::SET_PROPERTY, v8::internal::JSObject::SetElement(), v8::internal::Object::SetProperty(), THROW_NEW_ERROR, v8::internal::ToNumber(), and v8::internal::JSObject::ValidateElements().

Referenced by v8::internal::MaterializeLocalContext(), v8::internal::MaterializeStackLocalsWithFrameInspector(), v8::internal::RUNTIME_FUNCTION(), v8::Object::Set(), v8::internal::SetLocalVariableValue(), and v8::internal::KeyedStoreIC::Store().

Here is the call graph for this function:

Here is the caller graph for this function:

SetupArrayBuffer()

void v8::internal::Runtime::SetupArrayBuffer ( Isolate *  isolate, Handle< JSArrayBuffer >  array_buffer, bool  is_external, void *  data, size_t  allocated_length  )

static

Definition at line 35 of file runtime-typedarray.cc.

                                                        {
  DCHECK(array_buffer->GetInternalFieldCount() ==
         v8::ArrayBuffer::kInternalFieldCount);
  for (int i = 0; i < v8::ArrayBuffer::kInternalFieldCount; i++) {
    array_buffer->SetInternalField(i, Smi::FromInt(0));
  }
  array_buffer->set_backing_store(data);
  array_buffer->set_flag(Smi::FromInt(0));
  array_buffer->set_is_external(is_external);
 
  Handle<Object> byte_length =
      isolate->factory()->NewNumberFromSize(allocated_length);
  CHECK(byte_length->IsSmi() || byte_length->IsHeapNumber());
  array_buffer->set_byte_length(*byte_length);
 
  array_buffer->set_weak_next(isolate->heap()->array_buffers_list());
  isolate->heap()->set_array_buffers_list(*array_buffer);
  array_buffer->set_weak_first_view(isolate->heap()->undefined_value());
}

References v8::internal::Heap::array_buffers_list(), CHECK, DCHECK, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::Isolate::heap(), v8::ArrayBuffer::kInternalFieldCount, and v8::internal::Heap::set_array_buffers_list().

Referenced by v8::ArrayBuffer::New(), and SetupArrayBufferAllocatingData().

Here is the call graph for this function:

Here is the caller graph for this function:

SetupArrayBufferAllocatingData()

bool v8::internal::Runtime::SetupArrayBufferAllocatingData ( Isolate *  isolate, Handle< JSArrayBuffer >  array_buffer, size_t  allocated_length, bool  initialize = true  )

static

Definition at line 59 of file runtime-typedarray.cc.

                                                              {
  void* data;
  CHECK(V8::ArrayBufferAllocator() != NULL);
  if (allocated_length != 0) {
    if (initialize) {
      data = V8::ArrayBufferAllocator()->Allocate(allocated_length);
    } else {
      data =
          V8::ArrayBufferAllocator()->AllocateUninitialized(allocated_length);
    }
    if (data == NULL) return false;
  } else {
    data = NULL;
  }
 
  SetupArrayBuffer(isolate, array_buffer, false, data, allocated_length);
 
  reinterpret_cast<v8::Isolate*>(isolate)
      ->AdjustAmountOfExternalAllocatedMemory(allocated_length);
 
  return true;
}

References v8::ArrayBuffer::Allocator::Allocate(), v8::ArrayBuffer::Allocator::AllocateUninitialized(), v8::internal::V8::ArrayBufferAllocator(), CHECK, NULL, and SetupArrayBuffer().

Referenced by v8::internal::JSTypedArray::MaterializeArrayBuffer(), v8::ArrayBuffer::New(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

StringMatch()

int v8::internal::Runtime::StringMatch ( Isolate *  isolate, Handle< String >  sub, Handle< String >  pat, int  index  )

static

Definition at line 1094 of file runtime-regexp.cc.

                                                              {
  DCHECK(0 <= start_index);
  DCHECK(start_index <= sub->length());
 
  int pattern_length = pat->length();
  if (pattern_length == 0) return start_index;
 
  int subject_length = sub->length();
  if (start_index + pattern_length > subject_length) return -1;
 
  sub = String::Flatten(sub);
  pat = String::Flatten(pat);
 
  DisallowHeapAllocation no_gc;  // ensure vectors stay valid
  // Extract flattened substrings of cons strings before getting encoding.
  String::FlatContent seq_sub = sub->GetFlatContent();
  String::FlatContent seq_pat = pat->GetFlatContent();
 
  // dispatch on type of strings
  if (seq_pat.IsOneByte()) {
    Vector<const uint8_t> pat_vector = seq_pat.ToOneByteVector();
    if (seq_sub.IsOneByte()) {
      return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
                          start_index);
    }
    return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
                        start_index);
  }
  Vector<const uc16> pat_vector = seq_pat.ToUC16Vector();
  if (seq_sub.IsOneByte()) {
    return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
                        start_index);
  }
  return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector, start_index);
}

References DCHECK, v8::internal::String::Flatten(), v8::internal::String::FlatContent::IsOneByte(), v8::internal::SearchString(), v8::internal::String::FlatContent::ToOneByteVector(), and v8::internal::String::FlatContent::ToUC16Vector().

Referenced by v8::internal::RUNTIME_FUNCTION(), and v8::internal::StringReplaceOneCharWithString().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

kNotFound

const int v8::internal::Runtime::kNotFound = -1

static

Definition at line 807 of file runtime.h.

Referenced by FunctionForName().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/runtime/runtime.h
• /mnt/V8SourceCode/src/runtime/runtime-regexp.cc
• /mnt/V8SourceCode/src/runtime/runtime-typedarray.cc
• /mnt/V8SourceCode/src/runtime/runtime.cc