src/v8/src/ic/mips/stub-cache-mips.cc

   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