src/ppc/stub-cache-ppc.cc - Issue 422063005: Contribution of PowerPC port.

Unified Diff: src/ppc/stub-cache-ppc.cc

Issue 422063005: Contribution of PowerPC port. (Closed) Base URL: http://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Caught up to bleending edge (8/15) Created 6 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/ppc/stub-cache-ppc.cc

diff --git a/src/arm/stub-cache-arm.cc b/src/ppc/stub-cache-ppc.cc

similarity index 84%

copy from src/arm/stub-cache-arm.cc

copy to src/ppc/stub-cache-ppc.cc

index 38f391a33642270d23605b40872b77c7fc2acff7..12a5d22953ee1836b03f36f69d015770d33a0c57 100644

--- a/src/arm/stub-cache-arm.cc

+++ b/src/ppc/stub-cache-ppc.cc

@@ -1,10 +1,13 @@

+//

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#include "src/v8.h"

-#if V8_TARGET_ARCH_ARM

+#if V8_TARGET_ARCH_PPC

#include "src/codegen.h"

#include "src/ic-inl.h"

@@ -31,9 +34,10 @@ static void ProbeTable(Isolate* isolate,

ExternalReference value_offset(isolate->stub_cache()->value_reference(table));

ExternalReference map_offset(isolate->stub_cache()->map_reference(table));

- uint32_t key_off_addr = reinterpret_cast<uint32_t>(key_offset.address());

- uint32_t value_off_addr = reinterpret_cast<uint32_t>(value_offset.address());

- uint32_t map_off_addr = reinterpret_cast<uint32_t>(map_offset.address());

+ uintptr_t key_off_addr = reinterpret_cast<uintptr_t>(key_offset.address());

+ uintptr_t value_off_addr =

+ reinterpret_cast<uintptr_t>(value_offset.address());

+ uintptr_t map_off_addr = reinterpret_cast<uintptr_t>(map_offset.address());

// Check the relative positions of the address fields.

DCHECK(value_off_addr > key_off_addr);

@@ -48,50 +52,54 @@ static void ProbeTable(Isolate* isolate,

scratch = no_reg;

// Multiply by 3 because there are 3 fields per entry (name, code, map).

- __ add(offset_scratch, offset, Operand(offset, LSL, 1));

+ __ ShiftLeftImm(offset_scratch, offset, Operand(1));

+ __ add(offset_scratch, offset, offset_scratch);

// Calculate the base address of the entry.

__ mov(base_addr, Operand(key_offset));

- __ add(base_addr, base_addr, Operand(offset_scratch, LSL, kPointerSizeLog2));

+ __ ShiftLeftImm(scratch2, offset_scratch, Operand(kPointerSizeLog2));

+ __ add(base_addr, base_addr, scratch2);

// Check that the key in the entry matches the name.

- __ ldr(ip, MemOperand(base_addr, 0));

+ __ LoadP(ip, MemOperand(base_addr, 0));

__ cmp(name, ip);

- __ b(ne, &miss);

+ __ bne(&miss);

// Check the map matches.

- __ ldr(ip, MemOperand(base_addr, map_off_addr - key_off_addr));

- __ ldr(scratch2, FieldMemOperand(receiver, HeapObject::kMapOffset));

+ __ LoadP(ip, MemOperand(base_addr, map_off_addr - key_off_addr));

+ __ LoadP(scratch2, FieldMemOperand(receiver, HeapObject::kMapOffset));

__ cmp(ip, scratch2);

- __ b(ne, &miss);

+ __ bne(&miss);

// Get the code entry from the cache.

scratch2 = no_reg;

- __ ldr(code, MemOperand(base_addr, value_off_addr - key_off_addr));

+ __ LoadP(code, MemOperand(base_addr, value_off_addr - key_off_addr));

// Check that the flags match what we're looking for.

base_addr = no_reg;

- __ ldr(flags_reg, FieldMemOperand(code, Code::kFlagsOffset));

- // It's a nice optimization if this constant is encodable in the bic insn.

+ __ lwz(flags_reg, FieldMemOperand(code, Code::kFlagsOffset));

- uint32_t mask = Code::kFlagsNotUsedInLookup;

- DCHECK(__ ImmediateFitsAddrMode1Instruction(mask));

- __ bic(flags_reg, flags_reg, Operand(mask));

- __ cmp(flags_reg, Operand(flags));

- __ b(ne, &miss);

+ DCHECK(!r0.is(flags_reg));

+ __ li(r0, Operand(Code::kFlagsNotUsedInLookup));

+ __ andc(flags_reg, flags_reg, r0);

+ __ mov(r0, Operand(flags));

+ __ cmpl(flags_reg, r0);

+ __ bne(&miss);

#ifdef DEBUG

if (FLAG_test_secondary_stub_cache && table == StubCache::kPrimary) {

- __ jmp(&miss);

+ __ b(&miss);

} else if (FLAG_test_primary_stub_cache && table == StubCache::kSecondary) {

- __ jmp(&miss);

+ __ b(&miss);

}

#endif

// Jump to the first instruction in the code stub.

- __ add(pc, code, Operand(Code::kHeaderSize - kHeapObjectTag));

+ __ addi(r0, code, Operand(Code::kHeaderSize - kHeapObjectTag));

+ __ mtctr(r0);

+ __ bctr();

// Miss: fall through.

__ bind(&miss);

@@ -114,28 +122,28 @@ void PropertyHandlerCompiler::GenerateDictionaryNegativeLookup(

// Bail out if the receiver has a named interceptor or requires access checks.

- __ ldr(map, FieldMemOperand(receiver, HeapObject::kMapOffset));

- __ ldrb(scratch0, FieldMemOperand(map, Map::kBitFieldOffset));

- __ tst(scratch0, Operand(kInterceptorOrAccessCheckNeededMask));

- __ b(ne, miss_label);

+ __ LoadP(map, FieldMemOperand(receiver, HeapObject::kMapOffset));

+ __ lbz(scratch0, FieldMemOperand(map, Map::kBitFieldOffset));

+ __ andi(r0, scratch0, Operand(kInterceptorOrAccessCheckNeededMask));

+ __ bne(miss_label, cr0);

// Check that receiver is a JSObject.

- __ ldrb(scratch0, FieldMemOperand(map, Map::kInstanceTypeOffset));

- __ cmp(scratch0, Operand(FIRST_SPEC_OBJECT_TYPE));

- __ b(lt, miss_label);

+ __ lbz(scratch0, FieldMemOperand(map, Map::kInstanceTypeOffset));

+ __ cmpi(scratch0, Operand(FIRST_SPEC_OBJECT_TYPE));

+ __ blt(miss_label);

// Load properties array.

- __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

+ __ LoadP(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

// Check that the properties array is a dictionary.

- __ ldr(map, FieldMemOperand(properties, HeapObject::kMapOffset));

+ __ LoadP(map, FieldMemOperand(properties, HeapObject::kMapOffset));

__ LoadRoot(tmp, Heap::kHashTableMapRootIndex);

__ cmp(map, tmp);

- __ b(ne, miss_label);

+ __ bne(miss_label);

// Restore the temporarily used register.

- __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

+ __ LoadP(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

NameDictionaryLookupStub::GenerateNegativeLookup(masm,

@@ -161,9 +169,15 @@ void StubCache::GenerateProbe(MacroAssembler* masm,

Isolate* isolate = masm->isolate();

Label miss;

+#if V8_TARGET_ARCH_PPC64

+ // Make sure that code is valid. The multiplying code relies on the

+ // entry size being 24.

+ DCHECK(sizeof(Entry) == 24);

+#else

// Make sure that code is valid. The multiplying code relies on the

// entry size being 12.

DCHECK(sizeof(Entry) == 12);

+#endif

// Make sure the flags does not name a specific type.

DCHECK(Code::ExtractTypeFromFlags(flags) == 0);

@@ -193,18 +207,22 @@ void StubCache::GenerateProbe(MacroAssembler* masm,

__ JumpIfSmi(receiver, &miss);

// Get the map of the receiver and compute the hash.

- __ ldr(scratch, FieldMemOperand(name, Name::kHashFieldOffset));

- __ ldr(ip, FieldMemOperand(receiver, HeapObject::kMapOffset));

- __ add(scratch, scratch, Operand(ip));

+ __ lwz(scratch, FieldMemOperand(name, Name::kHashFieldOffset));

+ __ LoadP(ip, FieldMemOperand(receiver, HeapObject::kMapOffset));

+ __ add(scratch, scratch, ip);

+#if V8_TARGET_ARCH_PPC64

+ // Use only the low 32 bits of the map pointer.

+ __ rldicl(scratch, scratch, 0, 32);

+#endif

uint32_t mask = kPrimaryTableSize - 1;

// We shift out the last two bits because they are not part of the hash and

// they are always 01 for maps.

- __ mov(scratch, Operand(scratch, LSR, kCacheIndexShift));

+ __ ShiftRightImm(scratch, scratch, Operand(kCacheIndexShift));

// Mask down the eor argument to the minimum to keep the immediate

- // ARM-encodable.

- __ eor(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask));

+ // encodable.

+ __ xori(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask));

// Prefer and_ to ubfx here because ubfx takes 2 cycles.

- __ and_(scratch, scratch, Operand(mask));

+ __ andi(scratch, scratch, Operand(mask));

// Probe the primary table.

ProbeTable(isolate,

@@ -219,10 +237,11 @@ void StubCache::GenerateProbe(MacroAssembler* masm,

extra3);

// Primary miss: Compute hash for secondary probe.

- __ sub(scratch, scratch, Operand(name, LSR, kCacheIndexShift));

+ __ ShiftRightImm(extra, name, Operand(kCacheIndexShift));

+ __ sub(scratch, scratch, extra);

uint32_t mask2 = kSecondaryTableSize - 1;

- __ add(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask2));

- __ and_(scratch, scratch, Operand(mask2));

+ __ addi(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask2));

+ __ andi(scratch, scratch, Operand(mask2));

// Probe the secondary table.

ProbeTable(isolate,

@@ -254,17 +273,18 @@ void NamedLoadHandlerCompiler::GenerateDirectLoadGlobalFunctionPrototype(

// Check we're still in the same context.

const int offset = Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX);

- __ ldr(scratch, MemOperand(cp, offset));

- __ ldr(scratch, FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));

- __ ldr(scratch, MemOperand(scratch, Context::SlotOffset(index)));

+ __ LoadP(scratch, MemOperand(cp, offset));

+ __ LoadP(scratch, FieldMemOperand(scratch,

+ GlobalObject::kNativeContextOffset));

+ __ LoadP(scratch, MemOperand(scratch, Context::SlotOffset(index)));

__ Move(ip, function);

__ cmp(ip, scratch);

- __ b(ne, miss);

+ __ bne(miss);

// Load its initial map. The global functions all have initial maps.

__ Move(prototype, Handle<Map>(function->initial_map()));

// Load the prototype from the initial map.

- __ ldr(prototype, FieldMemOperand(prototype, Map::kPrototypeOffset));

+ __ LoadP(prototype, FieldMemOperand(prototype, Map::kPrototypeOffset));

}

@@ -272,7 +292,7 @@ void NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(

MacroAssembler* masm, Register receiver, Register scratch1,

__ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);

- __ mov(r0, scratch1);

+ __ mr(r3, scratch1);

__ Ret();

}

@@ -286,10 +306,10 @@ void PropertyHandlerCompiler::GenerateCheckPropertyCell(

Handle<Cell> cell = JSGlobalObject::EnsurePropertyCell(global, name);

DCHECK(cell->value()->IsTheHole());

__ mov(scratch, Operand(cell));

- __ ldr(scratch, FieldMemOperand(scratch, Cell::kValueOffset));

+ __ LoadP(scratch, FieldMemOperand(scratch, Cell::kValueOffset));

__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

__ cmp(scratch, ip);

- __ b(ne, miss);

+ __ bne(miss);

}

@@ -338,10 +358,10 @@ void PropertyHandlerCompiler::GenerateFastApiCall(

DCHECK(optimization.is_simple_api_call());

// Abi for CallApiFunctionStub.

- Register callee = r0;

- Register call_data = r4;

- Register holder = r2;

- Register api_function_address = r1;

+ Register callee = r3;

+ Register call_data = r7;

+ Register holder = r5;

+ Register api_function_address = r4;

// Put holder in place.

CallOptimization::HolderLookup holder_lookup;

@@ -371,7 +391,8 @@ void PropertyHandlerCompiler::GenerateFastApiCall(

// Put call_data in place.

if (isolate->heap()->InNewSpace(*call_data_obj)) {

__ Move(call_data, api_call_info);

- __ ldr(call_data, FieldMemOperand(call_data, CallHandlerInfo::kDataOffset));

+ __ LoadP(call_data,

+ FieldMemOperand(call_data, CallHandlerInfo::kDataOffset));

} else if (call_data_obj->IsUndefined()) {

call_data_undefined = true;

__ LoadRoot(call_data, Heap::kUndefinedValueRootIndex);

@@ -411,7 +432,7 @@ void NamedStoreHandlerCompiler::GenerateRestoreName(Label* label,

}

-// Generate StoreTransition code, value is passed in r0 register.

+// Generate StoreTransition code, value is passed in r3 register.

// When leaving generated code after success, the receiver_reg and name_reg

// may be clobbered. Upon branch to miss_label, the receiver and name

// registers have their original values.

@@ -419,7 +440,7 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

Handle<Map> transition, Handle<Name> name, Register receiver_reg,

- // r0 : value

+ // r3 : value

Label exit;

int descriptor = transition->LastAdded();

@@ -432,7 +453,7 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

Handle<Object> constant(descriptors->GetValue(descriptor), isolate());

__ Move(scratch1, constant);

__ cmp(value_reg, scratch1);

- __ b(ne, miss_label);

+ __ bne(miss_label);

} else if (representation.IsSmi()) {

__ JumpIfNotSmi(value_reg, miss_label);

} else if (representation.IsHeapObject()) {

@@ -440,16 +461,16 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

HeapType* field_type = descriptors->GetFieldType(descriptor);

HeapType::Iterator<Map> it = field_type->Classes();

if (!it.Done()) {

- __ ldr(scratch1, FieldMemOperand(value_reg, HeapObject::kMapOffset));

+ __ LoadP(scratch1, FieldMemOperand(value_reg, HeapObject::kMapOffset));

Label do_store;

while (true) {

__ CompareMap(scratch1, it.Current(), &do_store);

it.Advance();

if (it.Done()) {

- __ b(ne, miss_label);

+ __ bne(miss_label);

break;

}

- __ b(eq, &do_store);

+ __ beq(&do_store);

}

__ bind(&do_store);

}

@@ -461,17 +482,16 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

__ JumpIfNotSmi(value_reg, &heap_number);

__ SmiUntag(scratch1, value_reg);

- __ vmov(s0, scratch1);

- __ vcvt_f64_s32(d0, s0);

+ __ ConvertIntToDouble(scratch1, d0);

__ jmp(&do_store);

__ bind(&heap_number);

__ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex,

miss_label, DONT_DO_SMI_CHECK);

- __ vldr(d0, FieldMemOperand(value_reg, HeapNumber::kValueOffset));

+ __ lfd(d0, FieldMemOperand(value_reg, HeapNumber::kValueOffset));

__ bind(&do_store);

- __ vstr(d0, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));

+ __ stfd(d0, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));

}

// Stub never generated for objects that require access checks.

@@ -483,8 +503,8 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

// The properties must be extended before we can store the value.

// We jump to a runtime call that extends the properties array.

__ push(receiver_reg);

- __ mov(r2, Operand(transition));

- __ Push(r2, r0);

+ __ mov(r5, Operand(transition));

+ __ Push(r5, r3);

__ TailCallExternalReference(

ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),

isolate()),

@@ -494,7 +514,8 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

// Update the map of the object.

__ mov(scratch1, Operand(transition));

- __ str(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset));

