handler-compiler-ppc.cc 24.5 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#if V8_TARGET_ARCH_PPC

#include "src/ic/handler-compiler.h"
8

9
#include "src/api-arguments.h"
10 11
#include "src/field-type.h"
#include "src/ic/call-optimization.h"
12
#include "src/ic/ic.h"
13
#include "src/isolate-inl.h"
14 15 16 17 18 19 20 21

namespace v8 {
namespace internal {

#define __ ACCESS_MASM(masm)


void NamedLoadHandlerCompiler::GenerateLoadViaGetter(
22 23
    MacroAssembler* masm, Handle<Map> map, Register receiver, Register holder,
    int accessor_index, int expected_arguments, Register scratch) {
24 25 26 27 28 29
  // ----------- S t a t e -------------
  //  -- r3    : receiver
  //  -- r5    : name
  //  -- lr    : return address
  // -----------------------------------
  {
30
    FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
31

32 33 34
    // Save context register
    __ push(cp);

35 36 37
    if (accessor_index >= 0) {
      DCHECK(!holder.is(scratch));
      DCHECK(!receiver.is(scratch));
38
      // Call the JavaScript getter with the receiver on the stack.
39
      if (map->IsJSGlobalObjectMap()) {
40
        // Swap in the global receiver.
41
        __ LoadP(scratch,
42
                 FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));
43
        receiver = scratch;
44 45
      }
      __ push(receiver);
46
      __ LoadAccessor(r4, holder, accessor_index, ACCESSOR_GETTER);
47 48 49 50
      __ li(r3, Operand::Zero());
      __ Call(masm->isolate()->builtins()->CallFunction(
                  ConvertReceiverMode::kNotNullOrUndefined),
              RelocInfo::CODE_TARGET);
51 52 53 54 55 56 57
    } else {
      // If we generate a global code snippet for deoptimization only, remember
      // the place to continue after deoptimization.
      masm->isolate()->heap()->SetGetterStubDeoptPCOffset(masm->pc_offset());
    }

    // Restore context register.
58
    __ pop(cp);
59 60 61 62 63 64
  }
  __ Ret();
}


void NamedStoreHandlerCompiler::GenerateStoreViaSetter(
65 66
    MacroAssembler* masm, Handle<Map> map, Register receiver, Register holder,
    int accessor_index, int expected_arguments, Register scratch) {
67 68 69 70
  // ----------- S t a t e -------------
  //  -- lr    : return address
  // -----------------------------------
  {
71
    FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
72

73
    // Save context register
74
    // Save value register, so we can restore it later.
75
    __ Push(cp, value());
76

77 78 79 80
    if (accessor_index >= 0) {
      DCHECK(!holder.is(scratch));
      DCHECK(!receiver.is(scratch));
      DCHECK(!value().is(scratch));
81
      // Call the JavaScript setter with receiver and value on the stack.
82
      if (map->IsJSGlobalObjectMap()) {
83
        // Swap in the global receiver.
84
        __ LoadP(scratch,
85
                 FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));
86
        receiver = scratch;
87 88
      }
      __ Push(receiver, value());
89
      __ LoadAccessor(r4, holder, accessor_index, ACCESSOR_SETTER);
90 91 92 93
      __ li(r3, Operand(1));
      __ Call(masm->isolate()->builtins()->CallFunction(
                  ConvertReceiverMode::kNotNullOrUndefined),
              RelocInfo::CODE_TARGET);
94 95 96 97 98 99 100 101
    } else {
      // If we generate a global code snippet for deoptimization only, remember
      // the place to continue after deoptimization.
      masm->isolate()->heap()->SetSetterStubDeoptPCOffset(masm->pc_offset());
    }

    // We have to return the passed value, not the return value of the setter.
    // Restore context register.
102
    __ Pop(cp, r3);
103 104 105 106 107
  }
  __ Ret();
}


108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
void PropertyHandlerCompiler::PushVectorAndSlot(Register vector,
                                                Register slot) {
  MacroAssembler* masm = this->masm();
  __ Push(vector, slot);
}


