CSE2410 Fall 2014 Bounce

#include "v8.h"

#include "accessors.h"

#include "api.h"

#include "arguments.h"

#include "bootstrapper.h"

  ElementsKind from_kind =

      Handle<JSObject>::cast(object)->map()->elements_kind();

  if (Map::IsValidElementsTransition(from_kind, to_kind)) {

  }

  return isolate->ThrowIllegalOperation();

}

  bool has_function_literal = (flags & ObjectLiteral::kHasFunction) != 0;

  // Check if boilerplate exists. If not, create it first.

    // Update the functions literal and return the boilerplate.

  }

}

    ASSERT(*elements != isolate->heap()->empty_fixed_array());

    Handle<Object> boilerplate =

        Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements);

    literals->set(literals_index, *site);

  } else {

    site = Handle<AllocationSite>::cast(literal_site);

      literals_index, elements);

  RETURN_IF_EMPTY_HANDLE(isolate, site);

}

    isolate->counters()->cow_arrays_created_runtime()->Increment();

  }

  }

  return isolate->heap()->CopyJSObject(boilerplate);

}

enum TypedArrayId {

  // arrayIds below should be synchromized with typedarray.js natives.

  ARRAY_ID_UINT8 = 1,

            HandleVector<Object>(NULL, 0)));

  }

  // We assume that the caller of this function will initialize holder

  // with the loop

  //      for(i = 0; i < length; i++) { holder[i] = source[i]; }

  // If source is a typed array, this loop will always run to completion,

  // so we are sure that the backing store will be initialized.

  if (!Runtime::SetupArrayBufferAllocatingData(

    return isolate->Throw(*isolate->factory()->

          NewRangeError("invalid_array_buffer_length",

            HandleVector<Object>(NULL, 0)));

RUNTIME_FUNCTION(MaybeObject*, Runtime_GetPrototype) {

  ASSERT(args.length() == 1);

  // We don't expect access checks to be needed on JSProxy objects.

  ASSERT(!obj->IsAccessCheckNeeded() || obj->IsJSObject());

  do {

    if (obj->IsAccessCheckNeeded() &&

      RETURN_IF_SCHEDULED_EXCEPTION(isolate);

      return isolate->heap()->undefined_value();

    }

  } while (obj->IsJSObject() &&

}

static bool CheckAccessException(Object* callback,

                                 v8::AccessType access_type) {

  if (callback->IsAccessorInfo()) {

    AccessorInfo* info = AccessorInfo::cast(callback);

    return

template<class Key>

static bool CheckGenericAccess(

    Key key,

    v8::AccessType access_type,

  Isolate* isolate = receiver->GetIsolate();

       true;

    if (current->IsAccessCheckNeeded() &&

        !(isolate->*mayAccess)(current, key, access_type)) {

      return false;

    }

  }

  return true;

}

};

  uint32_t index;

  if (name->AsArrayIndex(&index)) {

    // TODO(1095): we should traverse hidden prototype hierachy as well.

    if (CheckGenericAccess(

      return ACCESS_ALLOWED;

    }

    return ACCESS_FORBIDDEN;

  }

  if (!lookup.IsProperty()) return ACCESS_ABSENT;

    return ACCESS_ALLOWED;

  }

    case INTERCEPTOR:

      // If the object has an interceptor, try real named properties.

      // Overwrite the result to fetch the correct property later.

      if (lookup.IsProperty() && lookup.IsPropertyCallbacks()) {

        if (CheckAccessException(lookup.GetCallbackObject(), access_type)) {

          return ACCESS_ALLOWED;

      break;

  }

  return ACCESS_FORBIDDEN;

}

};

  Heap* heap = isolate->heap();

  // Due to some WebKit tests, we want to make sure that we do not log

  // more than one access failure here.

  AccessCheckResult access_check_result =

  switch (access_check_result) {

    case ACCESS_ALLOWED: break;

  }

  PropertyAttributes attrs = obj->GetLocalPropertyAttribute(*name);

  if (attrs == ABSENT) {

  }

  ASSERT(!isolate->has_scheduled_exception());

  AccessorPair* raw_accessors = obj->GetLocalPropertyAccessorPair(*name);

  Handle<AccessorPair> accessors(raw_accessors, isolate);

  Handle<FixedArray> elms = isolate->factory()->NewFixedArray(DESCRIPTOR_SIZE);

  elms->set(ENUMERABLE_INDEX, heap->ToBoolean((attrs & DONT_ENUM) == 0));

  elms->set(CONFIGURABLE_INDEX, heap->ToBoolean((attrs & DONT_DELETE) == 0));

    elms->set(WRITABLE_INDEX, heap->ToBoolean((attrs & READ_ONLY) == 0));

    // GetProperty does access check.

    Handle<Object> value = GetProperty(isolate, obj, name);

    elms->set(VALUE_INDEX, *value);

  } else {

    // Access checks are performed for both accessors separately.

    // When they fail, the respective field is not set in the descriptor.

      ASSERT(!isolate->has_scheduled_exception());

    } else {

    }

      ASSERT(!isolate->has_scheduled_exception());

    } else {

    }

  }

}

  ASSERT(args.length() == 2);

  CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);

  CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);

}