+ __ StoreP(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset),

+ r0);

// Update the write barrier for the map field.

__ RecordWriteField(receiver_reg,

@@ -507,7 +528,7 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

OMIT_SMI_CHECK);

if (details.type() == CONSTANT) {

- DCHECK(value_reg.is(r0));

+ DCHECK(value_reg.is(r3));

__ Ret();

return;

}

@@ -527,15 +548,15 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

// Set the property straight into the object.

int offset = transition->instance_size() + (index * kPointerSize);

if (representation.IsDouble()) {

- __ str(storage_reg, FieldMemOperand(receiver_reg, offset));

+ __ StoreP(storage_reg, FieldMemOperand(receiver_reg, offset), r0);

} else {

- __ str(value_reg, FieldMemOperand(receiver_reg, offset));

+ __ StoreP(value_reg, FieldMemOperand(receiver_reg, offset), r0);

}

if (!representation.IsSmi()) {

- // Update the write barrier for the array address.

+ // Update the write barrier for the array address.

if (!representation.IsDouble()) {

- __ mov(storage_reg, value_reg);

+ __ mr(storage_reg, value_reg);

}

__ RecordWriteField(receiver_reg,

offset,

@@ -550,18 +571,18 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

// Write to the properties array.

int offset = index * kPointerSize + FixedArray::kHeaderSize;

// Get the properties array

- __ ldr(scratch1,

- FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));

+ __ LoadP(scratch1,

+ FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));