void PropertyHandlerCompiler::PopVectorAndSlot(Register vector, Register slot) {
  MacroAssembler* masm = this->masm();
  __ Pop(vector, slot);
}


void PropertyHandlerCompiler::DiscardVectorAndSlot() {
  MacroAssembler* masm = this->masm();
  // Remove vector and slot.
  __ addi(sp, sp, Operand(2 * kPointerSize));
}


128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
void PropertyHandlerCompiler::GenerateDictionaryNegativeLookup(
    MacroAssembler* masm, Label* miss_label, Register receiver,
    Handle<Name> name, Register scratch0, Register scratch1) {
  DCHECK(name->IsUniqueName());
  DCHECK(!receiver.is(scratch0));
  Counters* counters = masm->isolate()->counters();
  __ IncrementCounter(counters->negative_lookups(), 1, scratch0, scratch1);
  __ IncrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);

  Label done;

  const int kInterceptorOrAccessCheckNeededMask =
      (1 << Map::kHasNamedInterceptor) | (1 << Map::kIsAccessCheckNeeded);

  // Bail out if the receiver has a named interceptor or requires access checks.
  Register map = scratch1;
  __ LoadP(map, FieldMemOperand(receiver, HeapObject::kMapOffset));
  __ lbz(scratch0, FieldMemOperand(map, Map::kBitFieldOffset));
  __ andi(r0, scratch0, Operand(kInterceptorOrAccessCheckNeededMask));
  __ bne(miss_label, cr0);

  // Check that receiver is a JSObject.
  __ lbz(scratch0, FieldMemOperand(map, Map::kInstanceTypeOffset));
151
  __ cmpi(scratch0, Operand(FIRST_JS_RECEIVER_TYPE));
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
  __ blt(miss_label);

  // Load properties array.
  Register properties = scratch0;
  __ LoadP(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
  // Check that the properties array is a dictionary.
  __ LoadP(map, FieldMemOperand(properties, HeapObject::kMapOffset));
  Register tmp = properties;
  __ LoadRoot(tmp, Heap::kHashTableMapRootIndex);
  __ cmp(map, tmp);
  __ bne(miss_label);

  // Restore the temporarily used register.
  __ LoadP(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));


  NameDictionaryLookupStub::GenerateNegativeLookup(
      masm, miss_label, &done, receiver, properties, name, scratch1);
  __ bind(&done);
  __ DecrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);
}


void NamedLoadHandlerCompiler::GenerateDirectLoadGlobalFunctionPrototype(
176
    MacroAssembler* masm, int index, Register result, Label* miss) {
177
  __ LoadNativeContextSlot(index, result);
178
  // Load its initial map. The global functions all have initial maps.
179 180
  __ LoadP(result,
           FieldMemOperand(result, JSFunction::kPrototypeOrInitialMapOffset));
181
  // Load the prototype from the initial map.
182
  __ LoadP(result, FieldMemOperand(result, Map::kPrototypeOffset));
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
}


void NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(
    MacroAssembler* masm, Register receiver, Register scratch1,
    Register scratch2, Label* miss_label) {
  __ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);
  __ mr(r3, scratch1);
  __ Ret();
}


// Generate code to check that a global property cell is empty. Create
// the property cell at compilation time if no cell exists for the
// property.
void PropertyHandlerCompiler::GenerateCheckPropertyCell(
    MacroAssembler* masm, Handle<JSGlobalObject> global, Handle<Name> name,
    Register scratch, Label* miss) {
201
  Handle<PropertyCell> cell = JSGlobalObject::EnsurePropertyCell(global, name);
202 203 204
  Isolate* isolate = masm->isolate();
  DCHECK(cell->value()->IsTheHole(isolate));
  Handle<WeakCell> weak_cell = isolate->factory()->NewWeakCell(cell);
205
  __ LoadWeakValue(scratch, weak_cell, miss);
206
  __ LoadP(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
207 208 209 210 211 212 213 214 215 216
  __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
  __ cmp(scratch, ip);
  __ bne(miss);
}


static void PushInterceptorArguments(MacroAssembler* masm, Register receiver,
                                     Register holder, Register name,
                                     Handle<JSObject> holder_obj) {
  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0);
217 218 219
  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 1);
  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 2);
  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 3);
