Skip to content

V
V8
Commit a3fbabc7 authored by Junliang Yan's avatar Junliang Yan Committed by Commit Bot
Browse files
Options

PPC: rename kPointerSize to kSystemPointerSize etc 

Prepare for pointer compression changes

Change-Id: I8ec56ac65194f1f89f2803af155d5bec520a569f
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2171036
Auto-Submit: Junliang Yan <jyan@ca.ibm.com>
Reviewed-by: 's avatarMilad Farazmand <miladfar@ca.ibm.com>
Commit-Queue: Junliang Yan <jyan@ca.ibm.com>
Cr-Commit-Position: refs/heads/master@{#67455}
parent abfdb819
Hide whitespace changes
Inline Side-by-side
Showing with 306 additions and 284 deletions
src/builtins/ppc/builtins-ppc.cc
View file @ a3fbabc7
......@@ -87,7 +87,7 @@ void Generate_StackOverflowCheck(MacroAssembler* masm, Register num_args,
// here which will cause scratch to become negative.
__ sub(scratch, sp, scratch);
// Check if the arguments will overflow the stack.
__ ShiftLeftImm(r0, num_args, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r0, num_args, Operand(kSystemPointerSizeLog2));
__ cmp(scratch, r0);
__ ble(stack_overflow); // Signed comparison.
}
......@@ -130,16 +130,16 @@ void Generate_JSBuiltinsConstructStubHelper(MacroAssembler* masm) {
// -- r6: new target
// -- r7: pointer to last argument
// -- cr0: condition indicating whether r3 is zero
// -- sp[0*kPointerSize]: the hole (receiver)
// -- sp[1*kPointerSize]: number of arguments (tagged)
// -- sp[2*kPointerSize]: context
// -- sp[0*kSystemPointerSize]: the hole (receiver)
// -- sp[1*kSystemPointerSize]: number of arguments (tagged)
// -- sp[2*kSystemPointerSize]: context
// -----------------------------------
__ beq(&no_args, cr0);
__ ShiftLeftImm(scratch, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(scratch, r3, Operand(kSystemPointerSizeLog2));
__ sub(sp, sp, scratch);
__ mtctr(r3);
__ bind(&loop);
__ subi(scratch, scratch, Operand(kPointerSize));
__ subi(scratch, scratch, Operand(kSystemPointerSize));
__ LoadPX(r0, MemOperand(r7, scratch));
__ StorePX(r0, MemOperand(sp, scratch));
__ bdnz(&loop);
......@@ -166,7 +166,7 @@ void Generate_JSBuiltinsConstructStubHelper(MacroAssembler* masm) {
__ SmiToPtrArrayOffset(r4, r4);
__ add(sp, sp, r4);
__ addi(sp, sp, Operand(kPointerSize));
__ addi(sp, sp, Operand(kSystemPointerSize));
__ blr();
__ bind(&stack_overflow);
......@@ -202,11 +202,11 @@ void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
__ Push(r6);
// ----------- S t a t e -------------
// -- sp[0*kPointerSize]: new target
// -- sp[1*kPointerSize]: padding
// -- r4 and sp[2*kPointerSize]: constructor function
// -- sp[3*kPointerSize]: number of arguments (tagged)
// -- sp[4*kPointerSize]: context
// -- sp[0*kSystemPointerSize]: new target
// -- sp[1*kSystemPointerSize]: padding
// -- r4 and sp[2*kSystemPointerSize]: constructor function
// -- sp[3*kSystemPointerSize]: number of arguments (tagged)
// -- sp[4*kSystemPointerSize]: context
// -----------------------------------
__ LoadP(r7, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
......@@ -228,11 +228,11 @@ void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
// ----------- S t a t e -------------
// -- r3: receiver
// -- Slot 4 / sp[0*kPointerSize]: new target
// -- Slot 3 / sp[1*kPointerSize]: padding
// -- Slot 2 / sp[2*kPointerSize]: constructor function
// -- Slot 1 / sp[3*kPointerSize]: number of arguments (tagged)
// -- Slot 0 / sp[4*kPointerSize]: context
// -- Slot 4 / sp[0*kSystemPointerSize]: new target
// -- Slot 3 / sp[1*kSystemPointerSize]: padding
// -- Slot 2 / sp[2*kSystemPointerSize]: constructor function
// -- Slot 1 / sp[3*kSystemPointerSize]: number of arguments (tagged)
// -- Slot 0 / sp[4*kSystemPointerSize]: context
// -----------------------------------
// Deoptimizer enters here.
masm->isolate()->heap()->SetConstructStubCreateDeoptPCOffset(
......@@ -248,12 +248,12 @@ void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
// ----------- S t a t e -------------
// -- r6: new target
// -- sp[0*kPointerSize]: implicit receiver
// -- sp[1*kPointerSize]: implicit receiver
// -- sp[2*kPointerSize]: padding
// -- sp[3*kPointerSize]: constructor function
// -- sp[4*kPointerSize]: number of arguments (tagged)
// -- sp[5*kPointerSize]: context
// -- sp[0*kSystemPointerSize]: implicit receiver
// -- sp[1*kSystemPointerSize]: implicit receiver
// -- sp[2*kSystemPointerSize]: padding
// -- sp[3*kSystemPointerSize]: constructor function
// -- sp[4*kSystemPointerSize]: number of arguments (tagged)
// -- sp[5*kSystemPointerSize]: context
// -----------------------------------
// Restore constructor function and argument count.
......@@ -284,20 +284,20 @@ void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
// -- r6: new target
// -- r7: pointer to last argument
// -- cr0: condition indicating whether r3 is zero
// -- sp[0*kPointerSize]: implicit receiver
// -- sp[1*kPointerSize]: implicit receiver
// -- sp[2*kPointerSize]: padding
// -- r4 and sp[3*kPointerSize]: constructor function
// -- sp[4*kPointerSize]: number of arguments (tagged)
// -- sp[5*kPointerSize]: context
// -- sp[0*kSystemPointerSize]: implicit receiver
// -- sp[1*kSystemPointerSize]: implicit receiver
// -- sp[2*kSystemPointerSize]: padding
// -- r4 and sp[3*kSystemPointerSize]: constructor function
// -- sp[4*kSystemPointerSize]: number of arguments (tagged)
// -- sp[5*kSystemPointerSize]: context
// -----------------------------------
__ cmpi(r3, Operand::Zero());
__ beq(&no_args);
__ ShiftLeftImm(r9, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r9, r3, Operand(kSystemPointerSizeLog2));
__ sub(sp, sp, r9);
__ mtctr(r3);
__ bind(&loop);
__ subi(r9, r9, Operand(kPointerSize));
__ subi(r9, r9, Operand(kSystemPointerSize));
__ LoadPX(r0, MemOperand(r7, r9));
__ StorePX(r0, MemOperand(sp, r9));
__ bdnz(&loop);
......@@ -311,11 +311,11 @@ void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
// ----------- S t a t e -------------
// -- r0: constructor result
// -- sp[0*kPointerSize]: implicit receiver
// -- sp[1*kPointerSize]: padding
// -- sp[2*kPointerSize]: constructor function
// -- sp[3*kPointerSize]: number of arguments
// -- sp[4*kPointerSize]: context
// -- sp[0*kSystemPointerSize]: implicit receiver
// -- sp[1*kSystemPointerSize]: padding
// -- sp[2*kSystemPointerSize]: constructor function
// -- sp[3*kSystemPointerSize]: number of arguments
// -- sp[4*kSystemPointerSize]: context
// -----------------------------------
// Store offset of return address for deoptimizer.
......@@ -366,7 +366,7 @@ void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
__ SmiToPtrArrayOffset(r4, r4);
__ add(sp, sp, r4);
__ addi(sp, sp, Operand(kPointerSize));
__ addi(sp, sp, Operand(kSystemPointerSize));
__ blr();
}
......@@ -458,13 +458,14 @@ void Builtins::Generate_ResumeGeneratorTrampoline(MacroAssembler* masm) {
__ cmpi(r6, Operand::Zero());
__ ble(&done_loop);
// setup r9 to first element address - kPointerSize
__ addi(r9, r5,
Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
// setup r9 to first element address - kSystemPointerSize
__ addi(
r9, r5,
Operand(FixedArray::kHeaderSize - kHeapObjectTag - kSystemPointerSize));
__ mtctr(r6);
__ bind(&loop);
__ LoadPU(scratch, MemOperand(r9, kPointerSize));
__ LoadPU(scratch, MemOperand(r9, kSystemPointerSize));
__ push(scratch);
__ bdnz(&loop);
......@@ -560,7 +561,7 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
// PPC LINUX ABI:
// preserve LR in pre-reserved slot in caller's frame
__ mflr(r0);
__ StoreP(r0, MemOperand(sp, kStackFrameLRSlot * kPointerSize));
__ StoreP(r0, MemOperand(sp, kStackFrameLRSlot * kSystemPointerSize));
// Save callee saved registers on the stack.
__ MultiPush(kCalleeSaved);
......@@ -695,7 +696,7 @@ void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
__ MultiPop(kCalleeSaved);
// Return
__ LoadP(r0, MemOperand(sp, kStackFrameLRSlot * kPointerSize));
__ LoadP(r0, MemOperand(sp, kStackFrameLRSlot * kSystemPointerSize));
__ mtlr(r0);
__ blr();
}
......@@ -729,7 +730,7 @@ static void Generate_CheckStackOverflow(MacroAssembler* masm, Register argc,
// here which will cause scratch1 to become negative.
__ sub(scratch1, sp, scratch1);
// Check if the arguments will overflow the stack.
__ ShiftLeftImm(scratch2, argc, Operand(kPointerSizeLog2));
__ ShiftLeftImm(scratch2, argc, Operand(kSystemPointerSizeLog2));
__ cmp(scratch1, scratch2);
__ bgt(&okay); // Signed comparison.
......@@ -787,13 +788,13 @@ static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
// r3: argc
// r8: argv, i.e. points to first arg
Label loop, entry;
__ ShiftLeftImm(r0, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r0, r3, Operand(kSystemPointerSizeLog2));
__ add(r5, r8, r0);
// r5 points past last arg.
__ b(&entry);
__ bind(&loop);
__ LoadP(r9, MemOperand(r8)); // read next parameter
__ addi(r8, r8, Operand(kPointerSize));
__ addi(r8, r8, Operand(kSystemPointerSize));
__ LoadP(r0, MemOperand(r9)); // dereference handle
__ push(r0); // push parameter
__ bind(&entry);
......@@ -1156,7 +1157,7 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
// TODO(rmcilroy): Consider doing more than one push per loop iteration.
Label loop, no_args;
__ LoadRoot(kInterpreterAccumulatorRegister, RootIndex::kUndefinedValue);
__ ShiftRightImm(r5, r5, Operand(kPointerSizeLog2), SetRC);
__ ShiftRightImm(r5, r5, Operand(kSystemPointerSizeLog2), SetRC);
__ beq(&no_args, cr0);
__ mtctr(r5);
__ bind(&loop);
......@@ -1174,7 +1175,7 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
BytecodeArray::kIncomingNewTargetOrGeneratorRegisterOffset));
__ cmpi(r8, Operand::Zero());
__ beq(&no_incoming_new_target_or_generator_register);
__ ShiftLeftImm(r8, r8, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r8, r8, Operand(kSystemPointerSizeLog2));
__ StorePX(r6, MemOperand(fp, r8));
__ bind(&no_incoming_new_target_or_generator_register);
......@@ -1197,7 +1198,7 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
ExternalReference::interpreter_dispatch_table_address(masm->isolate()));
__ lbzx(r6, MemOperand(kInterpreterBytecodeArrayRegister,
kInterpreterBytecodeOffsetRegister));
__ ShiftLeftImm(r6, r6, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r6, r6, Operand(kSystemPointerSizeLog2));
__ LoadPX(kJavaScriptCallCodeStartRegister,
MemOperand(kInterpreterDispatchTableRegister, r6));
__ Call(kJavaScriptCallCodeStartRegister);
......@@ -1282,10 +1283,10 @@ static void Generate_InterpreterPushArgs(MacroAssembler* masm,
Label loop, skip;
__ cmpi(count, Operand::Zero());
__ beq(&skip);
__ addi(index, index, Operand(kPointerSize)); // Bias up for LoadPU
__ addi(index, index, Operand(kSystemPointerSize)); // Bias up for LoadPU
__ mtctr(count);
__ bind(&loop);
__ LoadPU(scratch, MemOperand(index, -kPointerSize));
__ LoadPU(scratch, MemOperand(index, -kSystemPointerSize));
__ push(scratch);
__ bdnz(&loop);
__ bind(&skip);
......@@ -1472,7 +1473,7 @@ static void Generate_InterpreterEnterBytecode(MacroAssembler* masm) {
Register scratch = temps.Acquire();
__ lbzx(ip, MemOperand(kInterpreterBytecodeArrayRegister,
kInterpreterBytecodeOffsetRegister));
__ ShiftLeftImm(scratch, scratch, Operand(kPointerSizeLog2));
__ ShiftLeftImm(scratch, scratch, Operand(kSystemPointerSizeLog2));
__ LoadPX(kJavaScriptCallCodeStartRegister,
MemOperand(kInterpreterDispatchTableRegister, scratch));
__ Jump(kJavaScriptCallCodeStartRegister);
......@@ -1538,9 +1539,10 @@ void Generate_ContinueToBuiltinHelper(MacroAssembler* masm,
// Overwrite the hole inserted by the deoptimizer with the return value from
// the LAZY deopt point.
__ StoreP(
r3, MemOperand(
sp, config->num_allocatable_general_registers() * kPointerSize +
BuiltinContinuationFrameConstants::kFixedFrameSize));
r3,
MemOperand(sp, config->num_allocatable_general_registers() *
kSystemPointerSize +
BuiltinContinuationFrameConstants::kFixedFrameSize));
}
for (int i = allocatable_register_count - 1; i >= 0; --i) {
int code = config->GetAllocatableGeneralCode(i);
......@@ -1591,8 +1593,8 @@ void Builtins::Generate_NotifyDeoptimized(MacroAssembler* masm) {
}
DCHECK_EQ(kInterpreterAccumulatorRegister.code(), r3.code());
__ LoadP(r3, MemOperand(sp, 0 * kPointerSize));
__ addi(sp, sp, Operand(1 * kPointerSize));
__ LoadP(r3, MemOperand(sp, 0 * kSystemPointerSize));
__ addi(sp, sp, Operand(1 * kSystemPointerSize));
__ Ret();
}
......@@ -1659,16 +1661,16 @@ void Builtins::Generate_FunctionPrototypeApply(MacroAssembler* masm) {
Register arg_size = r8;
Register new_sp = r6;
Register scratch = r7;
__ ShiftLeftImm(arg_size, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(arg_size, r3, Operand(kSystemPointerSizeLog2));
__ add(new_sp, sp, arg_size);
__ LoadRoot(scratch, RootIndex::kUndefinedValue);
__ mr(r5, scratch);
__ LoadP(r4, MemOperand(new_sp, 0)); // receiver
__ cmpi(arg_size, Operand(kPointerSize));
__ cmpi(arg_size, Operand(kSystemPointerSize));
__ blt(&skip);
__ LoadP(scratch, MemOperand(new_sp, 1 * -kPointerSize)); // thisArg
__ LoadP(scratch, MemOperand(new_sp, 1 * -kSystemPointerSize)); // thisArg
__ beq(&skip);
__ LoadP(r5, MemOperand(new_sp, 2 * -kPointerSize)); // argArray
__ LoadP(r5, MemOperand(new_sp, 2 * -kSystemPointerSize)); // argArray
__ bind(&skip);
__ mr(sp, new_sp);
__ StoreP(scratch, MemOperand(sp, 0));
......@@ -1717,7 +1719,7 @@ void Builtins::Generate_FunctionPrototypeCall(MacroAssembler* masm) {
// 2. Get the callable to call (passed as receiver) from the stack.
// r3: actual number of arguments
__ ShiftLeftImm(r5, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r5, r3, Operand(kSystemPointerSizeLog2));
__ LoadPX(r4, MemOperand(sp, r5));
// 3. Shift arguments and return address one slot down on the stack
......@@ -1733,9 +1735,9 @@ void Builtins::Generate_FunctionPrototypeCall(MacroAssembler* masm) {
__ mtctr(r3);
__ bind(&loop);
__ LoadP(scratch, MemOperand(r5, -kPointerSize));
__ LoadP(scratch, MemOperand(r5, -kSystemPointerSize));
__ StoreP(scratch, MemOperand(r5));
__ subi(r5, r5, Operand(kPointerSize));
__ subi(r5, r5, Operand(kSystemPointerSize));
__ bdnz(&loop);
// Adjust the actual number of arguments and remove the top element
// (which is a copy of the last argument).
......@@ -1764,19 +1766,20 @@ void Builtins::Generate_ReflectApply(MacroAssembler* masm) {
Register arg_size = r8;
Register new_sp = r6;
Register scratch = r7;
__ ShiftLeftImm(arg_size, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(arg_size, r3, Operand(kSystemPointerSizeLog2));
__ add(new_sp, sp, arg_size);
__ LoadRoot(r4, RootIndex::kUndefinedValue);
__ mr(scratch, r4);
__ mr(r5, r4);
__ cmpi(arg_size, Operand(kPointerSize));
__ cmpi(arg_size, Operand(kSystemPointerSize));
__ blt(&skip);
__ LoadP(r4, MemOperand(new_sp, 1 * -kPointerSize)); // target
__ LoadP(r4, MemOperand(new_sp, 1 * -kSystemPointerSize)); // target
__ beq(&skip);
__ LoadP(scratch, MemOperand(new_sp, 2 * -kPointerSize)); // thisArgument
__ cmpi(arg_size, Operand(2 * kPointerSize));
__ LoadP(scratch,
MemOperand(new_sp, 2 * -kSystemPointerSize)); // thisArgument
__ cmpi(arg_size, Operand(2 * kSystemPointerSize));
__ beq(&skip);
__ LoadP(r5, MemOperand(new_sp, 3 * -kPointerSize)); // argumentsList
__ LoadP(r5, MemOperand(new_sp, 3 * -kSystemPointerSize)); // argumentsList
__ bind(&skip);
__ mr(sp, new_sp);
__ StoreP(scratch, MemOperand(sp, 0));
......@@ -1814,21 +1817,21 @@ void Builtins::Generate_ReflectConstruct(MacroAssembler* masm) {
Label skip;
Register arg_size = r8;
Register new_sp = r7;
__ ShiftLeftImm(arg_size, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(arg_size, r3, Operand(kSystemPointerSizeLog2));
__ add(new_sp, sp, arg_size);
__ LoadRoot(r4, RootIndex::kUndefinedValue);
__ mr(r5, r4);
__ mr(r6, r4);
__ StoreP(r4, MemOperand(new_sp, 0)); // receiver (undefined)
__ cmpi(arg_size, Operand(kPointerSize));
__ cmpi(arg_size, Operand(kSystemPointerSize));
__ blt(&skip);
__ LoadP(r4, MemOperand(new_sp, 1 * -kPointerSize)); // target
__ LoadP(r4, MemOperand(new_sp, 1 * -kSystemPointerSize)); // target
__ mr(r6, r4); // new.target defaults to target
__ beq(&skip);
__ LoadP(r5, MemOperand(new_sp, 2 * -kPointerSize)); // argumentsList
__ cmpi(arg_size, Operand(2 * kPointerSize));
__ LoadP(r5, MemOperand(new_sp, 2 * -kSystemPointerSize)); // argumentsList
__ cmpi(arg_size, Operand(2 * kSystemPointerSize));
__ beq(&skip);
__ LoadP(r6, MemOperand(new_sp, 3 * -kPointerSize)); // new.target
__ LoadP(r6, MemOperand(new_sp, 3 * -kSystemPointerSize)); // new.target
__ bind(&skip);
__ mr(sp, new_sp);
}
......@@ -1875,7 +1878,7 @@ static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) {
// Get the number of arguments passed (as a smi), tear down the frame and
// then tear down the parameters.
__ LoadP(r4, MemOperand(fp, ArgumentsAdaptorFrameConstants::kLengthOffset));
int stack_adjustment = kPointerSize; // adjust for receiver
int stack_adjustment = kSystemPointerSize; // adjust for receiver
__ LeaveFrame(StackFrame::ARGUMENTS_ADAPTOR, stack_adjustment);
__ SmiToPtrArrayOffset(r0, r4);
__ add(sp, sp, r0);
......@@ -1923,11 +1926,12 @@ void Builtins::Generate_CallOrConstructVarargs(MacroAssembler* masm,
Label loop, no_args, skip;
__ cmpi(r7, Operand::Zero());
__ beq(&no_args);
__ addi(r5, r5,
Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
__ addi(
r5, r5,
Operand(FixedArray::kHeaderSize - kHeapObjectTag - kSystemPointerSize));
__ mtctr(r7);
__ bind(&loop);
__ LoadPU(scratch, MemOperand(r5, kPointerSize));
__ LoadPU(scratch, MemOperand(r5, kSystemPointerSize));
__ CompareRoot(scratch, RootIndex::kTheHoleValue);
__ bne(&skip);
__ LoadRoot(scratch, RootIndex::kUndefinedValue);
......@@ -2011,11 +2015,11 @@ void Builtins::Generate_CallOrConstructForwardVarargs(MacroAssembler* masm,
// Forward the arguments from the caller frame.
{
Label loop;
__ addi(r7, r7, Operand(kPointerSize));
__ addi(r7, r7, Operand(kSystemPointerSize));
__ add(r3, r3, r8);
__ bind(&loop);
{
__ ShiftLeftImm(scratch, r8, Operand(kPointerSizeLog2));
__ ShiftLeftImm(scratch, r8, Operand(kSystemPointerSizeLog2));
__ LoadPX(scratch, MemOperand(r7, scratch));
__ push(scratch);
__ subi(r8, r8, Operand(1));
......@@ -2073,7 +2077,7 @@ void Builtins::Generate_CallFunction(MacroAssembler* masm,
__ LoadGlobalProxy(r6);
} else {
Label convert_to_object, convert_receiver;
__ ShiftLeftImm(r6, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r6, r3, Operand(kSystemPointerSizeLog2));
__ LoadPX(r6, MemOperand(sp, r6));
__ JumpIfSmi(r6, &convert_to_object);
STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
......@@ -2110,7 +2114,7 @@ void Builtins::Generate_CallFunction(MacroAssembler* masm,
__ LoadP(r5, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
__ bind(&convert_receiver);
}
__ ShiftLeftImm(r7, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r7, r3, Operand(kSystemPointerSizeLog2));
__ StorePX(r6, MemOperand(sp, r7));
}
__ bind(&done_convert);
......@@ -2164,7 +2168,7 @@ void Generate_PushBoundArguments(MacroAssembler* masm) {
{
Label done;
__ mr(scratch, sp); // preserve previous stack pointer
__ ShiftLeftImm(r10, r7, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r10, r7, Operand(kSystemPointerSizeLog2));
__ sub(sp, sp, r10);
// Check the stack for overflow. We are not trying to catch interruptions
// (i.e. debug break and preemption) here, so check the "real stack
......@@ -2199,7 +2203,7 @@ void Generate_PushBoundArguments(MacroAssembler* masm) {
__ bind(&loop);
__ LoadPX(r0, MemOperand(scratch, r8));
__ StorePX(r0, MemOperand(sp, r8));
__ addi(r8, r8, Operand(kPointerSize));
__ addi(r8, r8, Operand(kSystemPointerSize));
__ bdnz(&loop);
__ bind(&skip);
}
......@@ -2211,9 +2215,9 @@ void Generate_PushBoundArguments(MacroAssembler* masm) {
__ add(r5, r5, r10);
__ mtctr(r7);
__ bind(&loop);
__ LoadPU(r0, MemOperand(r5, -kPointerSize));
__ LoadPU(r0, MemOperand(r5, -kSystemPointerSize));
__ StorePX(r0, MemOperand(sp, r8));
__ addi(r8, r8, Operand(kPointerSize));
__ addi(r8, r8, Operand(kSystemPointerSize));
__ bdnz(&loop);
__ add(r3, r3, r7);
}
......@@ -2233,7 +2237,7 @@ void Builtins::Generate_CallBoundFunctionImpl(MacroAssembler* masm) {
// Patch the receiver to [[BoundThis]].
__ LoadP(r6, FieldMemOperand(r4, JSBoundFunction::kBoundThisOffset));
__ ShiftLeftImm(r0, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r0, r3, Operand(kSystemPointerSizeLog2));
__ StorePX(r6, MemOperand(sp, r0));
// Push the [[BoundArguments]] onto the stack.
......@@ -2275,7 +2279,7 @@ void Builtins::Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode) {
// 2. Call to something else, which might have a [[Call]] internal method (if
// not we raise an exception).
// Overwrite the original receiver the (original) target.
__ ShiftLeftImm(r8, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r8, r3, Operand(kSystemPointerSizeLog2));
__ StorePX(r4, MemOperand(sp, r8));
// Let the "call_as_function_delegate" take care of the rest.
__ LoadNativeContextSlot(Context::CALL_AS_FUNCTION_DELEGATE_INDEX, r4);
......@@ -2390,7 +2394,7 @@ void Builtins::Generate_Construct(MacroAssembler* masm) {
__ bind(&non_proxy);
{
// Overwrite the original receiver with the (original) target.
__ ShiftLeftImm(r8, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r8, r3, Operand(kSystemPointerSizeLog2));
__ StorePX(r4, MemOperand(sp, r8));
// Let the "call_as_constructor_delegate" take care of the rest.
__ LoadNativeContextSlot(Context::CALL_AS_CONSTRUCTOR_DELEGATE_INDEX, r4);
......@@ -2444,8 +2448,8 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
__ SmiToPtrArrayOffset(r3, r3);
__ add(r3, r3, fp);
// adjust for return address and receiver
__ addi(r3, r3, Operand(2 * kPointerSize));
__ ShiftLeftImm(r7, r5, Operand(kPointerSizeLog2));
__ addi(r3, r3, Operand(2 * kSystemPointerSize));
__ ShiftLeftImm(r7, r5, Operand(kSystemPointerSizeLog2));
__ sub(r7, r3, r7);
// Copy the arguments (including the receiver) to the new stack frame.
......@@ -2460,7 +2464,7 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
__ LoadP(r0, MemOperand(r3, 0));
__ push(r0);
__ cmp(r3, r7); // Compare before moving to next argument.
__ subi(r3, r3, Operand(kPointerSize));
__ subi(r3, r3, Operand(kSystemPointerSize));
__ bne(&copy);
__ b(&invoke);
......@@ -2488,10 +2492,10 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
Label copy;
__ bind(&copy);
// Adjust load for return address and receiver.
__ LoadP(r0, MemOperand(r3, 2 * kPointerSize));
__ LoadP(r0, MemOperand(r3, 2 * kSystemPointerSize));
__ push(r0);
__ cmp(r3, fp); // Compare before moving to next argument.
__ subi(r3, r3, Operand(kPointerSize));
__ subi(r3, r3, Operand(kSystemPointerSize));
__ bne(&copy);
// Fill the remaining expected arguments with undefined.
......@@ -2499,12 +2503,12 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
// r5: expected number of arguments
// r6: new target (passed through to callee)
__ LoadRoot(r0, RootIndex::kUndefinedValue);
__ ShiftLeftImm(r7, r5, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r7, r5, Operand(kSystemPointerSizeLog2));
__ sub(r7, fp, r7);
// Adjust for frame.
__ subi(r7, r7,
Operand(ArgumentsAdaptorFrameConstants::kFixedFrameSizeFromFp +
kPointerSize));
kSystemPointerSize));
Label fill;
__ bind(&fill);
......@@ -2549,7 +2553,7 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
// Remove superfluous parameters from the stack.
__ sub(r7, r3, r5);
__ mr(r3, r5);
__ ShiftLeftImm(r7, r7, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r7, r7, Operand(kSystemPointerSizeLog2));
__ add(sp, sp, r7);
__ b(&dont_adapt_arguments);
}
......@@ -2663,9 +2667,9 @@ void Builtins::Generate_CEntry(MacroAssembler* masm, int result_size,
__ mr(r4, r5);
} else {
// Compute the argv pointer.
__ ShiftLeftImm(r4, r3, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r4, r3, Operand(kSystemPointerSizeLog2));
__ add(r4, r4, sp);
__ subi(r4, r4, Operand(kPointerSize));
__ subi(r4, r4, Operand(kSystemPointerSize));
}
// Enter the exit frame that transitions from JavaScript to C++.
......@@ -2701,7 +2705,8 @@ void Builtins::Generate_CEntry(MacroAssembler* masm, int result_size,
// buffer as implicit first argument.
__ mr(r5, r4);
__ mr(r4, r3);
__ addi(r3, sp, Operand((kStackFrameExtraParamSlot + 1) * kPointerSize));
__ addi(r3, sp,
Operand((kStackFrameExtraParamSlot + 1) * kSystemPointerSize));
isolate_reg = r6;
}
......@@ -2713,7 +2718,7 @@ void Builtins::Generate_CEntry(MacroAssembler* masm, int result_size,
// If return value is on the stack, pop it to registers.
if (needs_return_buffer) {
__ LoadP(r4, MemOperand(r3, kPointerSize));
__ LoadP(r4, MemOperand(r3, kSystemPointerSize));
__ LoadP(r3, MemOperand(r3));
}
......@@ -2828,7 +2833,7 @@ void Builtins::Generate_DoubleToI(MacroAssembler* masm) {
__ Push(result_reg, scratch);
// Account for saved regs.
int argument_offset = 2 * kPointerSize;
int argument_offset = 2 * kSystemPointerSize;
// Load double input.
__ lfd(double_scratch, MemOperand(sp, argument_offset));
......@@ -2850,7 +2855,7 @@ void Builtins::Generate_DoubleToI(MacroAssembler* masm) {
__ Push(scratch_high, scratch_low);
// Account for saved regs.
argument_offset += 2 * kPointerSize;
argument_offset += 2 * kSystemPointerSize;
__ lwz(scratch_high,
MemOperand(sp, argument_offset + Register::kExponentOffset));
......@@ -2921,7 +2926,7 @@ void Builtins::Generate_DoubleToI(MacroAssembler* masm) {
__ bind(&done);
__ Pop(scratch_high, scratch_low);
// Account for saved regs.
argument_offset -= 2 * kPointerSize;
argument_offset -= 2 * kSystemPointerSize;
__ bind(&fastpath_done);
__ StoreP(result_reg, MemOperand(sp, argument_offset));
......@@ -3092,33 +3097,33 @@ void Builtins::Generate_CallApiCallback(MacroAssembler* masm) {
// Set up FunctionCallbackInfo's implicit_args on the stack as follows:
//
// Target state:
// sp[0 * kPointerSize]: kHolder
// sp[1 * kPointerSize]: kIsolate
// sp[2 * kPointerSize]: undefined (kReturnValueDefaultValue)
// sp[3 * kPointerSize]: undefined (kReturnValue)
// sp[4 * kPointerSize]: kData
// sp[5 * kPointerSize]: undefined (kNewTarget)
// sp[0 * kSystemPointerSize]: kHolder
// sp[1 * kSystemPointerSize]: kIsolate
// sp[2 * kSystemPointerSize]: undefined (kReturnValueDefaultValue)
// sp[3 * kSystemPointerSize]: undefined (kReturnValue)
// sp[4 * kSystemPointerSize]: kData
// sp[5 * kSystemPointerSize]: undefined (kNewTarget)
// Reserve space on the stack.
__ subi(sp, sp, Operand(FCA::kArgsLength * kPointerSize));
__ subi(sp, sp, Operand(FCA::kArgsLength * kSystemPointerSize));
// kHolder.
__ StoreP(holder, MemOperand(sp, 0 * kPointerSize));
__ StoreP(holder, MemOperand(sp, 0 * kSystemPointerSize));
// kIsolate.
__ Move(scratch, ExternalReference::isolate_address(masm->isolate()));
__ StoreP(scratch, MemOperand(sp, 1 * kPointerSize));
__ StoreP(scratch, MemOperand(sp, 1 * kSystemPointerSize));
// kReturnValueDefaultValue and kReturnValue.
__ LoadRoot(scratch, RootIndex::kUndefinedValue);
__ StoreP(scratch, MemOperand(sp, 2 * kPointerSize));
__ StoreP(scratch, MemOperand(sp, 3 * kPointerSize));
__ StoreP(scratch, MemOperand(sp, 2 * kSystemPointerSize));
__ StoreP(scratch, MemOperand(sp, 3 * kSystemPointerSize));
// kData.
__ StoreP(call_data, MemOperand(sp, 4 * kPointerSize));
__ StoreP(call_data, MemOperand(sp, 4 * kSystemPointerSize));
// kNewTarget.
__ StoreP(scratch, MemOperand(sp, 5 * kPointerSize));
__ StoreP(scratch, MemOperand(sp, 5 * kSystemPointerSize));
// Keep a pointer to kHolder (= implicit_args) in a scratch register.
// We use it below to set up the FunctionCallbackInfo object.
......@@ -3140,31 +3145,34 @@ void Builtins::Generate_CallApiCallback(MacroAssembler* masm) {
// FunctionCallbackInfo::implicit_args_ (points at kHolder as set up above).
// Arguments are after the return address (pushed by EnterExitFrame()).
__ StoreP(scratch,
MemOperand(sp, (kStackFrameExtraParamSlot + 1) * kPointerSize));
__ StoreP(scratch, MemOperand(sp, (kStackFrameExtraParamSlot + 1) *
kSystemPointerSize));
// FunctionCallbackInfo::values_ (points at the first varargs argument passed
// on the stack).
__ addi(scratch, scratch, Operand((FCA::kArgsLength - 1) * kPointerSize));
__ ShiftLeftImm(ip, argc, Operand(kPointerSizeLog2));
__ addi(scratch, scratch,
Operand((FCA::kArgsLength - 1) * kSystemPointerSize));
__ ShiftLeftImm(ip, argc, Operand(kSystemPointerSizeLog2));
__ add(scratch, scratch, ip);
__ StoreP(scratch,
MemOperand(sp, (kStackFrameExtraParamSlot + 2) * kPointerSize));
__ StoreP(scratch, MemOperand(sp, (kStackFrameExtraParamSlot + 2) *
kSystemPointerSize));
// FunctionCallbackInfo::length_.
__ stw(argc, MemOperand(sp, (kStackFrameExtraParamSlot + 3) * kPointerSize));
__ stw(argc,
MemOperand(sp, (kStackFrameExtraParamSlot + 3) * kSystemPointerSize));
// We also store the number of bytes to drop from the stack after returning
// from the API function here.
__ mov(scratch,
Operand((FCA::kArgsLength + 1 /* receiver */) * kPointerSize));
__ ShiftLeftImm(ip, argc, Operand(kPointerSizeLog2));
Operand((FCA::kArgsLength + 1 /* receiver */) * kSystemPointerSize));
__ ShiftLeftImm(ip, argc, Operand(kSystemPointerSizeLog2));
__ add(scratch, scratch, ip);
__ StoreP(scratch,
MemOperand(sp, (kStackFrameExtraParamSlot + 4) * kPointerSize));
__ StoreP(scratch, MemOperand(sp, (kStackFrameExtraParamSlot + 4) *
kSystemPointerSize));
// v8::InvocationCallback's argument.
__ addi(r3, sp, Operand((kStackFrameExtraParamSlot + 1) * kPointerSize));
__ addi(r3, sp,
Operand((kStackFrameExtraParamSlot + 1) * kSystemPointerSize));
ExternalReference thunk_ref = ExternalReference::invoke_function_callback();
......@@ -3172,11 +3180,11 @@ void Builtins::Generate_CallApiCallback(MacroAssembler* masm) {
// TODO(jgruber): Document what these arguments are.
static constexpr int kStackSlotsAboveFCA = 2;
MemOperand return_value_operand(
fp, (kStackSlotsAboveFCA + FCA::kReturnValueOffset) * kPointerSize);
fp, (kStackSlotsAboveFCA + FCA::kReturnValueOffset) * kSystemPointerSize);
static constexpr int kUseStackSpaceOperand = 0;
MemOperand stack_space_operand(
sp, (kStackFrameExtraParamSlot + 4) * kPointerSize);
sp, (kStackFrameExtraParamSlot + 4) * kSystemPointerSize);
AllowExternalCallThatCantCauseGC scope(masm);
CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
......@@ -3225,20 +3233,20 @@ void Builtins::Generate_CallApiGetter(MacroAssembler* masm) {
// Load address of v8::PropertyAccessorInfo::args_ array and name handle.
__ mr(r3, sp); // r3 = Handle<Name>
__ addi(r4, r3, Operand(1 * kPointerSize)); // r4 = v8::PCI::args_
__ addi(r4, r3, Operand(1 * kSystemPointerSize)); // r4 = v8::PCI::args_
// If ABI passes Handles (pointer-sized struct) in a register:
//
// Create 2 extra slots on stack:
// [0] space for DirectCEntryStub's LR save
// [1] AccessorInfo&
//
// Otherwise:
//
// Create 3 extra slots on stack:
// [0] space for DirectCEntryStub's LR save
// [1] copy of Handle (first arg)
// [2] AccessorInfo&
// If ABI passes Handles (pointer-sized struct) in a register:
//
// Create 2 extra slots on stack:
// [0] space for DirectCEntryStub's LR save
// [1] AccessorInfo&
//
// Otherwise:
//
// Create 3 extra slots on stack:
// [0] space for DirectCEntryStub's LR save
// [1] copy of Handle (first arg)
// [2] AccessorInfo&
if (ABI_PASSES_HANDLES_IN_REGS) {
accessorInfoSlot = kStackFrameExtraParamSlot + 1;
apiStackSpace = 2;
......@@ -3253,14 +3261,14 @@ void Builtins::Generate_CallApiGetter(MacroAssembler* masm) {
if (!ABI_PASSES_HANDLES_IN_REGS) {
// pass 1st arg by reference
__ StoreP(r3, MemOperand(sp, arg0Slot * kPointerSize));
__ addi(r3, sp, Operand(arg0Slot * kPointerSize));
__ StoreP(r3, MemOperand(sp, arg0Slot * kSystemPointerSize));
__ addi(r3, sp, Operand(arg0Slot * kSystemPointerSize));
}
// Create v8::PropertyCallbackInfo object on the stack and initialize
// it's args_ field.
__ StoreP(r4, MemOperand(sp, accessorInfoSlot * kPointerSize));
__ addi(r4, sp, Operand(accessorInfoSlot * kPointerSize));
__ StoreP(r4, MemOperand(sp, accessorInfoSlot * kSystemPointerSize));
__ addi(r4, sp, Operand(accessorInfoSlot * kSystemPointerSize));
// r4 = v8::PropertyCallbackInfo&
ExternalReference thunk_ref =
......@@ -3272,7 +3280,8 @@ void Builtins::Generate_CallApiGetter(MacroAssembler* masm) {
// +3 is to skip prolog, return address and name handle.
MemOperand return_value_operand(
fp, (PropertyCallbackArguments::kReturnValueOffset + 3) * kPointerSize);
fp,
(PropertyCallbackArguments::kReturnValueOffset + 3) * kSystemPointerSize);
MemOperand* const kUseStackSpaceConstant = nullptr;
CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
kStackUnwindSpace, kUseStackSpaceConstant,
......@@ -3285,16 +3294,17 @@ void Builtins::Generate_DirectCEntry(MacroAssembler* masm) {
// Place the return address on the stack, making the call
// GC safe. The RegExp backend also relies on this.
__ mflr(r0);
__ StoreP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kPointerSize));
__ StoreP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kSystemPointerSize));
if (ABI_USES_FUNCTION_DESCRIPTORS) {
// AIX/PPC64BE Linux use a function descriptor;
__ LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(temp2, kPointerSize));
__ LoadP(ToRegister(ABI_TOC_REGISTER),
MemOperand(temp2, kSystemPointerSize));
__ LoadP(temp2, MemOperand(temp2, 0)); // Instruction address
}
__ Call(temp2); // Call the C++ function.
__ LoadP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kPointerSize));
__ LoadP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kSystemPointerSize));
__ mtlr(r0);
__ blr();
}
......
src/codegen/ppc/assembler-ppc.cc
View file @ a3fbabc7
......@@ -511,7 +511,7 @@ void Assembler::target_at_put(int pos, int target_pos, bool* is_branch) {
case kUnboundJumpTableEntryOpcode: {
PatchingAssembler patcher(options(),
reinterpret_cast<byte*>(buffer_start_ + pos),
kPointerSize / kInstrSize);
kSystemPointerSize / kInstrSize);
// Keep internal references relative until EmitRelocations.
patcher.dp(target_pos);
break;
......
src/codegen/ppc/assembler-ppc.h
View file @ a3fbabc7
......@@ -958,9 +958,9 @@ class Assembler : public AssemblerBase {
void push(Register src) {
#if V8_TARGET_ARCH_PPC64
stdu(src, MemOperand(sp, -kPointerSize));
stdu(src, MemOperand(sp, -kSystemPointerSize));
#else
stwu(src, MemOperand(sp, -kPointerSize));
stwu(src, MemOperand(sp, -kSystemPointerSize));
#endif
}
......@@ -970,10 +970,10 @@ class Assembler : public AssemblerBase {
#else
lwz(dst, MemOperand(sp));
#endif
addi(sp, sp, Operand(kPointerSize));
addi(sp, sp, Operand(kSystemPointerSize));
}
void pop() { addi(sp, sp, Operand(kPointerSize)); }
void pop() { addi(sp, sp, Operand(kSystemPointerSize)); }
// Jump unconditionally to given label.
void jmp(Label* L) { b(L); }
......
src/codegen/ppc/macro-assembler-ppc.cc
View file @ a3fbabc7
......@@ -50,7 +50,7 @@ int TurboAssembler::RequiredStackSizeForCallerSaved(SaveFPRegsMode fp_mode,
}
RegList list = kJSCallerSaved & ~exclusions;
bytes += NumRegs(list) * kPointerSize;
bytes += NumRegs(list) * kSystemPointerSize;
if (fp_mode == kSaveFPRegs) {
bytes += kNumCallerSavedDoubles * kDoubleSize;
......@@ -75,7 +75,7 @@ int TurboAssembler::PushCallerSaved(SaveFPRegsMode fp_mode, Register exclusion1,
RegList list = kJSCallerSaved & ~exclusions;
MultiPush(list);
bytes += NumRegs(list) * kPointerSize;
bytes += NumRegs(list) * kSystemPointerSize;
if (fp_mode == kSaveFPRegs) {
MultiPushDoubles(kCallerSavedDoubles);
......@@ -106,7 +106,7 @@ int TurboAssembler::PopCallerSaved(SaveFPRegsMode fp_mode, Register exclusion1,
RegList list = kJSCallerSaved & ~exclusions;
MultiPop(list);
bytes += NumRegs(list) * kPointerSize;
bytes += NumRegs(list) * kSystemPointerSize;
return bytes;
}
......@@ -120,8 +120,8 @@ void TurboAssembler::LoadFromConstantsTable(Register destination,
int constant_index) {
DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kBuiltinsConstantsTable));
const uint32_t offset =
FixedArray::kHeaderSize + constant_index * kPointerSize - kHeapObjectTag;
const uint32_t offset = FixedArray::kHeaderSize +
constant_index * kSystemPointerSize - kHeapObjectTag;
CHECK(is_uint19(offset));
DCHECK_NE(destination, r0);
......@@ -212,7 +212,8 @@ void TurboAssembler::Jump(const ExternalReference& reference) {
if (ABI_USES_FUNCTION_DESCRIPTORS) {
// AIX uses a function descriptor. When calling C code be
// aware of this descriptor and pick up values from it.
LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(scratch, kPointerSize));
LoadP(ToRegister(ABI_TOC_REGISTER),
MemOperand(scratch, kSystemPointerSize));
LoadP(scratch, MemOperand(scratch, 0));
}
Jump(scratch);
......@@ -296,12 +297,12 @@ void TurboAssembler::Call(Handle<Code> code, RelocInfo::Mode rmode,
void TurboAssembler::Drop(int count) {
if (count > 0) {
Add(sp, sp, count * kPointerSize, r0);
Add(sp, sp, count * kSystemPointerSize, r0);
}
}
void TurboAssembler::Drop(Register count, Register scratch) {
ShiftLeftImm(scratch, count, Operand(kPointerSizeLog2));
ShiftLeftImm(scratch, count, Operand(kSystemPointerSizeLog2));
add(sp, sp, scratch);
}
......@@ -354,12 +355,12 @@ void TurboAssembler::Move(DoubleRegister dst, DoubleRegister src) {
void TurboAssembler::MultiPush(RegList regs, Register location) {
int16_t num_to_push = base::bits::CountPopulation(regs);
int16_t stack_offset = num_to_push * kPointerSize;
int16_t stack_offset = num_to_push * kSystemPointerSize;
subi(location, location, Operand(stack_offset));
for (int16_t i = Register::kNumRegisters - 1; i >= 0; i--) {
if ((regs & (1 << i)) != 0) {
stack_offset -= kPointerSize;
stack_offset -= kSystemPointerSize;
StoreP(ToRegister(i), MemOperand(location, stack_offset));
}
}
......@@ -371,7 +372,7 @@ void TurboAssembler::MultiPop(RegList regs, Register location) {
for (int16_t i = 0; i < Register::kNumRegisters; i++) {
if ((regs & (1 << i)) != 0) {
LoadP(ToRegister(i), MemOperand(location, stack_offset));
stack_offset += kPointerSize;
stack_offset += kSystemPointerSize;
}
}
addi(location, location, Operand(stack_offset));
......@@ -427,13 +428,13 @@ void MacroAssembler::RecordWriteField(Register object, int offset,
}
// Although the object register is tagged, the offset is relative to the start
// of the object, so so offset must be a multiple of kPointerSize.
DCHECK(IsAligned(offset, kPointerSize));
// of the object, so so offset must be a multiple of kSystemPointerSize.
DCHECK(IsAligned(offset, kSystemPointerSize));
Add(dst, object, offset - kHeapObjectTag, r0);
if (emit_debug_code()) {
Label ok;
andi(r0, dst, Operand(kPointerSize - 1));
andi(r0, dst, Operand(kSystemPointerSize - 1));
beq(&ok, cr0);
stop();
bind(&ok);
......@@ -636,7 +637,7 @@ void TurboAssembler::PushCommonFrame(Register marker_reg) {
fp_delta = 0;
}
}
addi(fp, sp, Operand(fp_delta * kPointerSize));
addi(fp, sp, Operand(fp_delta * kSystemPointerSize));
}
void TurboAssembler::PushStandardFrame(Register function_reg) {
......@@ -659,7 +660,7 @@ void TurboAssembler::PushStandardFrame(Register function_reg) {
fp_delta = 1;
}
}
addi(fp, sp, Operand(fp_delta * kPointerSize));
addi(fp, sp, Operand(fp_delta * kSystemPointerSize));
}
void TurboAssembler::RestoreFrameStateForTailCall() {
......@@ -1012,9 +1013,9 @@ void MacroAssembler::EnterExitFrame(bool save_doubles, int stack_space,
DCHECK(frame_type == StackFrame::EXIT ||
frame_type == StackFrame::BUILTIN_EXIT);
// Set up the frame structure on the stack.
DCHECK_EQ(2 * kPointerSize, ExitFrameConstants::kCallerSPDisplacement);
DCHECK_EQ(1 * kPointerSize, ExitFrameConstants::kCallerPCOffset);
DCHECK_EQ(0 * kPointerSize, ExitFrameConstants::kCallerFPOffset);
DCHECK_EQ(2 * kSystemPointerSize, ExitFrameConstants::kCallerSPDisplacement);
DCHECK_EQ(1 * kSystemPointerSize, ExitFrameConstants::kCallerPCOffset);
DCHECK_EQ(0 * kSystemPointerSize, ExitFrameConstants::kCallerFPOffset);
DCHECK_GT(stack_space, 0);
// This is an opportunity to build a frame to wrap
......@@ -1052,22 +1053,23 @@ void MacroAssembler::EnterExitFrame(bool save_doubles, int stack_space,
// since the sp slot and code slot were pushed after the fp.
}
addi(sp, sp, Operand(-stack_space * kPointerSize));
addi(sp, sp, Operand(-stack_space * kSystemPointerSize));
// Allocate and align the frame preparing for calling the runtime
// function.
const int frame_alignment = ActivationFrameAlignment();
if (frame_alignment > kPointerSize) {
if (frame_alignment > kSystemPointerSize) {
DCHECK(base::bits::IsPowerOfTwo(frame_alignment));
ClearRightImm(sp, sp,
Operand(base::bits::WhichPowerOfTwo(frame_alignment)));
}
li(r0, Operand::Zero());
StorePU(r0, MemOperand(sp, -kNumRequiredStackFrameSlots * kPointerSize));
StorePU(r0,
MemOperand(sp, -kNumRequiredStackFrameSlots * kSystemPointerSize));
// Set the exit frame sp value to point just before the return address
// location.
addi(r8, sp, Operand((kStackFrameExtraParamSlot + 1) * kPointerSize));
addi(r8, sp, Operand((kStackFrameExtraParamSlot + 1) * kSystemPointerSize));
StoreP(r8, MemOperand(fp, ExitFrameConstants::kSPOffset));
}
......@@ -1123,7 +1125,8 @@ void MacroAssembler::LeaveExitFrame(bool save_doubles, Register argument_count,
if (argument_count.is_valid()) {
if (!argument_count_is_length) {
ShiftLeftImm(argument_count, argument_count, Operand(kPointerSizeLog2));
ShiftLeftImm(argument_count, argument_count,
Operand(kSystemPointerSizeLog2));
}
add(sp, sp, argument_count);
}
......@@ -1143,19 +1146,19 @@ void TurboAssembler::PrepareForTailCall(Register callee_args_count,
DCHECK(!AreAliased(callee_args_count, caller_args_count, scratch0, scratch1));
// Calculate the end of destination area where we will put the arguments
// after we drop current frame. We add kPointerSize to count the receiver
// argument which is not included into formal parameters count.
// after we drop current frame. We add kSystemPointerSize to count the
// receiver argument which is not included into formal parameters count.
Register dst_reg = scratch0;
ShiftLeftImm(dst_reg, caller_args_count, Operand(kPointerSizeLog2));
ShiftLeftImm(dst_reg, caller_args_count, Operand(kSystemPointerSizeLog2));
add(dst_reg, fp, dst_reg);
addi(dst_reg, dst_reg,
Operand(StandardFrameConstants::kCallerSPOffset + kPointerSize));
Operand(StandardFrameConstants::kCallerSPOffset + kSystemPointerSize));
Register src_reg = caller_args_count;
// Calculate the end of source area. +kPointerSize is for the receiver.
ShiftLeftImm(src_reg, callee_args_count, Operand(kPointerSizeLog2));
// Calculate the end of source area. +kSystemPointerSize is for the receiver.
ShiftLeftImm(src_reg, callee_args_count, Operand(kSystemPointerSizeLog2));
add(src_reg, sp, src_reg);
addi(src_reg, src_reg, Operand(kPointerSize));
addi(src_reg, src_reg, Operand(kSystemPointerSize));
if (FLAG_debug_code) {
cmpl(src_reg, dst_reg);
......@@ -1176,8 +1179,8 @@ void TurboAssembler::PrepareForTailCall(Register callee_args_count,
addi(tmp_reg, callee_args_count, Operand(1)); // +1 for receiver
mtctr(tmp_reg);
bind(&loop);
LoadPU(tmp_reg, MemOperand(src_reg, -kPointerSize));
StorePU(tmp_reg, MemOperand(dst_reg, -kPointerSize));
LoadPU(tmp_reg, MemOperand(src_reg, -kSystemPointerSize));
StorePU(tmp_reg, MemOperand(dst_reg, -kSystemPointerSize));
bdnz(&loop);
// Leave current frame.
......@@ -1233,7 +1236,7 @@ void MacroAssembler::CheckDebugHook(Register fun, Register new_target,
{
// Load receiver to pass it later to DebugOnFunctionCall hook.
ShiftLeftImm(r7, actual_parameter_count, Operand(kPointerSizeLog2));
ShiftLeftImm(r7, actual_parameter_count, Operand(kSystemPointerSizeLog2));
LoadPX(r7, MemOperand(sp, r7));
FrameScope frame(this,
has_frame() ? StackFrame::NONE : StackFrame::INTERNAL);
......@@ -1352,8 +1355,8 @@ void MacroAssembler::MaybeDropFrames() {
void MacroAssembler::PushStackHandler() {
// Adjust this code if not the case.
STATIC_ASSERT(StackHandlerConstants::kSize == 2 * kPointerSize);
STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0 * kPointerSize);
STATIC_ASSERT(StackHandlerConstants::kSize == 2 * kSystemPointerSize);
STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0 * kSystemPointerSize);
Push(Smi::zero()); // Padding.
......@@ -1369,7 +1372,7 @@ void MacroAssembler::PushStackHandler() {
}
void MacroAssembler::PopStackHandler() {
STATIC_ASSERT(StackHandlerConstants::kSize == 2 * kPointerSize);
STATIC_ASSERT(StackHandlerConstants::kSize == 2 * kSystemPointerSize);
STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
pop(r4);
......@@ -1821,15 +1824,16 @@ void TurboAssembler::PrepareCallCFunction(int num_reg_arguments,
CalculateStackPassedWords(num_reg_arguments, num_double_arguments);
int stack_space = kNumRequiredStackFrameSlots;
if (frame_alignment > kPointerSize) {
if (frame_alignment > kSystemPointerSize) {
// Make stack end at alignment and make room for stack arguments
// -- preserving original value of sp.
mr(scratch, sp);
addi(sp, sp, Operand(-(stack_passed_arguments + 1) * kPointerSize));
addi(sp, sp, Operand(-(stack_passed_arguments + 1) * kSystemPointerSize));
DCHECK(base::bits::IsPowerOfTwo(frame_alignment));
ClearRightImm(sp, sp,
Operand(base::bits::WhichPowerOfTwo(frame_alignment)));
StoreP(scratch, MemOperand(sp, stack_passed_arguments * kPointerSize));
StoreP(scratch,
MemOperand(sp, stack_passed_arguments * kSystemPointerSize));
} else {
// Make room for stack arguments
stack_space += stack_passed_arguments;
......@@ -1837,7 +1841,7 @@ void TurboAssembler::PrepareCallCFunction(int num_reg_arguments,
// Allocate frame with required slots to make ABI work.
li(r0, Operand::Zero());
StorePU(r0, MemOperand(sp, -stack_space * kPointerSize));
StorePU(r0, MemOperand(sp, -stack_space * kSystemPointerSize));
}
void TurboAssembler::PrepareCallCFunction(int num_reg_arguments,
......@@ -1931,7 +1935,8 @@ void TurboAssembler::CallCFunctionHelper(Register function,
if (ABI_USES_FUNCTION_DESCRIPTORS && has_function_descriptor) {
// AIX/PPC64BE Linux uses a function descriptor. When calling C code be
// aware of this descriptor and pick up values from it
LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(function, kPointerSize));
LoadP(ToRegister(ABI_TOC_REGISTER),
MemOperand(function, kSystemPointerSize));
LoadP(ip, MemOperand(function, 0));
dest = ip;
} else if (ABI_CALL_VIA_IP) {
......@@ -1963,10 +1968,10 @@ void TurboAssembler::CallCFunctionHelper(Register function,
int stack_passed_arguments =
CalculateStackPassedWords(num_reg_arguments, num_double_arguments);
int stack_space = kNumRequiredStackFrameSlots + stack_passed_arguments;
if (ActivationFrameAlignment() > kPointerSize) {
LoadP(sp, MemOperand(sp, stack_space * kPointerSize));
if (ActivationFrameAlignment() > kSystemPointerSize) {
LoadP(sp, MemOperand(sp, stack_space * kSystemPointerSize));
} else {
addi(sp, sp, Operand(stack_space * kPointerSize));
addi(sp, sp, Operand(stack_space * kSystemPointerSize));
}
}
......@@ -2996,7 +3001,7 @@ void TurboAssembler::StoreReturnAddressAndCall(Register target) {
if (ABI_USES_FUNCTION_DESCRIPTORS) {
// AIX/PPC64BE Linux uses a function descriptor. When calling C code be
// aware of this descriptor and pick up values from it
LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(target, kPointerSize));
LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(target, kSystemPointerSize));
LoadP(ip, MemOperand(target, 0));
dest = ip;
} else if (ABI_CALL_VIA_IP && dest != ip) {
......@@ -3007,7 +3012,7 @@ void TurboAssembler::StoreReturnAddressAndCall(Register target) {
LoadPC(r7);
bind(&start_call);
addi(r7, r7, Operand(after_call_offset));
StoreP(r7, MemOperand(sp, kStackFrameExtraParamSlot * kPointerSize));
StoreP(r7, MemOperand(sp, kStackFrameExtraParamSlot * kSystemPointerSize));
Call(dest);
DCHECK_EQ(after_call_offset - kInstrSize,
......
src/codegen/ppc/macro-assembler-ppc.h
View file @ a3fbabc7
......@@ -196,33 +196,33 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
// Push two registers. Pushes leftmost register first (to highest address).
void Push(Register src1, Register src2) {
StorePU(src2, MemOperand(sp, -2 * kPointerSize));
StoreP(src1, MemOperand(sp, kPointerSize));
StorePU(src2, MemOperand(sp, -2 * kSystemPointerSize));
StoreP(src1, MemOperand(sp, kSystemPointerSize));
}
// Push three registers. Pushes leftmost register first (to highest address).
void Push(Register src1, Register src2, Register src3) {
StorePU(src3, MemOperand(sp, -3 * kPointerSize));
StoreP(src2, MemOperand(sp, kPointerSize));
StoreP(src1, MemOperand(sp, 2 * kPointerSize));
StorePU(src3, MemOperand(sp, -3 * kSystemPointerSize));
StoreP(src2, MemOperand(sp, kSystemPointerSize));
StoreP(src1, MemOperand(sp, 2 * kSystemPointerSize));
}
// Push four registers. Pushes leftmost register first (to highest address).
void Push(Register src1, Register src2, Register src3, Register src4) {
StorePU(src4, MemOperand(sp, -4 * kPointerSize));
StoreP(src3, MemOperand(sp, kPointerSize));
StoreP(src2, MemOperand(sp, 2 * kPointerSize));
StoreP(src1, MemOperand(sp, 3 * kPointerSize));
StorePU(src4, MemOperand(sp, -4 * kSystemPointerSize));
StoreP(src3, MemOperand(sp, kSystemPointerSize));
StoreP(src2, MemOperand(sp, 2 * kSystemPointerSize));
StoreP(src1, MemOperand(sp, 3 * kSystemPointerSize));
}
// Push five registers. Pushes leftmost register first (to highest address).
void Push(Register src1, Register src2, Register src3, Register src4,
Register src5) {
StorePU(src5, MemOperand(sp, -5 * kPointerSize));
StoreP(src4, MemOperand(sp, kPointerSize));
StoreP(src3, MemOperand(sp, 2 * kPointerSize));
StoreP(src2, MemOperand(sp, 3 * kPointerSize));
StoreP(src1, MemOperand(sp, 4 * kPointerSize));
StorePU(src5, MemOperand(sp, -5 * kSystemPointerSize));
StoreP(src4, MemOperand(sp, kSystemPointerSize));
StoreP(src3, MemOperand(sp, 2 * kSystemPointerSize));
StoreP(src2, MemOperand(sp, 3 * kSystemPointerSize));
StoreP(src1, MemOperand(sp, 4 * kSystemPointerSize));
}
void Pop(Register dst) { pop(dst); }
......@@ -230,36 +230,36 @@ class V8_EXPORT_PRIVATE TurboAssembler : public TurboAssemblerBase {
// Pop two registers. Pops rightmost register first (from lower address).
void Pop(Register src1, Register src2) {
LoadP(src2, MemOperand(sp, 0));
LoadP(src1, MemOperand(sp, kPointerSize));
addi(sp, sp, Operand(2 * kPointerSize));
LoadP(src1, MemOperand(sp, kSystemPointerSize));
addi(sp, sp, Operand(2 * kSystemPointerSize));
}
// Pop three registers. Pops rightmost register first (from lower address).
void Pop(Register src1, Register src2, Register src3) {
LoadP(src3, MemOperand(sp, 0));
LoadP(src2, MemOperand(sp, kPointerSize));
LoadP(src1, MemOperand(sp, 2 * kPointerSize));
addi(sp, sp, Operand(3 * kPointerSize));
LoadP(src2, MemOperand(sp, kSystemPointerSize));
LoadP(src1, MemOperand(sp, 2 * kSystemPointerSize));
addi(sp, sp, Operand(3 * kSystemPointerSize));
}
// Pop four registers. Pops rightmost register first (from lower address).
void Pop(Register src1, Register src2, Register src3, Register src4) {
LoadP(src4, MemOperand(sp, 0));
LoadP(src3, MemOperand(sp, kPointerSize));
LoadP(src2, MemOperand(sp, 2 * kPointerSize));
LoadP(src1, MemOperand(sp, 3 * kPointerSize));
addi(sp, sp, Operand(4 * kPointerSize));
LoadP(src3, MemOperand(sp, kSystemPointerSize));
LoadP(src2, MemOperand(sp, 2 * kSystemPointerSize));
LoadP(src1, MemOperand(sp, 3 * kSystemPointerSize));
addi(sp, sp, Operand(4 * kSystemPointerSize));
}
// Pop five registers. Pops rightmost register first (from lower address).
void Pop(Register src1, Register src2, Register src3, Register src4,
Register src5) {
LoadP(src5, MemOperand(sp, 0));
LoadP(src4, MemOperand(sp, kPointerSize));
LoadP(src3, MemOperand(sp, 2 * kPointerSize));
LoadP(src2, MemOperand(sp, 3 * kPointerSize));
LoadP(src1, MemOperand(sp, 4 * kPointerSize));
addi(sp, sp, Operand(5 * kPointerSize));
LoadP(src4, MemOperand(sp, kSystemPointerSize));
LoadP(src3, MemOperand(sp, 2 * kSystemPointerSize));
LoadP(src2, MemOperand(sp, 3 * kSystemPointerSize));
LoadP(src1, MemOperand(sp, 4 * kSystemPointerSize));
addi(sp, sp, Operand(5 * kSystemPointerSize));
}
void SaveRegisters(RegList registers);
......@@ -893,11 +893,11 @@ class V8_EXPORT_PRIVATE MacroAssembler : public TurboAssembler {
void SmiToPtrArrayOffset(Register dst, Register src) {
#if defined(V8_COMPRESS_POINTERS) || defined(V8_31BIT_SMIS_ON_64BIT_ARCH)
STATIC_ASSERT(kSmiTag == 0 && kSmiShift < kPointerSizeLog2);
ShiftLeftImm(dst, src, Operand(kPointerSizeLog2 - kSmiShift));
STATIC_ASSERT(kSmiTag == 0 && kSmiShift < kSystemPointerSizeLog2);
ShiftLeftImm(dst, src, Operand(kSystemPointerSizeLog2 - kSmiShift));
#else
STATIC_ASSERT(kSmiTag == 0 && kSmiShift > kPointerSizeLog2);
ShiftRightArithImm(dst, src, kSmiShift - kPointerSizeLog2);
STATIC_ASSERT(kSmiTag == 0 && kSmiShift > kSystemPointerSizeLog2);
ShiftRightArithImm(dst, src, kSmiShift - kSystemPointerSizeLog2);
#endif
}
......@@ -918,7 +918,7 @@ class V8_EXPORT_PRIVATE MacroAssembler : public TurboAssembler {
STATIC_ASSERT(kSmiTagSize + kSmiShiftSize == 32);
#endif
#if V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN
#define SmiWordOffset(offset) (offset + kPointerSize / 2)
#define SmiWordOffset(offset) (offset + kSystemPointerSize / 2)
#else
#define SmiWordOffset(offset) offset
#endif
......
src/deoptimizer/ppc/deoptimizer-ppc.cc
View file @ a3fbabc7
......@@ -45,10 +45,10 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
// Push saved_regs (needed to populate FrameDescription::registers_).
// Leave gaps for other registers.
__ subi(sp, sp, Operand(kNumberOfRegisters * kPointerSize));
__ subi(sp, sp, Operand(kNumberOfRegisters * kSystemPointerSize));
for (int16_t i = kNumberOfRegisters - 1; i >= 0; i--) {
if ((saved_regs & (1 << i)) != 0) {
__ StoreP(ToRegister(i), MemOperand(sp, kPointerSize * i));
__ StoreP(ToRegister(i), MemOperand(sp, kSystemPointerSize * i));
}
}
{
......@@ -59,7 +59,7 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
__ StoreP(fp, MemOperand(scratch));
}
const int kSavedRegistersAreaSize =
(kNumberOfRegisters * kPointerSize) + kDoubleRegsSize;
(kNumberOfRegisters * kSystemPointerSize) + kDoubleRegsSize;
// Get the bailout id is passed as r29 by the caller.
__ mr(r5, r29);
......@@ -98,8 +98,9 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
// Copy core registers into FrameDescription::registers_[kNumRegisters].
DCHECK_EQ(Register::kNumRegisters, kNumberOfRegisters);
for (int i = 0; i < kNumberOfRegisters; i++) {
int offset = (i * kPointerSize) + FrameDescription::registers_offset();
__ LoadP(r5, MemOperand(sp, i * kPointerSize));
int offset =
(i * kSystemPointerSize) + FrameDescription::registers_offset();
__ LoadP(r5, MemOperand(sp, i * kSystemPointerSize));
__ StoreP(r5, MemOperand(r4, offset));
}
......@@ -109,7 +110,8 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
for (int i = 0; i < config->num_allocatable_double_registers(); ++i) {
int code = config->GetAllocatableDoubleCode(i);
int dst_offset = code * kDoubleSize + double_regs_offset;
int src_offset = code * kDoubleSize + kNumberOfRegisters * kPointerSize;
int src_offset =
code * kDoubleSize + kNumberOfRegisters * kSystemPointerSize;
__ lfd(d0, MemOperand(sp, src_offset));
__ stfd(d0, MemOperand(r4, dst_offset));
}
......@@ -143,7 +145,7 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
__ bind(&pop_loop);
__ pop(r7);
__ StoreP(r7, MemOperand(r6, 0));
__ addi(r6, r6, Operand(kPointerSize));
__ addi(r6, r6, Operand(kSystemPointerSize));
__ bind(&pop_loop_header);
__ cmp(r5, sp);
__ bne(&pop_loop);
......@@ -167,7 +169,7 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
// r4 = one past the last FrameDescription**.
__ lwz(r4, MemOperand(r3, Deoptimizer::output_count_offset()));
__ LoadP(r7, MemOperand(r3, Deoptimizer::output_offset())); // r7 is output_.
__ ShiftLeftImm(r4, r4, Operand(kPointerSizeLog2));
__ ShiftLeftImm(r4, r4, Operand(kSystemPointerSizeLog2));
__ add(r4, r7, r4);
__ b(&outer_loop_header);
......@@ -187,7 +189,7 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
__ cmpi(r6, Operand::Zero());
__ bne(&inner_push_loop); // test for gt?
__ addi(r7, r7, Operand(kPointerSize));
__ addi(r7, r7, Operand(kSystemPointerSize));
__ bind(&outer_loop_header);
__ cmp(r7, r4);
__ blt(&outer_push_loop);
......@@ -213,7 +215,8 @@ void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
DCHECK(!(scratch.bit() & restored_regs));
__ mr(scratch, r5);
for (int i = kNumberOfRegisters - 1; i >= 0; i--) {
int offset = (i * kPointerSize) + FrameDescription::registers_offset();
int offset =
(i * kSystemPointerSize) + FrameDescription::registers_offset();
if ((restored_regs & (1 << i)) != 0) {
__ LoadP(ToRegister(i), MemOperand(scratch, offset));
}
......
src/execution/ppc/frame-constants-ppc.h
View file @ a3fbabc7
......@@ -15,7 +15,7 @@ namespace internal {
class EntryFrameConstants : public AllStatic {
public:
static constexpr int kCallerFPOffset =
-(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize);
-(StandardFrameConstants::kFixedFrameSizeFromFp + kSystemPointerSize);
};
class WasmCompileLazyFrameConstants : public TypedFrameConstants {
......@@ -27,7 +27,7 @@ class WasmCompileLazyFrameConstants : public TypedFrameConstants {
static constexpr int kWasmInstanceOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(0);
static constexpr int kFixedFrameSizeFromFp =
TypedFrameConstants::kFixedFrameSizeFromFp +
kNumberOfSavedGpParamRegs * kPointerSize +
kNumberOfSavedGpParamRegs * kSystemPointerSize +
kNumberOfSavedFpParamRegs * kDoubleSize;
};
......
src/execution/ppc/simulator-ppc.cc
View file @ a3fbabc7
......@@ -481,7 +481,7 @@ void PPCDebugger::Debug() {
PrintF("FPSCR: %08x\n", sim_->fp_condition_reg_);
} else if (strcmp(cmd, "stop") == 0) {
intptr_t value;
intptr_t stop_pc = sim_->get_pc() - (kInstrSize + kPointerSize);
intptr_t stop_pc = sim_->get_pc() - (kInstrSize + kSystemPointerSize);
Instruction* stop_instr = reinterpret_cast<Instruction*>(stop_pc);
Instruction* msg_address =
reinterpret_cast<Instruction*>(stop_pc + kInstrSize);
......@@ -1230,7 +1230,7 @@ void Simulator::SoftwareInterrupt(Instruction* instr) {
}
DebugAtNextPC();
} else {
set_pc(get_pc() + kInstrSize + kPointerSize);
set_pc(get_pc() + kInstrSize + kSystemPointerSize);
}
} else {
// This is not a valid svc code.
......
src/execution/ppc/simulator-ppc.h
View file @ a3fbabc7
......@@ -344,7 +344,7 @@ class Simulator : public SimulatorBase {
// Simulator support.
char* stack_;
static const size_t stack_protection_size_ = 256 * kPointerSize;
static const size_t stack_protection_size_ = 256 * kSystemPointerSize;
bool pc_modified_;
int icount_;
......
src/regexp/ppc/regexp-macro-assembler-ppc.cc
View file @ a3fbabc7
......@@ -235,7 +235,7 @@ void RegExpMacroAssemblerPPC::CheckGreedyLoop(Label* on_equal) {
__ cmp(current_input_offset(), r3);
__ bne(&backtrack_non_equal);
__ addi(backtrack_stackpointer(), backtrack_stackpointer(),
Operand(kPointerSize));
Operand(kSystemPointerSize));
__ bind(&backtrack_non_equal);
BranchOrBacktrack(eq, on_equal);
......@@ -687,7 +687,7 @@ Handle<HeapObject> RegExpMacroAssemblerPPC::GetCode(Handle<String> source) {
__ MultiPush(argument_registers | registers_to_retain);
// Set frame pointer in space for it if this is not a direct call
// from generated code.
__ addi(frame_pointer(), sp, Operand(8 * kPointerSize));
__ addi(frame_pointer(), sp, Operand(8 * kSystemPointerSize));
STATIC_ASSERT(kSuccessfulCaptures == kInputString - kSystemPointerSize);
__ li(r3, Operand::Zero());
......@@ -711,7 +711,7 @@ Handle<HeapObject> RegExpMacroAssemblerPPC::GetCode(Handle<String> source) {
__ ble(&stack_limit_hit, cr0);
// Check if there is room for the variable number of registers above
// the stack limit.
__ Cmpli(r3, Operand(num_registers_ * kPointerSize), r0);
__ Cmpli(r3, Operand(num_registers_ * kSystemPointerSize), r0);
__ bge(&stack_ok);
// Exit with OutOfMemory exception. There is not enough space on the stack
// for our working registers.
......@@ -727,7 +727,7 @@ Handle<HeapObject> RegExpMacroAssemblerPPC::GetCode(Handle<String> source) {
__ bind(&stack_ok);
// Allocate space on stack for registers.
__ Add(sp, sp, -num_registers_ * kPointerSize, r0);
__ Add(sp, sp, -num_registers_ * kSystemPointerSize, r0);
// Load string end.
__ LoadP(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd));
// Load input start.
......@@ -769,12 +769,13 @@ Handle<HeapObject> RegExpMacroAssemblerPPC::GetCode(Handle<String> source) {
// Fill saved registers with initial value = start offset - 1
if (num_saved_registers_ > 8) {
// One slot beyond address of register 0.
__ addi(r4, frame_pointer(), Operand(kRegisterZero + kPointerSize));
__ addi(r4, frame_pointer(),
Operand(kRegisterZero + kSystemPointerSize));
__ mov(r5, Operand(num_saved_registers_));
__ mtctr(r5);
Label init_loop;
__ bind(&init_loop);
__ StorePU(r3, MemOperand(r4, -kPointerSize));
__ StorePU(r3, MemOperand(r4, -kSystemPointerSize));
__ bdnz(&init_loop);
} else {
for (int i = 0; i < num_saved_registers_; i++) {
......@@ -1103,15 +1104,17 @@ void RegExpMacroAssemblerPPC::CallCheckStackGuardState(Register scratch) {
// The following stack manipulation logic is similar to
// PrepareCallCFunction. However, we need an extra slot on the
// stack to house the return address parameter.
if (frame_alignment > kPointerSize) {
if (frame_alignment > kSystemPointerSize) {
// Make stack end at alignment and make room for stack arguments
// -- preserving original value of sp.
__ mr(scratch, sp);
__ addi(sp, sp, Operand(-(stack_passed_arguments + 1) * kPointerSize));
__ addi(sp, sp,
Operand(-(stack_passed_arguments + 1) * kSystemPointerSize));
DCHECK(base::bits::IsPowerOfTwo(frame_alignment));
__ ClearRightImm(sp, sp,
Operand(base::bits::WhichPowerOfTwo(frame_alignment)));
__ StoreP(scratch, MemOperand(sp, stack_passed_arguments * kPointerSize));
__ StoreP(scratch,
MemOperand(sp, stack_passed_arguments * kSystemPointerSize));
} else {
// Make room for stack arguments
stack_space += stack_passed_arguments;
......@@ -1119,14 +1122,14 @@ void RegExpMacroAssemblerPPC::CallCheckStackGuardState(Register scratch) {
// Allocate frame with required slots to make ABI work.
__ li(r0, Operand::Zero());
__ StorePU(r0, MemOperand(sp, -stack_space * kPointerSize));
__ StorePU(r0, MemOperand(sp, -stack_space * kSystemPointerSize));
// RegExp code frame pointer.
__ mr(r5, frame_pointer());
// Code of self.
__ mov(r4, Operand(masm_->CodeObject()));
// r3 will point to the return address, placed by DirectCEntry.
__ addi(r3, sp, Operand(kStackFrameExtraParamSlot * kPointerSize));
__ addi(r3, sp, Operand(kStackFrameExtraParamSlot * kSystemPointerSize));
ExternalReference stack_guard_check =
ExternalReference::re_check_stack_guard_state(isolate());
......@@ -1140,10 +1143,10 @@ void RegExpMacroAssemblerPPC::CallCheckStackGuardState(Register scratch) {
// Restore the stack pointer
stack_space = kNumRequiredStackFrameSlots + stack_passed_arguments;
if (frame_alignment > kPointerSize) {
__ LoadP(sp, MemOperand(sp, stack_space * kPointerSize));
if (frame_alignment > kSystemPointerSize) {
__ LoadP(sp, MemOperand(sp, stack_space * kSystemPointerSize));
} else {
__ addi(sp, sp, Operand(stack_space * kPointerSize));
__ addi(sp, sp, Operand(stack_space * kSystemPointerSize));
}
__ mov(code_pointer(), Operand(masm_->CodeObject()));
......@@ -1184,7 +1187,7 @@ MemOperand RegExpMacroAssemblerPPC::register_location(int register_index) {
num_registers_ = register_index + 1;
}
return MemOperand(frame_pointer(),
kRegisterZero - register_index * kPointerSize);
kRegisterZero - register_index * kSystemPointerSize);
}
......@@ -1246,7 +1249,7 @@ void RegExpMacroAssemblerPPC::SafeCallTarget(Label* name) {
void RegExpMacroAssemblerPPC::Push(Register source) {
DCHECK(source != backtrack_stackpointer());
__ StorePU(source, MemOperand(backtrack_stackpointer(), -kPointerSize));
__ StorePU(source, MemOperand(backtrack_stackpointer(), -kSystemPointerSize));
}
......@@ -1254,7 +1257,7 @@ void RegExpMacroAssemblerPPC::Pop(Register target) {
DCHECK(target != backtrack_stackpointer());
__ LoadP(target, MemOperand(backtrack_stackpointer()));
__ addi(backtrack_stackpointer(), backtrack_stackpointer(),
Operand(kPointerSize));
Operand(kSystemPointerSize));
}
......
src/regexp/ppc/regexp-macro-assembler-ppc.h
View file @ a3fbabc7
......@@ -91,26 +91,27 @@ class V8_EXPORT_PRIVATE RegExpMacroAssemblerPPC
// Register 25..31.
static const int kStoredRegisters = kFramePointer;
// Return address (stored from link register, read into pc on return).
static const int kReturnAddress = kStoredRegisters + 7 * kPointerSize;
static const int kCallerFrame = kReturnAddress + kPointerSize;
static const int kReturnAddress = kStoredRegisters + 7 * kSystemPointerSize;
static const int kCallerFrame = kReturnAddress + kSystemPointerSize;
// Stack parameters placed by caller.
static const int kIsolate =
kCallerFrame + kStackFrameExtraParamSlot * kPointerSize;
kCallerFrame + kStackFrameExtraParamSlot * kSystemPointerSize;
// Below the frame pointer.
// Register parameters stored by setup code.
static const int kDirectCall = kFramePointer - kPointerSize;
static const int kStackHighEnd = kDirectCall - kPointerSize;
static const int kNumOutputRegisters = kStackHighEnd - kPointerSize;
static const int kRegisterOutput = kNumOutputRegisters - kPointerSize;
static const int kInputEnd = kRegisterOutput - kPointerSize;
static const int kInputStart = kInputEnd - kPointerSize;
static const int kStartIndex = kInputStart - kPointerSize;
static const int kInputString = kStartIndex - kPointerSize;
static const int kDirectCall = kFramePointer - kSystemPointerSize;
static const int kStackHighEnd = kDirectCall - kSystemPointerSize;
static const int kNumOutputRegisters = kStackHighEnd - kSystemPointerSize;
static const int kRegisterOutput = kNumOutputRegisters - kSystemPointerSize;
static const int kInputEnd = kRegisterOutput - kSystemPointerSize;
static const int kInputStart = kInputEnd - kSystemPointerSize;
static const int kStartIndex = kInputStart - kSystemPointerSize;
static const int kInputString = kStartIndex - kSystemPointerSize;
// When adding local variables remember to push space for them in
// the frame in GetCode.
static const int kSuccessfulCaptures = kInputString - kPointerSize;
static const int kStringStartMinusOne = kSuccessfulCaptures - kPointerSize;
static const int kSuccessfulCaptures = kInputString - kSystemPointerSize;
static const int kStringStartMinusOne =
kSuccessfulCaptures - kSystemPointerSize;
static const int kBacktrackCount = kStringStartMinusOne - kSystemPointerSize;
// First register address. Following registers are below it on the stack.
static const int kRegisterZero = kBacktrackCount - kSystemPointerSize;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment