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