220 221 222 223 224 225 226 227
  __ push(name);
  __ push(receiver);
  __ push(holder);
}


static void CompileCallLoadPropertyWithInterceptor(
    MacroAssembler* masm, Register receiver, Register holder, Register name,
228
    Handle<JSObject> holder_obj, Runtime::FunctionId id) {
229 230
  DCHECK(NamedLoadHandlerCompiler::kInterceptorArgsLength ==
         Runtime::FunctionForId(id)->nargs);
231
  PushInterceptorArguments(masm, receiver, holder, name, holder_obj);
232
  __ CallRuntime(id);
233 234 235 236
}


// Generate call to api function.
237
void PropertyHandlerCompiler::GenerateApiAccessorCall(
238 239
    MacroAssembler* masm, const CallOptimization& optimization,
    Handle<Map> receiver_map, Register receiver, Register scratch_in,
240 241 242
    bool is_store, Register store_parameter, Register accessor_holder,
    int accessor_index) {
  DCHECK(!accessor_holder.is(scratch_in));
243 244 245
  DCHECK(!receiver.is(scratch_in));
  __ push(receiver);
  // Write the arguments to stack frame.
246 247 248 249
  if (is_store) {
    DCHECK(!receiver.is(store_parameter));
    DCHECK(!scratch_in.is(store_parameter));
    __ push(store_parameter);
250 251 252
  }
  DCHECK(optimization.is_simple_api_call());

vogelheim's avatar
vogelheim committed
253
  // Abi for CallApiCallbackStub.
254
  Register callee = r3;
255
  Register data = r7;
256 257 258
  Register holder = r5;
  Register api_function_address = r4;

259 260 261 262
  // Put callee in place.
  __ LoadAccessor(callee, accessor_holder, accessor_index,
                  is_store ? ACCESSOR_SETTER : ACCESSOR_GETTER);

263 264
  // Put holder in place.
  CallOptimization::HolderLookup holder_lookup;
265 266 267
  int holder_depth = 0;
  optimization.LookupHolderOfExpectedType(receiver_map, &holder_lookup,
                                          &holder_depth);
268 269 270 271 272
  switch (holder_lookup) {
    case CallOptimization::kHolderIsReceiver:
      __ Move(holder, receiver);
      break;
    case CallOptimization::kHolderFound:
273 274 275 276 277 278
      __ LoadP(holder, FieldMemOperand(receiver, HeapObject::kMapOffset));
      __ LoadP(holder, FieldMemOperand(holder, Map::kPrototypeOffset));
      for (int i = 1; i < holder_depth; i++) {
        __ LoadP(holder, FieldMemOperand(holder, HeapObject::kMapOffset));
        __ LoadP(holder, FieldMemOperand(holder, Map::kPrototypeOffset));
      }
279 280 281 282 283 284 285 286 287
      break;
    case CallOptimization::kHolderNotFound:
      UNREACHABLE();
      break;
  }

  Isolate* isolate = masm->isolate();
  Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
  bool call_data_undefined = false;
288
  // Put call data in place.
289
  if (api_call_info->data()->IsUndefined(isolate)) {
290
    call_data_undefined = true;
291
    __ LoadRoot(data, Heap::kUndefinedValueRootIndex);
292
  } else {
293 294 295 296 297 298 299 300 301 302 303
    if (optimization.is_constant_call()) {
      __ LoadP(data,
               FieldMemOperand(callee, JSFunction::kSharedFunctionInfoOffset));
      __ LoadP(data,
               FieldMemOperand(data, SharedFunctionInfo::kFunctionDataOffset));
      __ LoadP(data,
               FieldMemOperand(data, FunctionTemplateInfo::kCallCodeOffset));
    } else {
      __ LoadP(data,
               FieldMemOperand(callee, FunctionTemplateInfo::kCallCodeOffset));
    }
304
    __ LoadP(data, FieldMemOperand(data, CallHandlerInfo::kDataOffset));
305 306
  }

307 308 309 310 311 312 313
  if (api_call_info->fast_handler()->IsCode()) {
    // Just tail call into the fast handler if present.
    __ Jump(handle(Code::cast(api_call_info->fast_handler())),
            RelocInfo::CODE_TARGET);
    return;
  }

314 315 316 317 318 319 320 321
  // Put api_function_address in place.
  Address function_address = v8::ToCData<Address>(api_call_info->callback());
  ApiFunction fun(function_address);
  ExternalReference::Type type = ExternalReference::DIRECT_API_CALL;
  ExternalReference ref = ExternalReference(&fun, type, masm->isolate());
  __ mov(api_function_address, Operand(ref));

  // Jump to stub.
vogelheim's avatar
vogelheim committed
322
  CallApiCallbackStub stub(isolate, is_store, call_data_undefined,
323
                           !optimization.is_constant_call());
324 325 326 327
  __ TailCallStub(&stub);
}