RUNTIME_FUNCTION(MaybeObject*, Runtime_PreventExtensions) {

  ASSERT(args.length() == 1);

}

  CONVERT_ARG_HANDLE_CHECKED(JSRegExp, re, 0);

  CONVERT_ARG_HANDLE_CHECKED(String, pattern, 1);

  CONVERT_ARG_HANDLE_CHECKED(String, flags, 2);

  RETURN_IF_EMPTY_HANDLE(isolate, result);

  return *result;

}

    // Declare the property by setting it to the initial value if provided,

    // or undefined, and use the correct mode (e.g. READ_ONLY attribute for

    // constant declarations).

    Handle<Object> value(isolate->heap()->undefined_value(), isolate);

    if (*initial_value != NULL) value = initial_value;

    // Declaring a const context slot is a conflicting declaration if

RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeVarGlobal) {

  // args[0] == name

  // args[1] == language_mode

  // args[2] == value (optional)

  bool assign = args.length() == 3;

  CONVERT_ARG_HANDLE_CHECKED(String, name, 0);

  RUNTIME_ASSERT(args[1]->IsSmi());

  CONVERT_LANGUAGE_MODE_ARG(language_mode, 1);

  StrictModeFlag strict_mode_flag = (language_mode == CLASSIC_MODE)

  // to assign to the property.

  // Note that objects can have hidden prototypes, so we need to traverse

  // the whole chain of hidden prototypes to do a 'local' lookup.

  LookupResult lookup(isolate);

  if (lookup.IsInterceptor()) {

    PropertyAttributes intercepted =

        lookup.holder()->GetPropertyAttribute(*name);

    if (intercepted != ABSENT && (intercepted & READ_ONLY) == 0) {

      // Found an interceptor that's not read only.

      if (assign) {

      } else {

        return isolate->heap()->undefined_value();

      }

    }

  }

  if (assign) {

  }

  return isolate->heap()->undefined_value();

}

  source_shared->set_dont_flush(true);

  // Set the code, scope info, formal parameter count, and the length

  target_shared->ReplaceCode(source_shared->code());

  target_shared->set_scope_info(source_shared->scope_info());

  target_shared->set_length(source_shared->length());

  target_shared->set_formal_parameter_count(

      source_shared->formal_parameter_count());

  // Set the code of the target function.

  target->ReplaceCode(source_shared->code());

RUNTIME_FUNCTION(MaybeObject*, Runtime_SetExpectedNumberOfProperties) {

  HandleScope scope(isolate);

  ASSERT(args.length() == 2);

  CONVERT_SMI_ARG_CHECKED(num, 1);

  RUNTIME_ASSERT(num >= 0);

  return isolate->heap()->undefined_value();

}

RUNTIME_FUNCTION(MaybeObject*, Runtime_ObjectFreeze) {

  ASSERT(args.length() == 1);

}

  // Check if the given key is an array index.

  uint32_t index;

  if (key->ToArrayIndex(&index)) {

  }

  // Convert the key to a name - possibly by calling back into JavaScript.

    name = Handle<Name>::cast(converted);

  }

}

MaybeObject* Runtime::GetObjectPropertyOrFail(

    // TODO(mstarzinger): So far this only works if property attributes don't

    // change, this should be fixed once we cleanup the underlying code.

    if (callback->IsForeign() && result.GetAttributes() == attr) {

    }

  }

  if (object->IsJSProxy()) {

    bool has_pending_exception = false;

        ? key : Execution::ToString(isolate, key, &has_pending_exception);

    if (has_pending_exception) return Failure::Exception();

  }

  // If the object isn't a JavaScript object, we ignore the store.

  }

  if (key->IsName()) {

    Handle<Name> name = Handle<Name>::cast(key);

    if (name->AsArrayIndex(&index)) {

      if (js_object->HasExternalArrayElements()) {

          value = number;

        }

      }

          index, *value, attr, strict_mode, true, set_mode);

    } else {

      if (name->IsString()) Handle<String>::cast(name)->TryFlatten();

    }

    return *value;

  }

    return js_object->SetElement(

        index, *value, attr, strict_mode, true, set_mode);

  } else {

  }

}

