CSE2410 Fall 2014 Bounce

                                            Register receiver,

                                            Register scratch1,

                                            Register scratch2,

  Label check_wrapper;

  // Check if the object is a string leaving the instance type in the

  // scratch1 register.

  // Load length directly from the string.

  __ ldr(r0, FieldMemOperand(receiver, String::kLengthOffset));

  __ Ret();

}

}

    MacroAssembler* masm,

    Handle<JSObject> holder,

    Register holder_reg,

// When leaving generated code after success, the receiver_reg and name_reg

// may be clobbered.  Upon branch to miss_label, the receiver and name

// registers have their original values.

  // r0 : value

  Label exit;

  if (details.type() == CONSTANT) {

    Handle<Object> constant(descriptors->GetValue(descriptor), masm->isolate());

    __ cmp(value_reg, scratch1);

    __ b(ne, miss_label);

  } else if (FLAG_track_fields && representation.IsSmi()) {

// When leaving generated code after success, the receiver_reg and name_reg

// may be clobbered.  Upon branch to miss_label, the receiver and name

// registers have their original values.

  // r0 : value

  Label exit;

}

  if (!label->is_unused()) {

    __ bind(label);

    __ mov(this->name(), Operand(name));

static void GenerateFastApiDirectCall(MacroAssembler* masm,

                                      const CallOptimization& optimization,

  // ----------- S t a t e -------------

  //  -- ...

  // -----------------------------------

  // Get the function and setup the context.

  Handle<JSFunction> function = optimization.constant_function();

  __ ldr(cp, FieldMemOperand(r5, JSFunction::kContextOffset));

  Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();

  Handle<Object> call_data(api_call_info->data(), masm->isolate());

  if (masm->isolate()->heap()->InNewSpace(*call_data)) {

  } else {

    __ Move(r6, call_data);

  }

  __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);

  // Prepare arguments.

  // Allocate the v8::Arguments structure in the arguments' space since

  // it's not controlled by GC.

  FrameScope frame_scope(masm, StackFrame::MANUAL);

  __ EnterExitFrame(false, kApiStackSpace);

  // Arguments is after the return address.

  __ add(r0, sp, Operand(1 * kPointerSize));

  __ str(r2, MemOperand(r0, 0 * kPointerSize));

  __ str(ip, MemOperand(r0, 1 * kPointerSize));

  __ mov(ip, Operand(argc));

  __ str(ip, MemOperand(r0, 2 * kPointerSize));

  __ mov(ip, Operand::Zero());

  __ str(ip, MemOperand(r0, 3 * kPointerSize));

      masm->isolate());

  AllowExternalCallThatCantCauseGC scope(masm);

  __ CallApiFunctionAndReturn(ref,

                              function_address,

                              thunk_ref,

                              r1,

                              kStackUnwindSpace,

}

  ASSERT(optimization.is_simple_api_call());

  ASSERT(!receiver.is(scratch));

  const int stack_space = kFastApiCallArguments + argc + 1;

  // Assign stack space for the call arguments.

  __ sub(sp, sp, Operand(stack_space * kPointerSize));

  // Write holder to stack frame.

  // Write receiver to stack frame.

  int index = stack_space - 1;

  __ str(receiver, MemOperand(sp, index * kPointerSize));

    __ str(receiver, MemOperand(sp, index-- * kPointerSize));

  }

}

    // Invoke function.

    if (can_do_fast_api_call) {

    } else {

      CallKind call_kind = CallICBase::Contextual::decode(extra_ic_state_)

          ? CALL_AS_FUNCTION

  Register reg = object_reg;

  int depth = 0;

  if (save_at_depth == depth) {

  }

  // Check the maps in the prototype chain.

    }

    if (save_at_depth == depth) {

    }

    // Go to the next object in the prototype chain.

}

  if (!miss->is_unused()) {

    __ b(success);

    __ bind(miss);

}

  if (!miss->is_unused()) {

    __ b(success);

    GenerateRestoreName(masm(), miss, name);

}

    Handle<JSObject> object,

    Register object_reg,

    Handle<JSObject> holder,

}

    Handle<JSObject> object,

    Handle<JSObject> last,

    Handle<Name> name,

}

  if (!reg.is(receiver())) __ mov(receiver(), reg);

  if (kind() == Code::LOAD_IC) {

    LoadFieldStub stub(field.is_inobject(holder),

}

  // Return the constant value.

  __ Ret();

}

    const CallOptimization& call_optimization) {

  GenerateFastApiCall(

      masm(), call_optimization, receiver(), scratch3(), 0, NULL);

}

    Register reg,

    Handle<ExecutableAccessorInfo> callback) {

  // Build AccessorInfo::args_ list on the stack and push property name below

  // the exit frame to make GC aware of them and store pointers to them.

  ASSERT(!scratch2().is(reg));

  ASSERT(!scratch3().is(reg));

  ASSERT(!scratch4().is(reg));

  __ push(receiver());

  if (heap()->InNewSpace(callback->data())) {

    __ Move(scratch3(), callback);

    __ ldr(scratch3(), FieldMemOperand(scratch3(),

  __ Push(scratch3(), scratch4());

  __ mov(scratch4(),

         Operand(ExternalReference::isolate_address(isolate())));

  __ mov(r0, sp);  // r0 = Handle<Name>

  const int kApiStackSpace = 1;

  FrameScope frame_scope(masm(), StackFrame::MANUAL);

  __ EnterExitFrame(false, kApiStackSpace);

  // scratch2 (internal::Object** args_) as the data.

  __ str(scratch2(), MemOperand(sp, 1 * kPointerSize));

  __ add(r1, sp, Operand(1 * kPointerSize));  // r1 = AccessorInfo&

  Address getter_address = v8::ToCData<Address>(callback->getter());

  ApiFunction fun(getter_address);

                              thunk_ref,

                              r2,

                              kStackUnwindSpace,

}

    Register holder_reg,

    Handle<JSObject> object,

    Handle<JSObject> interceptor_holder,

      if (FLAG_smi_only_arrays  && !FLAG_trace_elements_transitions) {

        Label fast_object, not_fast_object;

        __ jmp(&fast_object);

        // In case of fast smi-only, convert to fast object, otherwise bail out.

        __ bind(&not_fast_object);

        __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);

        __ b(eq, &call_builtin);

        // edx: receiver

        // r3: map

        __ LoadTransitionedArrayMapConditional(FAST_SMI_ELEMENTS,

                                               FAST_ELEMENTS,

                                               r3,

                                               &try_holey_map);

        __ mov(r2, receiver);

        ElementsTransitionGenerator::

        __ LoadTransitionedArrayMapConditional(FAST_HOLEY_SMI_ELEMENTS,

                                               FAST_HOLEY_ELEMENTS,

                                               r3,

                                               &call_builtin);

        __ mov(r2, receiver);

        ElementsTransitionGenerator::

      __ bind(&attempt_to_grow_elements);

      // r0: array's length + 1.

      if (!FLAG_inline_new) {

        __ b(&call_builtin);

      // the new element is non-Smi. For now, delegate to the builtin.

      Label no_fast_elements_check;

      __ JumpIfSmi(r2, &no_fast_elements_check);

      __ bind(&no_fast_elements_check);

      ExternalReference new_space_allocation_top =

      // Load top and check if it is the end of elements.

      __ add(end_elements, elements, Operand::PointerOffsetFromSmiKey(r0));

      __ add(end_elements, end_elements, Operand(kEndElementsOffset));

      __ cmp(end_elements, r3);

      __ b(ne, &call_builtin);

      // We fit and could grow elements.

      // Update new_space_allocation_top.

      // Push the argument.

      __ str(r2, MemOperand(end_elements));

      // Fill the rest with holes.

      // Update elements' and array's sizes.

      __ str(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));

      __ add(r4, r4, Operand(Smi::FromInt(kAllocationDelta)));

      __ str(r4, FieldMemOperand(elements, FixedArray::kLengthOffset));

  CheckPrototypes(Handle<JSObject>::cast(object), r1, holder, r0, r3, r4, name,

                  depth, &miss);

  __ bind(&miss);

  FreeSpaceForFastApiCall(masm());

void LoadStubCompiler::GenerateLoadViaGetter(MacroAssembler* masm,

                                             Handle<JSFunction> getter) {

  // ----------- S t a t e -------------

  //  -- r0    : receiver

    if (!getter.is_null()) {

      // Call the JavaScript getter with the receiver on the stack.

      ParameterCount actual(0);

      ParameterCount expected(getter);

      __ InvokeFunction(getter, expected, actual,