328
static void StoreIC_PushArgs(MacroAssembler* masm) {
329 330 331 332
  __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
          StoreDescriptor::ValueRegister(),
          VectorStoreICDescriptor::SlotRegister(),
          VectorStoreICDescriptor::VectorRegister());
333 334 335
}


336
void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
337
  StoreIC_PushArgs(masm);
338 339 340

  // The slow case calls into the runtime to complete the store without causing
  // an IC miss that would otherwise cause a transition to the generic stub.
341
  __ TailCallRuntime(Runtime::kStoreIC_Slow);
342 343 344 345
}


void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
346
  StoreIC_PushArgs(masm);
347 348 349

  // The slow case calls into the runtime to complete the store without causing
  // an IC miss that would otherwise cause a transition to the generic stub.
350
  __ TailCallRuntime(Runtime::kKeyedStoreIC_Slow);
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
}


#undef __
#define __ ACCESS_MASM(masm())


void NamedStoreHandlerCompiler::GenerateRestoreName(Label* label,
                                                    Handle<Name> name) {
  if (!label->is_unused()) {
    __ bind(label);
    __ mov(this->name(), Operand(name));
  }
}


367
void NamedStoreHandlerCompiler::GenerateRestoreName(Handle<Name> name) {
368 369 370 371
  __ mov(this->name(), Operand(name));
}


372 373
void NamedStoreHandlerCompiler::RearrangeVectorAndSlot(
    Register current_map, Register destination_map) {
374 375 376 377
  DCHECK(false);  // Not implemented.
}


378
void NamedStoreHandlerCompiler::GenerateRestoreMap(Handle<Map> transition,
379
                                                   Register map_reg,
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
                                                   Register scratch,
                                                   Label* miss) {
  Handle<WeakCell> cell = Map::WeakCellForMap(transition);
  DCHECK(!map_reg.is(scratch));
  __ LoadWeakValue(map_reg, cell, miss);
  if (transition->CanBeDeprecated()) {
    __ lwz(scratch, FieldMemOperand(map_reg, Map::kBitField3Offset));
    __ DecodeField<Map::Deprecated>(r0, scratch, SetRC);
    __ bne(miss, cr0);
  }
}


void NamedStoreHandlerCompiler::GenerateConstantCheck(Register map_reg,
                                                      int descriptor,
395
                                                      Register value_reg,
396
                                                      Register scratch,
397
                                                      Label* miss_label) {
398 399 400 401 402 403 404
  DCHECK(!map_reg.is(scratch));
  DCHECK(!map_reg.is(value_reg));
  DCHECK(!value_reg.is(scratch));
  __ LoadInstanceDescriptors(map_reg, scratch);
  __ LoadP(scratch, FieldMemOperand(
                        scratch, DescriptorArray::GetValueOffset(descriptor)));
  __ cmp(value_reg, scratch);
405 406 407
  __ bne(miss_label);
}