static MaybeObject* HasLocalPropertyImplementation(Isolate* isolate,

                                                   Handle<JSObject> object,

                                                   Handle<Name> key) {

  // Handle hidden prototypes.  If there's a hidden prototype above this thing

  // then we have to check it for properties, because they are supposed to

  // look like they are on this object.

RUNTIME_FUNCTION(MaybeObject*, Runtime_HasLocalProperty) {

  ASSERT(args.length() == 2);

  uint32_t index;

  const bool key_is_array_index = key->AsArrayIndex(&index);

  // Only JS objects can have properties.

    // Fast case: either the key is a real named property or it is not

    // an array index and there are no interceptors or hidden

    // prototypes.

      ASSERT(!isolate->has_scheduled_exception());

      return isolate->heap()->true_value();

    } else {

      RETURN_IF_SCHEDULED_EXCEPTION(isolate);

    }

    if (!key_is_array_index &&

        !map->has_named_interceptor() &&

        !HeapObject::cast(map->prototype())->map()->is_hidden_prototype()) {

      return isolate->heap()->false_value();

    }

    // Slow case.

    return HasLocalPropertyImplementation(isolate,

                                          Handle<Name>(key));

    // Well, there is one exception:  Handle [] on strings.

    if (index < static_cast<uint32_t>(string->length())) {

      return isolate->heap()->true_value();

    }

RUNTIME_FUNCTION(MaybeObject*, Runtime_HasProperty) {

  ASSERT(args.length() == 2);

  RETURN_IF_SCHEDULED_EXCEPTION(isolate);

  if (isolate->has_pending_exception()) return Failure::Exception();

  return isolate->heap()->ToBoolean(result);

RUNTIME_FUNCTION(MaybeObject*, Runtime_HasElement) {

  ASSERT(args.length() == 2);

  CONVERT_SMI_ARG_CHECKED(index, 1);

  RETURN_IF_SCHEDULED_EXCEPTION(isolate);

  if (isolate->has_pending_exception()) return Failure::Exception();

  return isolate->heap()->ToBoolean(result);

RUNTIME_FUNCTION(MaybeObject*, Runtime_ToFastProperties) {

  ASSERT(args.length() == 1);

}

  // Allocate the elements if needed.

  if (length > 0) {

    // Allocate the fixed array.

    }

    DisallowHeapAllocation no_gc;

    WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);

    for (int i = 0; i < length; i++) {

      array->set(i, *--parameters, mode);

    }

  }

  return result;

}

  // If the function is not optimizable or debugger is active continue using the

  // code from the full compiler.

      function->shared()->optimization_disabled() ||

      isolate->DebuggerHasBreakPoints()) {

    if (FLAG_trace_opt) {

}

RUNTIME_FUNCTION(MaybeObject*, Runtime_DeoptimizeFunction) {

  HandleScope scope(isolate);

  ASSERT(args.length() == 1);

    if (type->IsOneByteEqualTo(STATIC_ASCII_VECTOR("osr"))) {

      // Start patching from the currently patched loop nesting level.

      int current_level = unoptimized->allow_osr_at_loop_nesting_level();

      for (int i = current_level + 1; i <= Code::kMaxLoopNestingMarker; i++) {

        unoptimized->set_allow_osr_at_loop_nesting_level(i);

        isolate->runtime_profiler()->AttemptOnStackReplacement(*function);

}

RUNTIME_FUNCTION(MaybeObject*, Runtime_GetOptimizationCount) {

  HandleScope scope(isolate);

  ASSERT(args.length() == 1);

                                            Handle<JSFunction> function,

                                            Handle<Code> unoptimized) {

  // Keep track of whether we've succeeded in optimizing.

  // If we are trying to do OSR when there are already optimized

  // activations of the function, it means (a) the function is directly or

  // indirectly recursive and (b) an optimized invocation has been

  Handle<Code> result = Handle<Code>::null();

  BailoutId ast_id = BailoutId::None();

    if (isolate->optimizing_compiler_thread()->

            IsQueuedForOSR(function, pc_offset)) {

      // Still waiting for the optimizing compiler thread to finish.  Carry on.

      return NULL;

    }

        FindReadyOSRCandidate(function, pc_offset);

      if (IsSuitableForOnStackReplacement(isolate, function, unoptimized) &&

          Compiler::RecompileConcurrent(function, pc_offset)) {

        if (function->IsMarkedForLazyRecompilation() ||

            function->IsMarkedForConcurrentRecompilation()) {

          // Prevent regular recompilation if we queue this for OSR.

          // TODO(yangguo): remove this as soon as OSR becomes one-shot.

        }

        return NULL;

      }

      // Fall through to the end in case of failure.

    } else {

      // TODO(titzer): don't install the OSR code into the function.

    }

  } else if (IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {

    ast_id = unoptimized->TranslatePcOffsetToAstId(pc_offset);

    result = JSFunction::CompileOsr(function, ast_id, CLEAR_EXCEPTION);

  }

  // Check whether we ended up with usable optimized code.

  if (!result.is_null() && result->kind() == Code::OPTIMIZED_FUNCTION) {

  // property from it.

  if (!holder.is_null()) {

    Handle<JSReceiver> object = Handle<JSReceiver>::cast(holder);

    // GetProperty below can cause GC.

    Handle<Object> receiver_handle(

        object->IsGlobalObject()

        Handle<Object> element_value(elements->get(j), isolate);

        if (!element_value->IsTheHole()) {

          visitor->visit(j, element_value);

          // Call GetElement on receiver, not its prototype, or getters won't

          // have the correct receiver.

          element_value = Object::GetElement(isolate, receiver, j);

          Handle<Object> element_value =

              isolate->factory()->NewNumber(double_value);

          visitor->visit(j, element_value);

          // Call GetElement on receiver, not its prototype, or getters won't

          // have the correct receiver.

          Handle<Object> element_value =

// property.

// Returns the number of non-undefined elements collected.

RUNTIME_FUNCTION(MaybeObject*, Runtime_RemoveArrayHoles) {

  ASSERT(args.length() == 2);

  CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[1]);

}

RUNTIME_FUNCTION(MaybeObject*, Runtime_LookupAccessor) {

  ASSERT(args.length() == 3);

  CONVERT_SMI_ARG_CHECKED(flag, 2);

  AccessorComponent component = flag == 0 ? ACCESSOR_GETTER : ACCESSOR_SETTER;

  if (!receiver->IsJSObject()) return isolate->heap()->undefined_value();

}

    case CALLBACKS: {

      Object* structure = result->GetCallbackObject();

      if (structure->IsForeign() || structure->IsAccessorInfo()) {

          heap->isolate()->clear_pending_exception();

        }

      } else {

        return heap->undefined_value();

      }

  CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);

  PropertyAttributes attributes;

}

  // Third fill all context locals.

  Handle<Context> frame_context(Context::cast(frame->context()));

  Handle<Context> function_context(frame_context->declaration_context());

    return Handle<JSObject>();

  }

          !function_context->IsNativeContext()) {

        Handle<JSObject> ext(JSObject::cast(function_context->extension()));

          // We don't expect this to do anything except replacing

          // property value.

          SetProperty(isolate,

      isolate->factory()->NewJSObject(isolate->object_function());

  // Fill all context locals to the context extension.

    return Handle<JSObject>();

  }

  // be variables introduced by eval.

  if (context->has_extension()) {

    Handle<JSObject> ext(JSObject::cast(context->extension()));

      // We don't expect this to do anything except replacing property value.

      SetProperty(isolate,

                  ext,

      isolate->factory()->NewJSObject(isolate->object_function());

  // Fill all context locals.

    return Handle<JSObject>();

  }

      isolate->factory()->NewJSObject(isolate->object_function());

  // Fill all context locals.

    return Handle<JSObject>();

  }

  // Do not materialize the arguments object for eval or top-level code.

  // Skip if "arguments" is already taken.

  if (!function->shared()->is_function() ||

    return target;

  }

RUNTIME_FUNCTION(MaybeObject*, Runtime_SetIsObserved) {

  ASSERT(args.length() == 1);

  if (obj->IsJSGlobalProxy()) {

    Object* proto = obj->GetPrototype();

    if (proto->IsNull()) return isolate->heap()->undefined_value();

    ASSERT(proto->IsJSGlobalObject());

  }

  if (obj->IsJSProxy())

    return isolate->heap()->undefined_value();

  ASSERT(!(obj->map()->is_observed() && obj->IsJSObject() &&

  ASSERT(obj->IsJSObject());

}

    Handle<Cell> cell = Handle<Cell>::cast(type_info);

    Handle<AllocationSite> site = Handle<AllocationSite>(

        AllocationSite::cast(cell->value()), isolate);

    ElementsKind to_kind = site->GetElementsKind();

    if (holey && !IsFastHoleyElementsKind(to_kind)) {

      to_kind = GetHoleyElementsKind(to_kind);

}

  Failure* failure = Failure::cast(result);

  if (failure->IsRetryAfterGC()) {

    if (isolate->heap()->new_space()->AddFreshPage()) {