if (representation.IsDouble()) {

- __ str(storage_reg, FieldMemOperand(scratch1, offset));

+ __ StoreP(storage_reg, FieldMemOperand(scratch1, offset), r0);

} else {

- __ str(value_reg, FieldMemOperand(scratch1, offset));

+ __ StoreP(value_reg, FieldMemOperand(scratch1, offset), r0);

}

if (!representation.IsSmi()) {

// Update the write barrier for the array address.

if (!representation.IsDouble()) {

- __ mov(storage_reg, value_reg);

+ __ mr(storage_reg, value_reg);

}

__ RecordWriteField(scratch1,

offset,

@@ -574,8 +595,8 @@ void NamedStoreHandlerCompiler::GenerateStoreTransition(

}

- // Return the value (register r0).

- DCHECK(value_reg.is(r0));

+ // Return the value (register r3).

+ DCHECK(value_reg.is(r3));

__ bind(&exit);

__ Ret();

}

@@ -587,16 +608,16 @@ void NamedStoreHandlerCompiler::GenerateStoreField(LookupResult* lookup,

DCHECK(lookup->representation().IsHeapObject());

__ JumpIfSmi(value_reg, miss_label);

HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();

- __ ldr(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));

+ __ LoadP(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));

Label do_store;

while (true) {

__ CompareMap(scratch1(), it.Current(), &do_store);

it.Advance();

if (it.Done()) {

- __ b(ne, miss_label);

+ __ bne(miss_label);

break;

}

- __ b(eq, &do_store);

+ __ beq(&do_store);

}

