1// Copyright 2012 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_MIPS64
6
7#include "src/codegen.h"
8#include "src/ic/ic.h"
9#include "src/ic/stub-cache.h"
10#include "src/interface-descriptors.h"
11
12namespace v8 {
13namespace internal {
14
15#define __ ACCESS_MASM(masm)
16
17static void ProbeTable(Isolate* isolate, MacroAssembler* masm,
18                       Code::Flags flags, StubCache::Table table,
19                       Register receiver, Register name,
20                       // Number of the cache entry, not scaled.
21                       Register offset, Register scratch, Register scratch2,
22                       Register offset_scratch) {
23  ExternalReference key_offset(isolate->stub_cache()->key_reference(table));
24  ExternalReference value_offset(isolate->stub_cache()->value_reference(table));
25  ExternalReference map_offset(isolate->stub_cache()->map_reference(table));
26
27  uint64_t key_off_addr = reinterpret_cast<uint64_t>(key_offset.address());
28  uint64_t value_off_addr = reinterpret_cast<uint64_t>(value_offset.address());
29  uint64_t map_off_addr = reinterpret_cast<uint64_t>(map_offset.address());
30
31  // Check the relative positions of the address fields.
32  DCHECK(value_off_addr > key_off_addr);
33  DCHECK((value_off_addr - key_off_addr) % 4 == 0);
34  DCHECK((value_off_addr - key_off_addr) < (256 * 4));
35  DCHECK(map_off_addr > key_off_addr);
36  DCHECK((map_off_addr - key_off_addr) % 4 == 0);
37  DCHECK((map_off_addr - key_off_addr) < (256 * 4));
38
39  Label miss;
40  Register base_addr = scratch;
41  scratch = no_reg;
42
43  // Multiply by 3 because there are 3 fields per entry (name, code, map).
44  __ Dlsa(offset_scratch, offset, offset, 1);
45
46  // Calculate the base address of the entry.
47  __ li(base_addr, Operand(key_offset));
48  __ Dlsa(base_addr, base_addr, offset_scratch, kPointerSizeLog2);
49
50  // Check that the key in the entry matches the name.
51  __ ld(at, MemOperand(base_addr, 0));
52  __ Branch(&miss, ne, name, Operand(at));
53
54  // Check the map matches.
55  __ ld(at, MemOperand(base_addr,
56                       static_cast<int32_t>(map_off_addr - key_off_addr)));
57  __ ld(scratch2, FieldMemOperand(receiver, HeapObject::kMapOffset));
58  __ Branch(&miss, ne, at, Operand(scratch2));
59
60  // Get the code entry from the cache.
61  Register code = scratch2;
62  scratch2 = no_reg;
63  __ ld(code, MemOperand(base_addr,
64                         static_cast<int32_t>(value_off_addr - key_off_addr)));
65
66  // Check that the flags match what we're looking for.
67  Register flags_reg = base_addr;
68  base_addr = no_reg;
69  __ lw(flags_reg, FieldMemOperand(code, Code::kFlagsOffset));
70  __ And(flags_reg, flags_reg, Operand(~Code::kFlagsNotUsedInLookup));
71  __ Branch(&miss, ne, flags_reg, Operand(flags));
72
73#ifdef DEBUG
74  if (FLAG_test_secondary_stub_cache && table == StubCache::kPrimary) {
75    __ jmp(&miss);
76  } else if (FLAG_test_primary_stub_cache && table == StubCache::kSecondary) {
77    __ jmp(&miss);
78  }
79#endif
80
81  // Jump to the first instruction in the code stub.
82  __ Daddu(at, code, Operand(Code::kHeaderSize - kHeapObjectTag));
83  __ Jump(at);
84
85  // Miss: fall through.
86  __ bind(&miss);
87}
88
89
90void StubCache::GenerateProbe(MacroAssembler* masm, Code::Kind ic_kind,
91                              Code::Flags flags, Register receiver,
92                              Register name, Register scratch, Register extra,
93                              Register extra2, Register extra3) {
94  Isolate* isolate = masm->isolate();
95  Label miss;
96
97  // Make sure that code is valid. The multiplying code relies on the
98  // entry size being 12.
99  // DCHECK(sizeof(Entry) == 12);
100  // DCHECK(sizeof(Entry) == 3 * kPointerSize);
101
102  // Make sure that there are no register conflicts.
103  DCHECK(!AreAliased(receiver, name, scratch, extra, extra2, extra3));
104
105  // Check register validity.
106  DCHECK(!scratch.is(no_reg));
107  DCHECK(!extra.is(no_reg));
108  DCHECK(!extra2.is(no_reg));
109  DCHECK(!extra3.is(no_reg));
110
111#ifdef DEBUG
112  // If vector-based ics are in use, ensure that scratch, extra, extra2 and
113  // extra3 don't conflict with the vector and slot registers, which need
114  // to be preserved for a handler call or miss.
115  if (IC::ICUseVector(ic_kind)) {
116    Register vector, slot;
117    if (ic_kind == Code::STORE_IC || ic_kind == Code::KEYED_STORE_IC) {
118      vector = VectorStoreICDescriptor::VectorRegister();
119      slot = VectorStoreICDescriptor::SlotRegister();
120    } else {
121      vector = LoadWithVectorDescriptor::VectorRegister();
122      slot = LoadWithVectorDescriptor::SlotRegister();
123    }
124    DCHECK(!AreAliased(vector, slot, scratch, extra, extra2, extra3));
125  }
126#endif
127
128  Counters* counters = masm->isolate()->counters();
129  __ IncrementCounter(counters->megamorphic_stub_cache_probes(), 1, extra2,
130                      extra3);
131
132  // Check that the receiver isn't a smi.
133  __ JumpIfSmi(receiver, &miss);
134
135  // Get the map of the receiver and compute the hash.
136  __ ld(scratch, FieldMemOperand(name, Name::kHashFieldOffset));
137  __ ld(at, FieldMemOperand(receiver, HeapObject::kMapOffset));
138  __ Daddu(scratch, scratch, at);
139  uint64_t mask = kPrimaryTableSize - 1;
140  // We shift out the last two bits because they are not part of the hash and
141  // they are always 01 for maps.
142  __ dsrl(scratch, scratch, kCacheIndexShift);
143  __ Xor(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask));
144  __ And(scratch, scratch, Operand(mask));
145
146  // Probe the primary table.
147  ProbeTable(isolate, masm, flags, kPrimary, receiver, name, scratch, extra,
148             extra2, extra3);
149
150  // Primary miss: Compute hash for secondary probe.
151  __ dsrl(at, name, kCacheIndexShift);
152  __ Dsubu(scratch, scratch, at);
153  uint64_t mask2 = kSecondaryTableSize - 1;
154  __ Daddu(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask2));
155  __ And(scratch, scratch, Operand(mask2));
156
157  // Probe the secondary table.
158  ProbeTable(isolate, masm, flags, kSecondary, receiver, name, scratch, extra,
159             extra2, extra3);
160
161  // Cache miss: Fall-through and let caller handle the miss by
162  // entering the runtime system.
163  __ bind(&miss);
164  __ IncrementCounter(counters->megamorphic_stub_cache_misses(), 1, extra2,
165                      extra3);
166}
167
168
169#undef __
170}  // namespace internal
171}  // namespace v8
172
173#endif  // V8_TARGET_ARCH_MIPS64
174