src/v8/src/ic/arm64/ic-compiler-arm64.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_ARM64
   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 void PropertyICCompiler::GenerateRuntimeSetProperty(MacroAssembler* masm,
  18                                                     StrictMode strict_mode) {
  19   ASM_LOCATION("PropertyICCompiler::GenerateRuntimeSetProperty");
  20
  21   __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
  22           StoreDescriptor::ValueRegister());
  23
  24   __ Mov(x10, Smi::FromInt(strict_mode));
  25   __ Push(x10);
  26
  27   // Do tail-call to runtime routine.
  28   __ TailCallRuntime(Runtime::kSetProperty, 4, 1);
  29 }
  30
  31
  32 #undef __
  33 #define __ ACCESS_MASM(masm())
  34
  35
  36 Handle<Code> PropertyICCompiler::CompilePolymorphic(TypeHandleList* types,
  37                                                     CodeHandleList* handlers,
  38                                                     Handle<Name> name,
  39                                                     Code::StubType type,
  40                                                     IcCheckType check) {
  41   Label miss;
  42
  43   if (check == PROPERTY &&
  44       (kind() == Code::KEYED_LOAD_IC || kind() == Code::KEYED_STORE_IC)) {
  45     // In case we are compiling an IC for dictionary loads and stores, just
  46     // check whether the name is unique.
  47     if (name.is_identical_to(isolate()->factory()->normal_ic_symbol())) {
  48       Register tmp = scratch1();
  49       __ JumpIfSmi(this->name(), &miss);
  50       __ Ldr(tmp, FieldMemOperand(this->name(), HeapObject::kMapOffset));
  51       __ Ldrb(tmp, FieldMemOperand(tmp, Map::kInstanceTypeOffset));
  52       __ JumpIfNotUniqueNameInstanceType(tmp, &miss);
  53     } else {
  54       __ CompareAndBranch(this->name(), Operand(name), ne, &miss);
  55     }
  56   }
  57
  58   Label number_case;
  59   Label* smi_target = IncludesNumberType(types) ? &number_case : &miss;
  60   __ JumpIfSmi(receiver(), smi_target);
  61
  62   // Polymorphic keyed stores may use the map register
  63   Register map_reg = scratch1();
  64   DCHECK(kind() != Code::KEYED_STORE_IC ||
  65          map_reg.is(ElementTransitionAndStoreDescriptor::MapRegister()));
  66   __ Ldr(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));
  67   int receiver_count = types->length();
  68   int number_of_handled_maps = 0;
  69   for (int current = 0; current < receiver_count; ++current) {
  70     Handle<HeapType> type = types->at(current);
  71     Handle<Map> map = IC::TypeToMap(*type, isolate());
  72     if (!map->is_deprecated()) {
  73       number_of_handled_maps++;
  74       Label try_next;
  75       __ Cmp(map_reg, Operand(map));
  76       __ B(ne, &try_next);
  77       if (type->Is(HeapType::Number())) {
  78         DCHECK(!number_case.is_unused());
  79         __ Bind(&number_case);
  80       }
  81       __ Jump(handlers->at(current), RelocInfo::CODE_TARGET);
  82       __ Bind(&try_next);
  83     }
  84   }
  85   DCHECK(number_of_handled_maps != 0);
  86
  87   __ Bind(&miss);
  88   TailCallBuiltin(masm(), MissBuiltin(kind()));
  89
  90   // Return the generated code.
  91   InlineCacheState state =
  92       (number_of_handled_maps > 1) ? POLYMORPHIC : MONOMORPHIC;
  93   return GetCode(kind(), type, name, state);
  94 }
  95
  96
  97 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(
  98     MapHandleList* receiver_maps, CodeHandleList* handler_stubs,
  99     MapHandleList* transitioned_maps) {
 100   Label miss;
 101
 102   ASM_LOCATION("PropertyICCompiler::CompileStorePolymorphic");
 103
 104   __ JumpIfSmi(receiver(), &miss);
 105
 106   int receiver_count = receiver_maps->length();
 107   __ Ldr(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset));
 108   for (int i = 0; i < receiver_count; i++) {
 109     __ Cmp(scratch1(), Operand(receiver_maps->at(i)));
 110
 111     Label skip;
 112     __ B(&skip, ne);
 113     if (!transitioned_maps->at(i).is_null()) {
 114       // This argument is used by the handler stub. For example, see
 115       // ElementsTransitionGenerator::GenerateMapChangeElementsTransition.
 116       __ Mov(transition_map(), Operand(transitioned_maps->at(i)));
 117     }
 118     __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET);
 119     __ Bind(&skip);
 120   }
 121
 122   __ Bind(&miss);
 123   TailCallBuiltin(masm(), MissBuiltin(kind()));
 124
 125   return GetCode(kind(), Code::NORMAL, factory()->empty_string(), POLYMORPHIC);
 126 }
 127
 128
 129 #undef __
 130 }
 131 }  // namespace v8::internal
 132
 133 #endif  // V8_TARGET_ARCH_ARM64