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#if V8_TARGET_ARCH_ARM
6
7#include "src/ic/handler-compiler.h"
8
9#include "src/api-arguments.h"
10#include "src/field-type.h"
11#include "src/ic/call-optimization.h"
12#include "src/ic/ic.h"
13#include "src/isolate-inl.h"
14
15namespace v8 {
16namespace internal {
17
18#define __ ACCESS_MASM(masm)
19
20
21void NamedLoadHandlerCompiler::GenerateLoadViaGetter(
22    MacroAssembler* masm, Handle<Map> map, Register receiver, Register holder,
23    int accessor_index, int expected_arguments, Register scratch) {
24  // ----------- S t a t e -------------
25  //  -- r0    : receiver
26  //  -- r2    : name
27  //  -- lr    : return address
28  // -----------------------------------
29  {
30    FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
31
32    // Save context register
33    __ push(cp);
34
35    if (accessor_index >= 0) {
36      DCHECK(!holder.is(scratch));
37      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        __ ldr(scratch,
42               FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));
43        receiver = scratch;
44      }
45      __ push(receiver);
46      __ LoadAccessor(r1, holder, accessor_index, ACCESSOR_GETTER);
47      __ mov(r0, Operand(0));
48      __ Call(masm->isolate()->builtins()->CallFunction(
49                  ConvertReceiverMode::kNotNullOrUndefined),
50              RelocInfo::CODE_TARGET);
51    } else {
52      // If we generate a global code snippet for deoptimization only, remember
53      // the place to continue after deoptimization.
54      masm->isolate()->heap()->SetGetterStubDeoptPCOffset(masm->pc_offset());
55    }
56
57    // Restore context register.
58    __ pop(cp);
59  }
60  __ Ret();
61}
62
63
64void NamedStoreHandlerCompiler::GenerateStoreViaSetter(
65    MacroAssembler* masm, Handle<Map> map, Register receiver, Register holder,
66    int accessor_index, int expected_arguments, Register scratch) {
67  // ----------- S t a t e -------------
68  //  -- lr    : return address
69  // -----------------------------------
70  {
71    FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
72
73    // Save context register
74    __ push(cp);
75    // Save value register, so we can restore it later.
76    __ push(value());
77
78    if (accessor_index >= 0) {
79      DCHECK(!holder.is(scratch));
80      DCHECK(!receiver.is(scratch));
81      DCHECK(!value().is(scratch));
82      // Call the JavaScript setter with receiver and value on the stack.
83      if (map->IsJSGlobalObjectMap()) {
84        // Swap in the global receiver.
85        __ ldr(scratch,
86               FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));
87        receiver = scratch;
88      }
89      __ Push(receiver, value());
90      __ LoadAccessor(r1, holder, accessor_index, ACCESSOR_SETTER);
91      __ mov(r0, Operand(1));
92      __ Call(masm->isolate()->builtins()->CallFunction(
93                  ConvertReceiverMode::kNotNullOrUndefined),
94              RelocInfo::CODE_TARGET);
95    } else {
96      // If we generate a global code snippet for deoptimization only, remember
97      // the place to continue after deoptimization.
98      masm->isolate()->heap()->SetSetterStubDeoptPCOffset(masm->pc_offset());
99    }
100
101    // We have to return the passed value, not the return value of the setter.
102    __ pop(r0);
103
104    // Restore context register.
105    __ pop(cp);
106  }
107  __ Ret();
108}
109
110
111void PropertyHandlerCompiler::PushVectorAndSlot(Register vector,
112                                                Register slot) {
113  MacroAssembler* masm = this->masm();
114  STATIC_ASSERT(LoadWithVectorDescriptor::kSlot <
115                LoadWithVectorDescriptor::kVector);
116  STATIC_ASSERT(StoreWithVectorDescriptor::kSlot <
117                StoreWithVectorDescriptor::kVector);
118  STATIC_ASSERT(StoreTransitionDescriptor::kSlot <
119                StoreTransitionDescriptor::kVector);
120  __ push(slot);
121  __ push(vector);
122}
123
124
125void PropertyHandlerCompiler::PopVectorAndSlot(Register vector, Register slot) {
126  MacroAssembler* masm = this->masm();
127  __ pop(vector);
128  __ pop(slot);
129}
130
131
132void PropertyHandlerCompiler::DiscardVectorAndSlot() {
133  MacroAssembler* masm = this->masm();
134  // Remove vector and slot.
135  __ add(sp, sp, Operand(2 * kPointerSize));
136}
137
138void PropertyHandlerCompiler::GenerateDictionaryNegativeLookup(
139    MacroAssembler* masm, Label* miss_label, Register receiver,
140    Handle<Name> name, Register scratch0, Register scratch1) {
141  DCHECK(name->IsUniqueName());
142  DCHECK(!receiver.is(scratch0));
143  Counters* counters = masm->isolate()->counters();
144  __ IncrementCounter(counters->negative_lookups(), 1, scratch0, scratch1);
145  __ IncrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);
146
147  Label done;
148
149  const int kInterceptorOrAccessCheckNeededMask =
150      (1 << Map::kHasNamedInterceptor) | (1 << Map::kIsAccessCheckNeeded);
151
152  // Bail out if the receiver has a named interceptor or requires access checks.
153  Register map = scratch1;
154  __ ldr(map, FieldMemOperand(receiver, HeapObject::kMapOffset));
155  __ ldrb(scratch0, FieldMemOperand(map, Map::kBitFieldOffset));
156  __ tst(scratch0, Operand(kInterceptorOrAccessCheckNeededMask));
157  __ b(ne, miss_label);
158
159  // Check that receiver is a JSObject.
160  __ ldrb(scratch0, FieldMemOperand(map, Map::kInstanceTypeOffset));
161  __ cmp(scratch0, Operand(FIRST_JS_RECEIVER_TYPE));
162  __ b(lt, miss_label);
163
164  // Load properties array.
165  Register properties = scratch0;
166  __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
167  // Check that the properties array is a dictionary.
168  __ ldr(map, FieldMemOperand(properties, HeapObject::kMapOffset));
169  Register tmp = properties;
170  __ LoadRoot(tmp, Heap::kHashTableMapRootIndex);
171  __ cmp(map, tmp);
172  __ b(ne, miss_label);
173
174  // Restore the temporarily used register.
175  __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
176
177
178  NameDictionaryLookupStub::GenerateNegativeLookup(
179      masm, miss_label, &done, receiver, properties, name, scratch1);
180  __ bind(&done);
181  __ DecrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);
182}
183
184// Generate code to check that a global property cell is empty. Create
185// the property cell at compilation time if no cell exists for the
186// property.
187void PropertyHandlerCompiler::GenerateCheckPropertyCell(
188    MacroAssembler* masm, Handle<JSGlobalObject> global, Handle<Name> name,
189    Register scratch, Label* miss) {
190  Handle<PropertyCell> cell = JSGlobalObject::EnsureEmptyPropertyCell(
191      global, name, PropertyCellType::kInvalidated);
192  Isolate* isolate = masm->isolate();
193  DCHECK(cell->value()->IsTheHole(isolate));
194  Handle<WeakCell> weak_cell = isolate->factory()->NewWeakCell(cell);
195  __ LoadWeakValue(scratch, weak_cell, miss);
196  __ ldr(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
197  __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
198  __ cmp(scratch, ip);
199  __ b(ne, miss);
200}
201
202static void CompileCallLoadPropertyWithInterceptor(
203    MacroAssembler* masm, Register receiver, Register holder, Register name,
204    Handle<JSObject> holder_obj, Runtime::FunctionId id) {
205  DCHECK(NamedLoadHandlerCompiler::kInterceptorArgsLength ==
206         Runtime::FunctionForId(id)->nargs);
207
208  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0);
209  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 1);
210  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 2);
211  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 3);
212  __ push(name);
213  __ push(receiver);
214  __ push(holder);
215
216  __ CallRuntime(id);
217}
218
219
220// Generate call to api function.
221void PropertyHandlerCompiler::GenerateApiAccessorCall(
222    MacroAssembler* masm, const CallOptimization& optimization,
223    Handle<Map> receiver_map, Register receiver, Register scratch_in,
224    bool is_store, Register store_parameter, Register accessor_holder,
225    int accessor_index) {
226  DCHECK(!accessor_holder.is(scratch_in));
227  DCHECK(!receiver.is(scratch_in));
228  __ push(receiver);
229  // Write the arguments to stack frame.
230  if (is_store) {
231    DCHECK(!receiver.is(store_parameter));
232    DCHECK(!scratch_in.is(store_parameter));
233    __ push(store_parameter);
234  }
235  DCHECK(optimization.is_simple_api_call());
236
237  // Abi for CallApiCallbackStub.
238  Register callee = r0;
239  Register data = r4;
240  Register holder = r2;
241  Register api_function_address = r1;
242
243  // Put callee in place.
244  __ LoadAccessor(callee, accessor_holder, accessor_index,
245                  is_store ? ACCESSOR_SETTER : ACCESSOR_GETTER);
246
247  // Put holder in place.
248  CallOptimization::HolderLookup holder_lookup;
249  int holder_depth = 0;
250  optimization.LookupHolderOfExpectedType(receiver_map, &holder_lookup,
251                                          &holder_depth);
252  switch (holder_lookup) {
253    case CallOptimization::kHolderIsReceiver:
254      __ Move(holder, receiver);
255      break;
256    case CallOptimization::kHolderFound:
257      __ ldr(holder, FieldMemOperand(receiver, HeapObject::kMapOffset));
258      __ ldr(holder, FieldMemOperand(holder, Map::kPrototypeOffset));
259      for (int i = 1; i < holder_depth; i++) {
260        __ ldr(holder, FieldMemOperand(holder, HeapObject::kMapOffset));
261        __ ldr(holder, FieldMemOperand(holder, Map::kPrototypeOffset));
262      }
263      break;
264    case CallOptimization::kHolderNotFound:
265      UNREACHABLE();
266      break;
267  }
268
269  Isolate* isolate = masm->isolate();
270  Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
271  bool call_data_undefined = false;
272  // Put call data in place.
273  if (api_call_info->data()->IsUndefined(isolate)) {
274    call_data_undefined = true;
275    __ LoadRoot(data, Heap::kUndefinedValueRootIndex);
276  } else {
277    if (optimization.is_constant_call()) {
278      __ ldr(data,
279             FieldMemOperand(callee, JSFunction::kSharedFunctionInfoOffset));
280      __ ldr(data,
281             FieldMemOperand(data, SharedFunctionInfo::kFunctionDataOffset));
282      __ ldr(data,
283             FieldMemOperand(data, FunctionTemplateInfo::kCallCodeOffset));
284    } else {
285      __ ldr(data,
286             FieldMemOperand(callee, FunctionTemplateInfo::kCallCodeOffset));
287    }
288    __ ldr(data, FieldMemOperand(data, CallHandlerInfo::kDataOffset));
289  }
290
291  if (api_call_info->fast_handler()->IsCode()) {
292    // Just tail call into the fast handler if present.
293    __ Jump(handle(Code::cast(api_call_info->fast_handler())),
294            RelocInfo::CODE_TARGET);
295    return;
296  }
297
298  // Put api_function_address in place.
299  Address function_address = v8::ToCData<Address>(api_call_info->callback());
300  ApiFunction fun(function_address);
301  ExternalReference::Type type = ExternalReference::DIRECT_API_CALL;
302  ExternalReference ref = ExternalReference(&fun, type, masm->isolate());
303  __ mov(api_function_address, Operand(ref));
304
305  // Jump to stub.
306  CallApiCallbackStub stub(isolate, is_store, call_data_undefined,
307                           !optimization.is_constant_call());
308  __ TailCallStub(&stub);
309}
310
311#undef __
312#define __ ACCESS_MASM(masm())
313
314
315void NamedStoreHandlerCompiler::GenerateRestoreName(Label* label,
316                                                    Handle<Name> name) {
317  if (!label->is_unused()) {
318    __ bind(label);
319    __ mov(this->name(), Operand(name));
320  }
321}
322
323void PropertyHandlerCompiler::GenerateAccessCheck(
324    Handle<WeakCell> native_context_cell, Register scratch1, Register scratch2,
325    Label* miss, bool compare_native_contexts_only) {
326  Label done;
327  // Load current native context.
328  __ ldr(scratch1, NativeContextMemOperand());
329  // Load expected native context.
330  __ LoadWeakValue(scratch2, native_context_cell, miss);
331  __ cmp(scratch1, scratch2);
332
333  if (!compare_native_contexts_only) {
334    __ b(eq, &done);
335
336    // Compare security tokens of current and expected native contexts.
337    __ ldr(scratch1,
338           ContextMemOperand(scratch1, Context::SECURITY_TOKEN_INDEX));
339    __ ldr(scratch2,
340           ContextMemOperand(scratch2, Context::SECURITY_TOKEN_INDEX));
341    __ cmp(scratch1, scratch2);
342  }
343  __ b(ne, miss);
344
345  __ bind(&done);
346}
347
348Register PropertyHandlerCompiler::CheckPrototypes(
349    Register object_reg, Register holder_reg, Register scratch1,
350    Register scratch2, Handle<Name> name, Label* miss,
351    ReturnHolder return_what) {
352  Handle<Map> receiver_map = map();
353
354  // Make sure there's no overlap between holder and object registers.
355  DCHECK(!scratch1.is(object_reg) && !scratch1.is(holder_reg));
356  DCHECK(!scratch2.is(object_reg) && !scratch2.is(holder_reg) &&
357         !scratch2.is(scratch1));
358
359  Handle<Cell> validity_cell =
360      Map::GetOrCreatePrototypeChainValidityCell(receiver_map, isolate());
361  if (!validity_cell.is_null()) {
362    DCHECK_EQ(Smi::FromInt(Map::kPrototypeChainValid), validity_cell->value());
363    __ mov(scratch1, Operand(validity_cell));
364    __ ldr(scratch1, FieldMemOperand(scratch1, Cell::kValueOffset));
365    __ cmp(scratch1, Operand(Smi::FromInt(Map::kPrototypeChainValid)));
366    __ b(ne, miss);
367  }
368
369  // Keep track of the current object in register reg.
370  Register reg = object_reg;
371  int depth = 0;
372
373  Handle<JSObject> current = Handle<JSObject>::null();
374  if (receiver_map->IsJSGlobalObjectMap()) {
375    current = isolate()->global_object();
376  }
377
378  Handle<Map> current_map(receiver_map->GetPrototypeChainRootMap(isolate()),
379                          isolate());
380  Handle<Map> holder_map(holder()->map());
381  // Traverse the prototype chain and check the maps in the prototype chain for
382  // fast and global objects or do negative lookup for normal objects.
383  while (!current_map.is_identical_to(holder_map)) {
384    ++depth;
385
386    if (current_map->IsJSGlobalObjectMap()) {
387      GenerateCheckPropertyCell(masm(), Handle<JSGlobalObject>::cast(current),
388                                name, scratch2, miss);
389    } else if (current_map->is_dictionary_map()) {
390      DCHECK(!current_map->IsJSGlobalProxyMap());  // Proxy maps are fast.
391      DCHECK(name->IsUniqueName());
392      DCHECK(current.is_null() ||
393             current->property_dictionary()->FindEntry(name) ==
394                 NameDictionary::kNotFound);
395
396      if (depth > 1) {
397        Handle<WeakCell> weak_cell =
398            Map::GetOrCreatePrototypeWeakCell(current, isolate());
399        __ LoadWeakValue(reg, weak_cell, miss);
400      }
401      GenerateDictionaryNegativeLookup(masm(), miss, reg, name, scratch1,
402                                       scratch2);
403    }
404
405    reg = holder_reg;  // From now on the object will be in holder_reg.
406    // Go to the next object in the prototype chain.
407    current = handle(JSObject::cast(current_map->prototype()));
408    current_map = handle(current->map());
409  }
410
411  DCHECK(!current_map->IsJSGlobalProxyMap());
412
413  // Log the check depth.
414  LOG(isolate(), IntEvent("check-maps-depth", depth + 1));
415
416  bool return_holder = return_what == RETURN_HOLDER;
417  if (return_holder && depth != 0) {
418    Handle<WeakCell> weak_cell =
419        Map::GetOrCreatePrototypeWeakCell(current, isolate());
420    __ LoadWeakValue(reg, weak_cell, miss);
421  }
422
423  // Return the register containing the holder.
424  return return_holder ? reg : no_reg;
425}
426
427
428void NamedLoadHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
429  if (!miss->is_unused()) {
430    Label success;
431    __ b(&success);
432    __ bind(miss);
433    if (IC::ICUseVector(kind())) {
434      DCHECK(kind() == Code::LOAD_IC);
435      PopVectorAndSlot();
436    }
437    TailCallBuiltin(masm(), MissBuiltin(kind()));
438    __ bind(&success);
439  }
440}
441
442
443void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
444  if (!miss->is_unused()) {
445    Label success;
446    __ b(&success);
447    GenerateRestoreName(miss, name);
448    if (IC::ICUseVector(kind())) PopVectorAndSlot();
449    TailCallBuiltin(masm(), MissBuiltin(kind()));
450    __ bind(&success);
451  }
452}
453
454void NamedLoadHandlerCompiler::GenerateLoadInterceptorWithFollowup(
455    LookupIterator* it, Register holder_reg) {
456  DCHECK(holder()->HasNamedInterceptor());
457  DCHECK(!holder()->GetNamedInterceptor()->getter()->IsUndefined(isolate()));
458
459  // Compile the interceptor call, followed by inline code to load the
460  // property from further up the prototype chain if the call fails.
461  // Check that the maps haven't changed.
462  DCHECK(holder_reg.is(receiver()) || holder_reg.is(scratch1()));
463
464  // Preserve the receiver register explicitly whenever it is different from the
465  // holder and it is needed should the interceptor return without any result.
466  // The ACCESSOR case needs the receiver to be passed into C++ code, the FIELD
467  // case might cause a miss during the prototype check.
468  bool must_perform_prototype_check =
469      !holder().is_identical_to(it->GetHolder<JSObject>());
470  bool must_preserve_receiver_reg =
471      !receiver().is(holder_reg) &&
472      (it->state() == LookupIterator::ACCESSOR || must_perform_prototype_check);
473
474  // Save necessary data before invoking an interceptor.
475  // Requires a frame to make GC aware of pushed pointers.
476  {
477    FrameAndConstantPoolScope frame_scope(masm(), StackFrame::INTERNAL);
478    if (must_preserve_receiver_reg) {
479      __ Push(receiver(), holder_reg, this->name());
480    } else {
481      __ Push(holder_reg, this->name());
482    }
483    InterceptorVectorSlotPush(holder_reg);
484    // Invoke an interceptor.  Note: map checks from receiver to
485    // interceptor's holder has been compiled before (see a caller
486    // of this method.)
487    CompileCallLoadPropertyWithInterceptor(
488        masm(), receiver(), holder_reg, this->name(), holder(),
489        Runtime::kLoadPropertyWithInterceptorOnly);
490
491    // Check if interceptor provided a value for property.  If it's
492    // the case, return immediately.
493    Label interceptor_failed;
494    __ LoadRoot(scratch1(), Heap::kNoInterceptorResultSentinelRootIndex);
495    __ cmp(r0, scratch1());
496    __ b(eq, &interceptor_failed);
497    frame_scope.GenerateLeaveFrame();
498    __ Ret();
499
500    __ bind(&interceptor_failed);
501    InterceptorVectorSlotPop(holder_reg);
502    __ pop(this->name());
503    __ pop(holder_reg);
504    if (must_preserve_receiver_reg) {
505      __ pop(receiver());
506    }
507    // Leave the internal frame.
508  }
509
510  GenerateLoadPostInterceptor(it, holder_reg);
511}
512
513
514void NamedLoadHandlerCompiler::GenerateLoadInterceptor(Register holder_reg) {
515  // Call the runtime system to load the interceptor.
516  DCHECK(holder()->HasNamedInterceptor());
517  DCHECK(!holder()->GetNamedInterceptor()->getter()->IsUndefined(isolate()));
518
519  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0);
520  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 1);
521  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 2);
522  STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 3);
523  __ Push(name(), receiver(), holder_reg);
524  // See NamedLoadHandlerCompiler::InterceptorVectorSlotPop() for details.
525  if (holder_reg.is(receiver())) {
526    __ Push(slot(), vector());
527  } else {
528    __ Push(scratch3(), scratch2());  // slot, vector
529  }
530
531  __ TailCallRuntime(Runtime::kLoadPropertyWithInterceptor);
532}
533
534void NamedStoreHandlerCompiler::ZapStackArgumentsRegisterAliases() {
535  STATIC_ASSERT(!StoreWithVectorDescriptor::kPassLastArgsOnStack);
536}
537
538Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
539    Handle<JSObject> object, Handle<Name> name, Handle<AccessorInfo> callback,
540    LanguageMode language_mode) {
541  Register holder_reg = Frontend(name);
542
543  __ push(receiver());  // receiver
544  __ push(holder_reg);
545
546  // If the callback cannot leak, then push the callback directly,
547  // otherwise wrap it in a weak cell.
548  if (callback->data()->IsUndefined(isolate()) || callback->data()->IsSmi()) {
549    __ mov(ip, Operand(callback));
550  } else {
551    Handle<WeakCell> cell = isolate()->factory()->NewWeakCell(callback);
552    __ mov(ip, Operand(cell));
553  }
554  __ push(ip);
555  __ mov(ip, Operand(name));
556  __ Push(ip, value());
557  __ Push(Smi::FromInt(language_mode));
558
559  // Do tail-call to the runtime system.
560  __ TailCallRuntime(Runtime::kStoreCallbackProperty);
561
562  // Return the generated code.
563  return GetCode(kind(), name);
564}
565
566
567Register NamedStoreHandlerCompiler::value() {
568  return StoreDescriptor::ValueRegister();
569}
570
571
572Handle<Code> NamedLoadHandlerCompiler::CompileLoadGlobal(
573    Handle<PropertyCell> cell, Handle<Name> name, bool is_configurable) {
574  Label miss;
575  if (IC::ICUseVector(kind())) {
576    PushVectorAndSlot();
577  }
578  FrontendHeader(receiver(), name, &miss, DONT_RETURN_ANYTHING);
579
580  // Get the value from the cell.
581  Register result = StoreDescriptor::ValueRegister();
582  Handle<WeakCell> weak_cell = factory()->NewWeakCell(cell);
583  __ LoadWeakValue(result, weak_cell, &miss);
584  __ ldr(result, FieldMemOperand(result, PropertyCell::kValueOffset));
585
586  // Check for deleted property if property can actually be deleted.
587  if (is_configurable) {
588    __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
589    __ cmp(result, ip);
590    __ b(eq, &miss);
591  }
592
593  Counters* counters = isolate()->counters();
594  __ IncrementCounter(counters->ic_named_load_global_stub(), 1, r1, r3);
595  if (IC::ICUseVector(kind())) {
596    DiscardVectorAndSlot();
597  }
598  __ Ret();
599
600  FrontendFooter(name, &miss);
601
602  // Return the generated code.
603  return GetCode(kind(), name);
604}
605
606
607#undef __
608}  // namespace internal
609}  // namespace v8
610
611#endif  // V8_TARGET_ARCH_ARM
612