408
void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(FieldType* field_type,
409 410
                                                        Register value_reg,
                                                        Label* miss_label) {
411 412 413 414
  Register map_reg = scratch1();
  Register scratch = scratch2();
  DCHECK(!value_reg.is(map_reg));
  DCHECK(!value_reg.is(scratch));
415
  __ JumpIfSmi(value_reg, miss_label);
jarin's avatar
jarin committed
416
  if (field_type->IsClass()) {
417
    __ LoadP(map_reg, FieldMemOperand(value_reg, HeapObject::kMapOffset));
jarin's avatar
jarin committed
418 419 420
    __ CmpWeakValue(map_reg, Map::WeakCellForMap(field_type->AsClass()),
                    scratch);
    __ bne(miss_label);
421 422 423 424 425 426
  }
}


Register PropertyHandlerCompiler::CheckPrototypes(
    Register object_reg, Register holder_reg, Register scratch1,
427 428
    Register scratch2, Handle<Name> name, Label* miss, PrototypeCheckType check,
    ReturnHolder return_what) {
429
  Handle<Map> receiver_map = map();
430 431 432 433 434 435

  // Make sure there's no overlap between holder and object registers.
  DCHECK(!scratch1.is(object_reg) && !scratch1.is(holder_reg));
  DCHECK(!scratch2.is(object_reg) && !scratch2.is(holder_reg) &&
         !scratch2.is(scratch1));

436 437 438 439 440 441 442 443 444
  Handle<Cell> validity_cell =
      Map::GetOrCreatePrototypeChainValidityCell(receiver_map, isolate());
  if (!validity_cell.is_null()) {
    DCHECK_EQ(Smi::FromInt(Map::kPrototypeChainValid), validity_cell->value());
    __ mov(scratch1, Operand(validity_cell));
    __ LoadP(scratch1, FieldMemOperand(scratch1, Cell::kValueOffset));
    __ CmpSmiLiteral(scratch1, Smi::FromInt(Map::kPrototypeChainValid), r0);
    __ bne(miss);
  }
445

446 447 448 449 450 451 452 453 454
  // The prototype chain of primitives (and their JSValue wrappers) depends
  // on the native context, which can't be guarded by validity cells.
  // |object_reg| holds the native context specific prototype in this case;
  // we need to check its map.
  if (check == CHECK_ALL_MAPS) {
    __ LoadP(scratch1, FieldMemOperand(object_reg, HeapObject::kMapOffset));
    Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
    __ CmpWeakValue(scratch1, cell, scratch2);
    __ b(ne, miss);
455 456
  }

457 458 459 460 461
  // Keep track of the current object in register reg.
  Register reg = object_reg;
  int depth = 0;

  Handle<JSObject> current = Handle<JSObject>::null();
462 463
  if (receiver_map->IsJSGlobalObjectMap()) {
    current = isolate()->global_object();
464
  }
465 466 467 468 469 470 471 472 473 474
  // Check access rights to the global object.  This has to happen after
  // the map check so that we know that the object is actually a global
  // object.
  // This allows us to install generated handlers for accesses to the
  // global proxy (as opposed to using slow ICs). See corresponding code
  // in LookupForRead().
  if (receiver_map->IsJSGlobalProxyMap()) {
    __ CheckAccessGlobalProxy(reg, scratch2, miss);
  }

475 476 477 478 479 480 481 482 483 484 485 486 487 488
  Handle<JSObject> prototype = Handle<JSObject>::null();
  Handle<Map> current_map = receiver_map;
  Handle<Map> holder_map(holder()->map());
  // Traverse the prototype chain and check the maps in the prototype chain for
  // fast and global objects or do negative lookup for normal objects.
  while (!current_map.is_identical_to(holder_map)) {
    ++depth;

    // Only global objects and objects that do not require access
    // checks are allowed in stubs.
    DCHECK(current_map->IsJSGlobalProxyMap() ||
           !current_map->is_access_check_needed());

    prototype = handle(JSObject::cast(current_map->prototype()));
489 490 491 492
    if (current_map->IsJSGlobalObjectMap()) {
      GenerateCheckPropertyCell(masm(), Handle<JSGlobalObject>::cast(current),
                                name, scratch2, miss);
    } else if (current_map->is_dictionary_map()) {
493 494 495 496 497 498 499 500 501
      DCHECK(!current_map->IsJSGlobalProxyMap());  // Proxy maps are fast.
      if (!name->IsUniqueName()) {
        DCHECK(name->IsString());
        name = factory()->InternalizeString(Handle<String>::cast(name));
      }
      DCHECK(current.is_null() ||
             current->property_dictionary()->FindEntry(name) ==
                 NameDictionary::kNotFound);

502
      if (depth > 1) {
503 504 505
        // TODO(jkummerow): Cache and re-use weak cell.
        __ LoadWeakValue(reg, isolate()->factory()->NewWeakCell(current), miss);
      }
506 507 508 509
      GenerateDictionaryNegativeLookup(masm(), miss, reg, name, scratch1,
                                       scratch2);
    }

510
    reg = holder_reg;  // From now on the object will be in holder_reg.
511 512 513 514 515
    // Go to the next object in the prototype chain.
    current = prototype;
    current_map = handle(current->map());
  }

516 517
  DCHECK(!current_map->IsJSGlobalProxyMap());

518 519 520
  // Log the check depth.
  LOG(isolate(), IntEvent("check-maps-depth", depth + 1));

521
  bool return_holder = return_what == RETURN_HOLDER;
522
  if (return_holder && depth != 0) {
523 524 525
    __ LoadWeakValue(reg, isolate()->factory()->NewWeakCell(current), miss);
  }

526
  // Return the register containing the holder.
527
  return return_holder ? reg : no_reg;
528 529 530 531 532 533 534 535
}


void NamedLoadHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
  if (!miss->is_unused()) {
    Label success;
    __ b(&success);
    __ bind(miss);
536 537 538 539
    if (IC::ICUseVector(kind())) {
      DCHECK(kind() == Code::LOAD_IC);
      PopVectorAndSlot();
    }
540 541 542 543 544 545 546 547 548 549 550
    TailCallBuiltin(masm(), MissBuiltin(kind()));
    __ bind(&success);
  }
}


void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
  if (!miss->is_unused()) {
    Label success;
    __ b(&success);
    GenerateRestoreName(miss, name);
551
    if (IC::ICUseVector(kind())) PopVectorAndSlot();
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
    TailCallBuiltin(masm(), MissBuiltin(kind()));
    __ bind(&success);
  }
}


void NamedLoadHandlerCompiler::GenerateLoadConstant(Handle<Object> value) {
  // Return the constant value.
  __ Move(r3, value);
  __ Ret();
}


void NamedLoadHandlerCompiler::GenerateLoadInterceptorWithFollowup(
    LookupIterator* it, Register holder_reg) {
  DCHECK(holder()->HasNamedInterceptor());
568
  DCHECK(!holder()->GetNamedInterceptor()->getter()->IsUndefined(isolate()));
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587

  // Compile the interceptor call, followed by inline code to load the
  // property from further up the prototype chain if the call fails.
  // Check that the maps haven't changed.
  DCHECK(holder_reg.is(receiver()) || holder_reg.is(scratch1()));

  // Preserve the receiver register explicitly whenever it is different from the
  // holder and it is needed should the interceptor return without any result.
  // The ACCESSOR case needs the receiver to be passed into C++ code, the FIELD
  // case might cause a miss during the prototype check.
  bool must_perform_prototype_check =
      !holder().is_identical_to(it->GetHolder<JSObject>());
  bool must_preserve_receiver_reg =
      !receiver().is(holder_reg) &&
      (it->state() == LookupIterator::ACCESSOR || must_perform_prototype_check);

  // Save necessary data before invoking an interceptor.
  // Requires a frame to make GC aware of pushed pointers.
  {
588
    FrameAndConstantPoolScope frame_scope(masm(), StackFrame::INTERNAL);
589 590 591 592 593
    if (must_preserve_receiver_reg) {
      __ Push(receiver(), holder_reg, this->name());
    } else {
      __ Push(holder_reg, this->name());
    }
594
    InterceptorVectorSlotPush(holder_reg);
595 596 597 598 599
    // Invoke an interceptor.  Note: map checks from receiver to
    // interceptor's holder has been compiled before (see a caller
    // of this method.)
    CompileCallLoadPropertyWithInterceptor(
        masm(), receiver(), holder_reg, this->name(), holder(),
600
        Runtime::kLoadPropertyWithInterceptorOnly);
601 602 603 604 605 606 607 608 609 610 611

    // Check if interceptor provided a value for property.  If it's
    // the case, return immediately.
    Label interceptor_failed;
    __ LoadRoot(scratch1(), Heap::kNoInterceptorResultSentinelRootIndex);
    __ cmp(r3, scratch1());
    __ beq(&interceptor_failed);
    frame_scope.GenerateLeaveFrame();
    __ Ret();

    __ bind(&interceptor_failed);
612
    InterceptorVectorSlotPop(holder_reg);
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
    __ pop(this->name());
    __ pop(holder_reg);
    if (must_preserve_receiver_reg) {
      __ pop(receiver());
    }
    // Leave the internal frame.
  }

  GenerateLoadPostInterceptor(it, holder_reg);
}


