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_MIPS 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 uint32_t key_off_addr = reinterpret_cast<uint32_t>(key_offset.address()); 29 uint32_t value_off_addr = reinterpret_cast<uint32_t>(value_offset.address()); 30 uint32_t map_off_addr = reinterpret_cast<uint32_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 __ sll(offset_scratch, offset, 1); 46 __ Addu(offset_scratch, offset_scratch, offset); 47 48 // Calculate the base address of the entry. 49 __ li(base_addr, Operand(key_offset)); 50 __ sll(at, offset_scratch, kPointerSizeLog2); 51 __ Addu(base_addr, base_addr, at); 52 53 // Check that the key in the entry matches the name. 54 __ lw(at, MemOperand(base_addr, 0)); 55 __ Branch(&miss, ne, name, Operand(at)); 56 57 // Check the map matches. 58 __ lw(at, MemOperand(base_addr, map_off_addr - key_off_addr)); 59 __ lw(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 __ lw(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 __ Addu(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 104 // Make sure the flags does not name a specific type. 105 DCHECK(Code::ExtractTypeFromFlags(flags) == 0); 106 107 // Make sure that there are no register conflicts. 108 DCHECK(!scratch.is(receiver)); 109 DCHECK(!scratch.is(name)); 110 DCHECK(!extra.is(receiver)); 111 DCHECK(!extra.is(name)); 112 DCHECK(!extra.is(scratch)); 113 DCHECK(!extra2.is(receiver)); 114 DCHECK(!extra2.is(name)); 115 DCHECK(!extra2.is(scratch)); 116 DCHECK(!extra2.is(extra)); 117 118 // Check register validity. 119 DCHECK(!scratch.is(no_reg)); 120 DCHECK(!extra.is(no_reg)); 121 DCHECK(!extra2.is(no_reg)); 122 DCHECK(!extra3.is(no_reg)); 123 124 Counters* counters = masm->isolate()->counters(); 125 __ IncrementCounter(counters->megamorphic_stub_cache_probes(), 1, extra2, 126 extra3); 127 128 // Check that the receiver isn't a smi. 129 __ JumpIfSmi(receiver, &miss); 130 131 // Get the map of the receiver and compute the hash. 132 __ lw(scratch, FieldMemOperand(name, Name::kHashFieldOffset)); 133 __ lw(at, FieldMemOperand(receiver, HeapObject::kMapOffset)); 134 __ Addu(scratch, scratch, at); 135 uint32_t mask = kPrimaryTableSize - 1; 136 // We shift out the last two bits because they are not part of the hash and 137 // they are always 01 for maps. 138 __ srl(scratch, scratch, kCacheIndexShift); 139 __ Xor(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask)); 140 __ And(scratch, scratch, Operand(mask)); 141 142 // Probe the primary table. 143 ProbeTable(isolate, masm, flags, leave_frame, kPrimary, receiver, name, 144 scratch, extra, extra2, extra3); 145 146 // Primary miss: Compute hash for secondary probe. 147 __ srl(at, name, kCacheIndexShift); 148 __ Subu(scratch, scratch, at); 149 uint32_t mask2 = kSecondaryTableSize - 1; 150 __ Addu(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask2)); 151 __ And(scratch, scratch, Operand(mask2)); 152 153 // Probe the secondary table. 154 ProbeTable(isolate, masm, flags, leave_frame, kSecondary, receiver, name, 155 scratch, extra, extra2, extra3); 156 157 // Cache miss: Fall-through and let caller handle the miss by 158 // entering the runtime system. 159 __ bind(&miss); 160 __ IncrementCounter(counters->megamorphic_stub_cache_misses(), 1, extra2, 161 extra3); 162 } 163 164 165 #undef __ 166 } 167 } // namespace v8::internal 168 169 #endif // V8_TARGET_ARCH_MIPS 170