deps/v8/src/ic/ppc/ic-compiler-ppc.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #if V8_TARGET_ARCH_PPC
   8
   9 #include "src/ic/ic.h"
  10 #include "src/ic/ic-compiler.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15 #define __ ACCESS_MASM(masm)
  16
  17
  18 void PropertyICCompiler::GenerateRuntimeSetProperty(
  19     MacroAssembler* masm, LanguageMode language_mode) {
  20   __ mov(r0, Operand(Smi::FromInt(language_mode)));
  21   __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
  22           StoreDescriptor::ValueRegister(), r0);
  23
  24   // Do tail-call to runtime routine.
  25   __ TailCallRuntime(Runtime::kSetProperty, 4, 1);
  26 }
  27
  28
  29 #undef __
  30 #define __ ACCESS_MASM(masm())
  31
  32
  33 Handle<Code> PropertyICCompiler::CompilePolymorphic(MapHandleList* maps,
  34                                                     CodeHandleList* handlers,
  35                                                     Handle<Name> name,
  36                                                     Code::StubType type,
  37                                                     IcCheckType check) {
  38   Label miss;
  39
  40   if (check == PROPERTY &&
  41       (kind() == Code::KEYED_LOAD_IC || kind() == Code::KEYED_STORE_IC)) {
  42     // In case we are compiling an IC for dictionary loads or stores, just
  43     // check whether the name is unique.
  44     if (name.is_identical_to(isolate()->factory()->normal_ic_symbol())) {
  45       // Keyed loads with dictionaries shouldn't be here, they go generic.
  46       // The DCHECK is to protect assumptions when --vector-ics is on.
  47       DCHECK(kind() != Code::KEYED_LOAD_IC);
  48       Register tmp = scratch1();
  49       __ JumpIfSmi(this->name(), &miss);
  50       __ LoadP(tmp, FieldMemOperand(this->name(), HeapObject::kMapOffset));
  51       __ lbz(tmp, FieldMemOperand(tmp, Map::kInstanceTypeOffset));
  52       __ JumpIfNotUniqueNameInstanceType(tmp, &miss);
  53     } else {
  54       __ Cmpi(this->name(), Operand(name), r0);
  55       __ bne(&miss);
  56     }
  57   }
  58
  59   Label number_case;
  60   Label* smi_target = IncludesNumberMap(maps) ? &number_case : &miss;
  61   __ JumpIfSmi(receiver(), smi_target);
  62
  63   // Polymorphic keyed stores may use the map register
  64   Register map_reg = scratch1();
  65   DCHECK(kind() != Code::KEYED_STORE_IC ||
  66          map_reg.is(ElementTransitionAndStoreDescriptor::MapRegister()));
  67
  68   int receiver_count = maps->length();
  69   int number_of_handled_maps = 0;
  70   __ LoadP(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));
  71   for (int current = 0; current < receiver_count; ++current) {
  72     Handle<Map> map = maps->at(current);
  73     if (!map->is_deprecated()) {
  74       number_of_handled_maps++;
  75       Handle<WeakCell> cell = Map::WeakCellForMap(map);
  76       __ CmpWeakValue(map_reg, cell, scratch2());
  77       Label next;
  78       __ bne(&next);
  79       if (map->instance_type() == HEAP_NUMBER_TYPE) {
  80         DCHECK(!number_case.is_unused());
  81         __ bind(&number_case);
  82       }
  83       __ Jump(handlers->at(current), RelocInfo::CODE_TARGET);
  84       __ bind(&next);
  85     }
  86   }
  87   DCHECK(number_of_handled_maps != 0);
  88
  89   __ bind(&miss);
  90   TailCallBuiltin(masm(), MissBuiltin(kind()));
  91
  92   // Return the generated code.
  93   InlineCacheState state =
  94       number_of_handled_maps > 1 ? POLYMORPHIC : MONOMORPHIC;
  95   return GetCode(kind(), type, name, state);
  96 }
  97
  98
  99 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(
 100     MapHandleList* receiver_maps, CodeHandleList* handler_stubs,
 101     MapHandleList* transitioned_maps) {
 102   Label miss;
 103   __ JumpIfSmi(receiver(), &miss);
 104
 105   int receiver_count = receiver_maps->length();
 106   Register map_reg = scratch1();
 107   __ LoadP(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));
 108   for (int i = 0; i < receiver_count; ++i) {
 109     Handle<WeakCell> cell = Map::WeakCellForMap(receiver_maps->at(i));
 110     __ CmpWeakValue(map_reg, cell, scratch2());
 111     if (transitioned_maps->at(i).is_null()) {
 112       __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, eq);
 113     } else {
 114       Label next_map;
 115       __ bne(&next_map);
 116       Handle<WeakCell> cell = Map::WeakCellForMap(transitioned_maps->at(i));
 117       __ LoadWeakValue(transition_map(), cell, &miss);
 118       __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, al);
 119       __ bind(&next_map);
 120     }
 121   }
 122
 123   __ bind(&miss);
 124   TailCallBuiltin(masm(), MissBuiltin(kind()));
 125
 126   // Return the generated code.
 127   return GetCode(kind(), Code::NORMAL, factory()->empty_string(), POLYMORPHIC);
 128 }
 129
 130
 131 #undef __
 132 }
 133 }  // namespace v8::internal
 134
 135 #endif  // V8_TARGET_ARCH_PPC