void NamedLoadHandlerCompiler::GenerateLoadInterceptor(Register holder_reg) {
  // Call the runtime system to load the interceptor.
  DCHECK(holder()->HasNamedInterceptor());
628
  DCHECK(!holder()->GetNamedInterceptor()->getter()->IsUndefined(isolate()));
629 630 631
  PushInterceptorArguments(masm(), receiver(), holder_reg, this->name(),
                           holder());

632
  __ TailCallRuntime(Runtime::kLoadPropertyWithInterceptor);
633 634 635 636
}


Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
637 638
    Handle<JSObject> object, Handle<Name> name, Handle<AccessorInfo> callback,
    LanguageMode language_mode) {
639
  Register holder_reg = Frontend(name);
640 641

  __ Push(receiver(), holder_reg);  // receiver
642 643 644

  // If the callback cannot leak, then push the callback directly,
  // otherwise wrap it in a weak cell.
645
  if (callback->data()->IsUndefined(isolate()) || callback->data()->IsSmi()) {
646 647 648 649 650
    __ mov(ip, Operand(callback));
  } else {
    Handle<WeakCell> cell = isolate()->factory()->NewWeakCell(callback);
    __ mov(ip, Operand(cell));
  }
651 652 653
  __ push(ip);
  __ mov(ip, Operand(name));
  __ Push(ip, value());
654
  __ Push(Smi::FromInt(language_mode));
655 656

  // Do tail-call to the runtime system.
657
  __ TailCallRuntime(Runtime::kStoreCallbackProperty);
658 659

  // Return the generated code.
660
  return GetCode(kind(), name);
661 662 663 664 665 666 667 668 669 670 671
}


Register NamedStoreHandlerCompiler::value() {
  return StoreDescriptor::ValueRegister();
}


Handle<Code> NamedLoadHandlerCompiler::CompileLoadGlobal(
    Handle<PropertyCell> cell, Handle<Name> name, bool is_configurable) {
  Label miss;
672 673 674
  if (IC::ICUseVector(kind())) {
    PushVectorAndSlot();
  }
675
  FrontendHeader(receiver(), name, &miss, DONT_RETURN_ANYTHING);
676 677 678

  // Get the value from the cell.
  Register result = StoreDescriptor::ValueRegister();
679 680
  Handle<WeakCell> weak_cell = factory()->NewWeakCell(cell);
  __ LoadWeakValue(result, weak_cell, &miss);
681
  __ LoadP(result, FieldMemOperand(result, PropertyCell::kValueOffset));
682 683 684 685 686 687 688 689 690

  // Check for deleted property if property can actually be deleted.
  if (is_configurable) {
    __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
    __ cmp(result, ip);
    __ beq(&miss);
  }

  Counters* counters = isolate()->counters();
cbruni's avatar
cbruni committed
691
  __ IncrementCounter(counters->ic_named_load_global_stub(), 1, r4, r6);
692 693 694
  if (IC::ICUseVector(kind())) {
    DiscardVectorAndSlot();
  }
695 696 697 698 699
  __ Ret();

  FrontendFooter(name, &miss);

  // Return the generated code.
700
  return GetCode(kind(), name);
701 702 703 704
}


#undef __
705 706
}  // namespace internal
}  // namespace v8
707 708

#endif  // V8_TARGET_ARCH_ARM