__ bind(&do_store);

@@ -641,7 +662,7 @@ Register PropertyHandlerCompiler::CheckPrototypes(

prototype = handle(JSObject::cast(current_map->prototype()));

if (current_map->is_dictionary_map() &&

!current_map->IsJSGlobalObjectMap()) {

- DCHECK(!current_map->IsJSGlobalProxyMap()); // Proxy maps are fast.

+ DCHECK(!current_map->IsJSGlobalProxyMap()); // Proxy maps are fast.

if (!name->IsUniqueName()) {

DCHECK(name->IsString());

name = factory()->InternalizeString(Handle<String>::cast(name));

@@ -653,16 +674,16 @@ Register PropertyHandlerCompiler::CheckPrototypes(

GenerateDictionaryNegativeLookup(masm(), miss, reg, name,

scratch1, scratch2);

- __ ldr(scratch1, FieldMemOperand(reg, HeapObject::kMapOffset));

+ __ LoadP(scratch1, FieldMemOperand(reg, HeapObject::kMapOffset));

reg = holder_reg; // From now on the object will be in holder_reg.

- __ ldr(reg, FieldMemOperand(scratch1, Map::kPrototypeOffset));

+ __ LoadP(reg, FieldMemOperand(scratch1, Map::kPrototypeOffset));

} else {

if (depth != 1 || check == CHECK_ALL_MAPS) {

// CheckMap implicitly loads the map of |reg| into |map_reg|.

__ CheckMap(reg, map_reg, current_map, miss, DONT_DO_SMI_CHECK);

} else {

- __ ldr(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));

+ __ LoadP(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));

}

// Check access rights to the global object. This has to happen after

@@ -688,7 +709,7 @@ Register PropertyHandlerCompiler::CheckPrototypes(

bool load_prototype_from_map =

heap()->InNewSpace(*prototype) || depth == 1;

if (load_prototype_from_map) {

- __ ldr(reg, FieldMemOperand(map_reg, Map::kPrototypeOffset));

+ __ LoadP(reg, FieldMemOperand(map_reg, Map::kPrototypeOffset));

} else {

__ mov(reg, Operand(prototype));

}

@@ -743,7 +764,7 @@ void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {

void NamedLoadHandlerCompiler::GenerateLoadConstant(Handle<Object> value) {

// Return the constant value.

- __ Move(r0, value);

+ __ Move(r3, value);

__ Ret();

}

@@ -765,23 +786,22 @@ void NamedLoadHandlerCompiler::GenerateLoadCallback(

__ push(receiver());

if (heap()->InNewSpace(callback->data())) {

__ Move(scratch3(), callback);

- __ ldr(scratch3(), FieldMemOperand(scratch3(),

+ __ LoadP(scratch3(), FieldMemOperand(scratch3(),

ExecutableAccessorInfo::kDataOffset));

} else {

__ Move(scratch3(), Handle<Object>(callback->data(), isolate()));

}

__ push(scratch3());

__ LoadRoot(scratch3(), Heap::kUndefinedValueRootIndex);

- __ mov(scratch4(), scratch3());

+ __ mr(scratch4(), scratch3());

__ Push(scratch3(), scratch4());

__ mov(scratch4(),

Operand(ExternalReference::isolate_address(isolate())));

__ Push(scratch4(), reg);

- __ mov(scratch2(), sp); // scratch2 = PropertyAccessorInfo::args_

__ push(name());

// Abi for CallApiGetter

- Register getter_address_reg = r2;

+ Register getter_address_reg = r5;

Address getter_address = v8::ToCData<Address>(callback->getter());

ApiFunction fun(getter_address);

@@ -852,8 +872,8 @@ void NamedLoadHandlerCompiler::GenerateLoadInterceptor(Register holder_reg,

// the case, return immediately.

Label interceptor_failed;

__ LoadRoot(scratch1(), Heap::kNoInterceptorResultSentinelRootIndex);

- __ cmp(r0, scratch1());

- __ b(eq, &interceptor_failed);

+ __ cmp(r3, scratch1());

+ __ beq(&interceptor_failed);

frame_scope.GenerateLeaveFrame();

__ Ret();

@@ -887,8 +907,7 @@ Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(

Handle<ExecutableAccessorInfo> callback) {

- __ push(receiver()); // receiver

- __ push(holder_reg);

+ __ Push(receiver(), holder_reg); // receiver

__ mov(ip, Operand(callback)); // callback info

__ push(ip);

__ mov(ip, Operand(name));

@@ -924,8 +943,8 @@ void NamedStoreHandlerCompiler::GenerateStoreViaSetter(

// Call the JavaScript setter with receiver and value on the stack.

if (IC::TypeToMap(*type, masm->isolate())->IsJSGlobalObjectMap()) {

// Swap in the global receiver.

- __ ldr(receiver,

- FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));

+ __ LoadP(receiver,

+ FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));

}

__ Push(receiver, value());

ParameterCount actual(1);

@@ -939,10 +958,10 @@ void NamedStoreHandlerCompiler::GenerateStoreViaSetter(

}

// We have to return the passed value, not the return value of the setter.

- __ pop(r0);

+ __ pop(r3);

// Restore context register.

- __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));

+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));

}

__ Ret();

}

@@ -970,7 +989,7 @@ Register* PropertyAccessCompiler::load_calling_convention() {

// receiver, name, scratch1, scratch2, scratch3, scratch4.

- static Register registers[] = { receiver, name, r3, r0, r4, r5 };

+ static Register registers[] = { receiver, name, r6, r3, r7, r8 };

return registers;

}

@@ -979,8 +998,8 @@ Register* PropertyAccessCompiler::store_calling_convention() {

// receiver, name, scratch1, scratch2, scratch3.

- DCHECK(r3.is(KeyedStoreIC::MapRegister()));

- static Register registers[] = { receiver, name, r3, r4, r5 };

+ DCHECK(r6.is(KeyedStoreIC::MapRegister()));

+ static Register registers[] = { receiver, name, r6, r7, r8 };

return registers;

}

@@ -996,8 +1015,8 @@ void NamedLoadHandlerCompiler::GenerateLoadViaGetter(

MacroAssembler* masm, Handle<HeapType> type, Register receiver,

Handle<JSFunction> getter) {

// ----------- S t a t e -------------

- // -- r0 : receiver

- // -- r2 : name

+ // -- r3 : receiver

+ // -- r5 : name

// -- lr : return address

// -----------------------------------

{

@@ -1007,8 +1026,8 @@ void NamedLoadHandlerCompiler::GenerateLoadViaGetter(

// Call the JavaScript getter with the receiver on the stack.

if (IC::TypeToMap(*type, masm->isolate())->IsJSGlobalObjectMap()) {

// Swap in the global receiver.

- __ ldr(receiver,

- FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));

+ __ LoadP(receiver,

+ FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));

}

__ push(receiver);

ParameterCount actual(0);

@@ -1022,7 +1041,7 @@ void NamedLoadHandlerCompiler::GenerateLoadViaGetter(

}

// Restore context register.

- __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));

+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));

}

