deps/v8/src/ic/arm/ic-compiler-arm.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_ARM
   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(MacroAssembler* masm,
  19                                                     StrictMode strict_mode) {
  20   __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
  21           StoreDescriptor::ValueRegister());
  22
  23   __ mov(r0, Operand(Smi::FromInt(strict_mode)));
  24   __ Push(r0);
  25
  26   // Do tail-call to runtime routine.
  27   __ TailCallRuntime(Runtime::kSetProperty, 4, 1);
  28 }
  29
  30
  31 #undef __
  32 #define __ ACCESS_MASM(masm())
  33
  34
  35 Handle<Code> PropertyICCompiler::CompilePolymorphic(TypeHandleList* types,
  36                                                     CodeHandleList* handlers,
  37                                                     Handle<Name> name,
  38                                                     Code::StubType type,
  39                                                     IcCheckType check) {
  40   Label miss;
  41
  42   if (check == PROPERTY &&
  43       (kind() == Code::KEYED_LOAD_IC || kind() == Code::KEYED_STORE_IC)) {
  44     // In case we are compiling an IC for dictionary loads or stores, just
  45     // check whether the name is unique.
  46     if (name.is_identical_to(isolate()->factory()->normal_ic_symbol())) {
  47       // Keyed loads with dictionaries shouldn't be here, they go generic.
  48       // The DCHECK is to protect assumptions when --vector-ics is on.
  49       DCHECK(kind() != Code::KEYED_LOAD_IC);
  50       Register tmp = scratch1();
  51       __ JumpIfSmi(this->name(), &miss);
  52       __ ldr(tmp, FieldMemOperand(this->name(), HeapObject::kMapOffset));
  53       __ ldrb(tmp, FieldMemOperand(tmp, Map::kInstanceTypeOffset));
  54       __ JumpIfNotUniqueNameInstanceType(tmp, &miss);
  55     } else {
  56       __ cmp(this->name(), Operand(name));
  57       __ b(ne, &miss);
  58     }
  59   }
  60
  61   Label number_case;
  62   Label* smi_target = IncludesNumberType(types) ? &number_case : &miss;
  63   __ JumpIfSmi(receiver(), smi_target);
  64
  65   // Polymorphic keyed stores may use the map register
  66   Register map_reg = scratch1();
  67   DCHECK(kind() != Code::KEYED_STORE_IC ||
  68          map_reg.is(ElementTransitionAndStoreDescriptor::MapRegister()));
  69
  70   int receiver_count = types->length();
  71   int number_of_handled_maps = 0;
  72   __ ldr(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));
  73   for (int current = 0; current < receiver_count; ++current) {
  74     Handle<HeapType> type = types->at(current);
  75     Handle<Map> map = IC::TypeToMap(*type, isolate());
  76     if (!map->is_deprecated()) {
  77       number_of_handled_maps++;
  78       Handle<WeakCell> cell = Map::WeakCellForMap(map);
  79       __ CmpWeakValue(map_reg, cell, scratch2());
  80       if (type->Is(HeapType::Number())) {
  81         DCHECK(!number_case.is_unused());
  82         __ bind(&number_case);
  83       }
  84       __ Jump(handlers->at(current), RelocInfo::CODE_TARGET, eq);
  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   __ ldr(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       __ b(ne, &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_ARM