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.

  __ Ret(USE_DELAY_SLOT);

  __ lw(v0, FieldMemOperand(receiver, String::kLengthOffset));

}

}

    MacroAssembler* masm,

    Handle<JSObject> holder,

    Register holder_reg,

// Generate StoreTransition code, value is passed in a0 register.

// After executing generated code, the receiver_reg and name_reg

// may be clobbered.

  // a0 : value.

  Label exit;

// 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.

  // a0 : value

  Label exit;

}

  if (!label->is_unused()) {

    __ bind(label);

    __ li(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();

  __ LoadHeapObject(t1, function);

  __ lw(cp, FieldMemOperand(t1, 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 {

    __ li(t2, call_data);

  }

  __ li(t3, Operand(ExternalReference::isolate_address(masm->isolate())));

  __ LoadRoot(t1, 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 built at sp + 1 (sp is a reserved spot for ra).

  __ Addu(a0, sp, kPointerSize);

  __ sw(a2, MemOperand(a0, 0 * kPointerSize));

  __ sw(t0, MemOperand(a0, 1 * kPointerSize));

  __ li(t0, Operand(argc));

  __ sw(t0, MemOperand(a0, 2 * kPointerSize));

  __ sw(zero_reg, MemOperand(a0, 3 * kPointerSize));

  const int kStackUnwindSpace = argc + kFastApiCallArguments + 1;

      masm->isolate());

  AllowExternalCallThatCantCauseGC scope(masm);

  __ CallApiFunctionAndReturn(ref,

                              function_address,

                              thunk_ref,

                              a1,

                              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.

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

  // Write holder to stack frame.

  // Write receiver to stack frame.

  int index = stack_space - 1;

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

    __ sw(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()) {

    __ Branch(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.

  __ LoadObject(v0, 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())) {

    __ li(scratch3(), callback);

    __ lw(scratch3(), FieldMemOperand(scratch3(),

  __ sw(scratch4(), MemOperand(sp, 2 * kPointerSize));

  __ sw(reg, MemOperand(sp, 1 * kPointerSize));

  __ sw(name(), MemOperand(sp, 0 * kPointerSize));

  __ mov(a2, scratch2());  // Saved in case scratch2 == a1.

  __ mov(a0, sp);  // (first argument - a0) = Handle<Name>

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

  __ EnterExitFrame(false, kApiStackSpace);

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

  __ sw(a2, MemOperand(sp, kPointerSize));

  // (second argument - a1) = AccessorInfo&

  __ Addu(a1, sp, kPointerSize);

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

  ApiFunction fun(getter_address);

  ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL;

                              thunk_ref,

                              a2,

                              kStackUnwindSpace,

}

    Register holder_reg,

    Handle<JSObject> object,

    Handle<JSObject> interceptor_holder,

  CheckPrototypes(Handle<JSObject>::cast(object), a1, holder, a0, a3, t0, name,

                  depth, &miss);

  __ bind(&miss);

  FreeSpaceForFastApiCall(masm());

void LoadStubCompiler::GenerateLoadViaGetter(MacroAssembler* masm,

                                             Handle<JSFunction> getter) {

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

  //  -- a0    : 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,