__ Ret();

}

@@ -1040,17 +1059,17 @@ Handle<Code> NamedLoadHandlerCompiler::CompileLoadGlobal(

// Get the value from the cell.

__ mov(result, Operand(cell));

- __ ldr(result, FieldMemOperand(result, Cell::kValueOffset));

+ __ LoadP(result, FieldMemOperand(result, Cell::kValueOffset));

// Check for deleted property if property can actually be deleted.

- if (is_configurable) {

+ if (!is_configurable) {

__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

__ cmp(result, ip);

- __ b(eq, &miss);

+ __ beq(&miss);

}

Counters* counters = isolate()->counters();

- __ IncrementCounter(counters->named_load_global_stub(), 1, r1, r3);

+ __ IncrementCounter(counters->named_load_global_stub(), 1, r4, r6);

__ Ret();

FrontendFooter(name, &miss);

@@ -1074,8 +1093,8 @@ Handle<Code> PropertyICCompiler::CompilePolymorphic(TypeHandleList* types,

if (name.is_identical_to(isolate()->factory()->normal_ic_symbol())) {

__ JumpIfNotUniqueName(this->name(), &miss);

} else {

- __ cmp(this->name(), Operand(name));

- __ b(ne, &miss);

+ __ Cmpi(this->name(), Operand(name), r0);

+ __ bne(&miss);

}

@@ -1090,7 +1109,7 @@ Handle<Code> PropertyICCompiler::CompilePolymorphic(TypeHandleList* types,

int receiver_count = types->length();

int number_of_handled_maps = 0;

- __ ldr(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));

+ __ LoadP(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));

for (int current = 0; current < receiver_count; ++current) {

Handle<HeapType> type = types->at(current);

Handle<Map> map = IC::TypeToMap(*type, isolate());

@@ -1124,15 +1143,18 @@ Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(

__ JumpIfSmi(receiver(), &miss);

int receiver_count = receiver_maps->length();

- __ ldr(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset));

+ __ LoadP(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset));

for (int i = 0; i < receiver_count; ++i) {

__ mov(ip, Operand(receiver_maps->at(i)));

__ cmp(scratch1(), ip);

if (transitioned_maps->at(i).is_null()) {

- __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, eq);

+ Label skip;

+ __ bne(&skip);

+ __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET);

+ __ bind(&skip);

} else {

Label next_map;

- __ b(ne, &next_map);

+ __ bne(&next_map);

__ mov(transition_map(), Operand(transitioned_maps->at(i)));

__ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, al);

__ bind(&next_map);

@@ -1158,18 +1180,18 @@ void ElementHandlerCompiler::GenerateLoadDictionaryElement(

- DCHECK(receiver.is(r1));

- DCHECK(key.is(r2));

+ DCHECK(receiver.is(r4));

+ DCHECK(key.is(r5));

- __ UntagAndJumpIfNotSmi(r6, key, &miss);

- __ ldr(r4, FieldMemOperand(receiver, JSObject::kElementsOffset));

- __ LoadFromNumberDictionary(&slow, r4, key, r0, r6, r3, r5);

+ __ UntagAndJumpIfNotSmi(r9, key, &miss);

+ __ LoadP(r7, FieldMemOperand(receiver, JSObject::kElementsOffset));

+ __ LoadFromNumberDictionary(&slow, r7, key, r3, r9, r6, r8);

__ Ret();

__ bind(&slow);

__ IncrementCounter(

masm->isolate()->counters()->keyed_load_external_array_slow(),

- 1, r2, r3);

+ 1, r5, r6);

TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Slow);

@@ -1184,4 +1206,4 @@ void ElementHandlerCompiler::GenerateLoadDictionaryElement(

} } // namespace v8::internal

-#endif // V8_TARGET_ARCH_ARM

+#endif // V8_TARGET_ARCH_PPC

« src/objects-printer.cc ('K') | « src/ppc/simulator-ppc.cc ('k') | src/regexp-macro-assembler.h » ('j') | no next file with comments »