Skip to content

Commit 9dcd085

Browse files
expatdannoCommit bot
expatdanno
authored and
Commit bot
committed
[runtime] Unify and simplify how frames are marked
Before this CL, various code stubs used different techniques for marking their frames to enable stack-crawling and other access to data in the frame. All of them were based on a abuse of the "standard" frame representation, e.g. storing the a context pointer immediately below the frame's fp, and a function pointer after that. Although functional, this approach tends to make stubs and builtins do an awkward, unnecessary dance to appear like standard frames, even if they have nothing to do with JavaScript execution. This CL attempts to improve this by: * Ensuring that there are only two fundamentally different types of frames, a "standard" frame and a "typed" frame. Standard frames, as before, contain both a context and function pointer. Typed frames contain only a minimum of a smi marker in the position immediately below the fp where the context is in standard frames. * Only interpreted, full codegen, and optimized Crankshaft and TurboFan JavaScript frames use the "standard" format. All other frames use the type frame format with an explicit marker. * Typed frames can contain one or more values below the type marker. There is new magic macro machinery in frames.h that simplifies defining the offsets of these fields in typed frames. * A new flag in the CallDescriptor enables specifying whether a frame is a standard frame or a typed frame. Secondary register location spilling is now only enabled for standard frames. * A zillion places in the code have been updated to deal with the fact that most code stubs and internal frames use the typed frame format. This includes changes in the deoptimizer, debugger, and liveedit. * StandardFrameConstants::kMarkerOffset is deprecated, (CommonFrameConstants::kContextOrFrameTypeOffset and StandardFrameConstants::kFrameOffset are now used in its stead). LOG=N Review URL: https://codereview.chromium.org/1696043002 Cr-Commit-Position: refs/heads/master@{#34571}
1 parent 059c163 commit 9dcd085

80 files changed

Lines changed: 1130 additions & 754 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎src/arm/builtins-arm.cc‎

Lines changed: 10 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -531,6 +531,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
531531
// -- r1 : constructor function
532532
// -- r2 : allocation site or undefined
533533
// -- r3 : new target
534+
// -- cp : context
534535
// -- lr : return address
535536
// -- sp[...]: constructor arguments
536537
// -----------------------------------
@@ -543,6 +544,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
543544

544545
// Preserve the incoming parameters on the stack.
545546
__ AssertUndefinedOrAllocationSite(r2, r4);
547+
__ Push(cp);
546548
__ SmiTag(r0);
547549
__ Push(r2, r0);
548550

@@ -622,7 +624,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm,
622624
// r0: result
623625
// sp[0]: receiver
624626
// sp[1]: number of arguments (smi-tagged)
625-
__ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
627+
__ ldr(cp, MemOperand(fp, ConstructFrameConstants::kContextOffset));
626628

627629
if (create_implicit_receiver) {
628630
// If the result is an object (in the ECMA sense), we should get rid
@@ -751,9 +753,6 @@ static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
751753
// r5-r6, r8 (if !FLAG_enable_embedded_constant_pool) and cp may be clobbered
752754
ProfileEntryHookStub::MaybeCallEntryHook(masm);
753755

754-
// Clear the context before we push it when entering the internal frame.
755-
__ mov(cp, Operand::Zero());
756-
757756
// Enter an internal frame.
758757
{
759758
FrameScope scope(masm, StackFrame::INTERNAL);
@@ -855,8 +854,7 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
855854
// MANUAL indicates that the scope shouldn't actually generate code to set up
856855
// the frame (that is done below).
857856
FrameScope frame_scope(masm, StackFrame::MANUAL);
858-
__ PushFixedFrame(r1);
859-
__ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
857+
__ PushStandardFrame(r1);
860858

861859
// Get the bytecode array from the function object and load the pointer to the
862860
// first entry into kInterpreterBytecodeRegister.
@@ -1192,8 +1190,7 @@ void Builtins::Generate_MarkCodeAsExecutedOnce(MacroAssembler* masm) {
11921190
__ ldm(ia_w, sp, r0.bit() | r1.bit() | r3.bit() | fp.bit() | lr.bit());
11931191

11941192
// Perform prologue operations usually performed by the young code stub.
1195-
__ PushFixedFrame(r1);
1196-
__ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
1193+
__ PushStandardFrame(r1);
11971194

11981195
// Jump to point after the code-age stub.
11991196
__ add(r0, r0, Operand(kNoCodeAgeSequenceLength));
@@ -1945,7 +1942,8 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
19451942
// Drop possible interpreter handler/stub frame.
19461943
{
19471944
Label no_interpreter_frame;
1948-
__ ldr(scratch3, MemOperand(fp, StandardFrameConstants::kMarkerOffset));
1945+
__ ldr(scratch3,
1946+
MemOperand(fp, CommonFrameConstants::kContextOrFrameTypeOffset));
19491947
__ cmp(scratch3, Operand(Smi::FromInt(StackFrame::STUB)));
19501948
__ b(ne, &no_interpreter_frame);
19511949
__ ldr(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
@@ -1957,7 +1955,7 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
19571955
Label no_arguments_adaptor, formal_parameter_count_loaded;
19581956
__ ldr(scratch2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
19591957
__ ldr(scratch3,
1960-
MemOperand(scratch2, StandardFrameConstants::kContextOffset));
1958+
MemOperand(scratch2, CommonFrameConstants::kContextOrFrameTypeOffset));
19611959
__ cmp(scratch3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
19621960
__ b(ne, &no_arguments_adaptor);
19631961

@@ -1970,7 +1968,8 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
19701968

19711969
__ bind(&no_arguments_adaptor);
19721970
// Load caller's formal parameter count
1973-
__ ldr(scratch1, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
1971+
__ ldr(scratch1,
1972+
MemOperand(fp, ArgumentsAdaptorFrameConstants::kFunctionOffset));
19741973
__ ldr(scratch1,
19751974
FieldMemOperand(scratch1, JSFunction::kSharedFunctionInfoOffset));
19761975
__ ldr(caller_args_count_reg,

‎src/arm/code-stubs-arm.cc‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3692,7 +3692,7 @@ void StubFailureTrampolineStub::Generate(MacroAssembler* masm) {
36923692
CEntryStub ces(isolate(), 1, kSaveFPRegs);
36933693
__ Call(ces.GetCode(), RelocInfo::CODE_TARGET);
36943694
int parameter_count_offset =
3695-
StubFailureTrampolineFrame::kCallerStackParameterCountFrameOffset;
3695+
StubFailureTrampolineFrameConstants::kArgumentsLengthOffset;
36963696
__ ldr(r1, MemOperand(fp, parameter_count_offset));
36973697
if (function_mode() == JS_FUNCTION_STUB_MODE) {
36983698
__ add(r1, r1, Operand(1));
@@ -4685,7 +4685,7 @@ void FastNewRestParameterStub::Generate(MacroAssembler* masm) {
46854685
__ bind(&loop);
46864686
__ ldr(r2, MemOperand(r2, StandardFrameConstants::kCallerFPOffset));
46874687
__ bind(&loop_entry);
4688-
__ ldr(ip, MemOperand(r2, StandardFrameConstants::kMarkerOffset));
4688+
__ ldr(ip, MemOperand(r2, StandardFrameConstants::kFunctionOffset));
46894689
__ cmp(ip, r1);
46904690
__ b(ne, &loop);
46914691
}
@@ -4694,7 +4694,7 @@ void FastNewRestParameterStub::Generate(MacroAssembler* masm) {
46944694
// arguments adaptor frame below the function frame).
46954695
Label no_rest_parameters;
46964696
__ ldr(r2, MemOperand(r2, StandardFrameConstants::kCallerFPOffset));
4697-
__ ldr(ip, MemOperand(r2, StandardFrameConstants::kContextOffset));
4697+
__ ldr(ip, MemOperand(r2, CommonFrameConstants::kContextOrFrameTypeOffset));
46984698
__ cmp(ip, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
46994699
__ b(ne, &no_rest_parameters);
47004700

@@ -4833,7 +4833,7 @@ void FastNewSloppyArgumentsStub::Generate(MacroAssembler* masm) {
48334833
// Check if the calling frame is an arguments adaptor frame.
48344834
Label adaptor_frame, try_allocate, runtime;
48354835
__ ldr(r4, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
4836-
__ ldr(r0, MemOperand(r4, StandardFrameConstants::kContextOffset));
4836+
__ ldr(r0, MemOperand(r4, CommonFrameConstants::kContextOrFrameTypeOffset));
48374837
__ cmp(r0, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
48384838
__ b(eq, &adaptor_frame);
48394839

@@ -5032,15 +5032,15 @@ void FastNewStrictArgumentsStub::Generate(MacroAssembler* masm) {
50325032
__ bind(&loop);
50335033
__ ldr(r2, MemOperand(r2, StandardFrameConstants::kCallerFPOffset));
50345034
__ bind(&loop_entry);
5035-
__ ldr(ip, MemOperand(r2, StandardFrameConstants::kMarkerOffset));
5035+
__ ldr(ip, MemOperand(r2, StandardFrameConstants::kFunctionOffset));
50365036
__ cmp(ip, r1);
50375037
__ b(ne, &loop);
50385038
}
50395039

50405040
// Check if we have an arguments adaptor frame below the function frame.
50415041
Label arguments_adaptor, arguments_done;
50425042
__ ldr(r3, MemOperand(r2, StandardFrameConstants::kCallerFPOffset));
5043-
__ ldr(ip, MemOperand(r3, StandardFrameConstants::kContextOffset));
5043+
__ ldr(ip, MemOperand(r3, CommonFrameConstants::kContextOrFrameTypeOffset));
50445044
__ cmp(ip, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
50455045
__ b(eq, &arguments_adaptor);
50465046
{

‎src/arm/codegen-arm.cc‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -898,10 +898,8 @@ CodeAgingHelper::CodeAgingHelper(Isolate* isolate) {
898898
young_sequence_.length() / Assembler::kInstrSize,
899899
CodePatcher::DONT_FLUSH));
900900
PredictableCodeSizeScope scope(patcher->masm(), young_sequence_.length());
901-
patcher->masm()->PushFixedFrame(r1);
901+
patcher->masm()->PushStandardFrame(r1);
902902
patcher->masm()->nop(ip.code());
903-
patcher->masm()->add(
904-
fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
905903
}
906904

907905

‎src/arm/deoptimizer-arm.cc‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -156,7 +156,12 @@ void Deoptimizer::TableEntryGenerator::Generate() {
156156
// Allocate a new deoptimizer object.
157157
// Pass four arguments in r0 to r3 and fifth argument on stack.
158158
__ PrepareCallCFunction(6, r5);
159+
__ mov(r0, Operand(0));
160+
Label context_check;
161+
__ ldr(r1, MemOperand(fp, CommonFrameConstants::kContextOrFrameTypeOffset));
162+
__ JumpIfSmi(r1, &context_check);
159163
__ ldr(r0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
164+
__ bind(&context_check);
160165
__ mov(r1, Operand(type())); // bailout type,
161166
// r2: bailout id already loaded.
162167
// r3: code address or 0 already loaded.

‎src/arm/frames-arm.h‎

Lines changed: 5 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -93,16 +93,11 @@ class EntryFrameConstants : public AllStatic {
9393
-(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize);
9494
};
9595

96-
97-
class ExitFrameConstants : public AllStatic {
96+
class ExitFrameConstants : public TypedFrameConstants {
9897
public:
99-
static const int kFrameSize =
100-
FLAG_enable_embedded_constant_pool ? 3 * kPointerSize : 2 * kPointerSize;
101-
102-
static const int kConstantPoolOffset =
103-
FLAG_enable_embedded_constant_pool ? -3 * kPointerSize : 0;
104-
static const int kCodeOffset = -2 * kPointerSize;
105-
static const int kSPOffset = -1 * kPointerSize;
98+
static const int kSPOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(0);
99+
static const int kCodeOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(1);
100+
DEFINE_TYPED_FRAME_SIZES(2);
106101

107102
// The caller fields are below the frame pointer on the stack.
108103
static const int kCallerFPOffset = 0 * kPointerSize;
@@ -120,7 +115,7 @@ class JavaScriptFrameConstants : public AllStatic {
120115
// FP-relative.
121116
static const int kLocal0Offset = StandardFrameConstants::kExpressionsOffset;
122117
static const int kLastParameterOffset = +2 * kPointerSize;
123-
static const int kFunctionOffset = StandardFrameConstants::kMarkerOffset;
118+
static const int kFunctionOffset = StandardFrameConstants::kFunctionOffset;
124119

125120
// Caller SP-relative.
126121
static const int kParam0Offset = -2 * kPointerSize;

‎src/arm/macro-assembler-arm.cc‎

Lines changed: 81 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -755,20 +755,65 @@ void MacroAssembler::RememberedSetHelper(Register object, // For debug tests.
755755
}
756756
}
757757

758-
759-
void MacroAssembler::PushFixedFrame(Register marker_reg) {
760-
DCHECK(!marker_reg.is_valid() || marker_reg.code() < cp.code());
761-
stm(db_w, sp, (marker_reg.is_valid() ? marker_reg.bit() : 0) | cp.bit() |
762-
(FLAG_enable_embedded_constant_pool ? pp.bit() : 0) |
763-
fp.bit() | lr.bit());
758+
void MacroAssembler::PushCommonFrame(Register marker_reg) {
759+
if (marker_reg.is_valid()) {
760+
if (FLAG_enable_embedded_constant_pool) {
761+
if (marker_reg.code() > pp.code()) {
762+
stm(db_w, sp, pp.bit() | fp.bit() | lr.bit());
763+
add(fp, sp, Operand(kPointerSize));
764+
Push(marker_reg);
765+
} else {
766+
stm(db_w, sp, marker_reg.bit() | pp.bit() | fp.bit() | lr.bit());
767+
add(fp, sp, Operand(2 * kPointerSize));
768+
}
769+
} else {
770+
if (marker_reg.code() > fp.code()) {
771+
stm(db_w, sp, fp.bit() | lr.bit());
772+
mov(fp, Operand(sp));
773+
Push(marker_reg);
774+
} else {
775+
stm(db_w, sp, marker_reg.bit() | fp.bit() | lr.bit());
776+
add(fp, sp, Operand(kPointerSize));
777+
}
778+
}
779+
} else {
780+
stm(db_w, sp, (FLAG_enable_embedded_constant_pool ? pp.bit() : 0) |
781+
fp.bit() | lr.bit());
782+
add(fp, sp, Operand(FLAG_enable_embedded_constant_pool ? kPointerSize : 0));
783+
}
764784
}
765785

786+
void MacroAssembler::PopCommonFrame(Register marker_reg) {
787+
if (marker_reg.is_valid()) {
788+
if (FLAG_enable_embedded_constant_pool) {
789+
if (marker_reg.code() > pp.code()) {
790+
pop(marker_reg);
791+
ldm(ia_w, sp, pp.bit() | fp.bit() | lr.bit());
792+
} else {
793+
ldm(ia_w, sp, marker_reg.bit() | pp.bit() | fp.bit() | lr.bit());
794+
}
795+
} else {
796+
if (marker_reg.code() > fp.code()) {
797+
pop(marker_reg);
798+
ldm(ia_w, sp, fp.bit() | lr.bit());
799+
} else {
800+
ldm(ia_w, sp, marker_reg.bit() | fp.bit() | lr.bit());
801+
}
802+
}
803+
} else {
804+
ldm(ia_w, sp, (FLAG_enable_embedded_constant_pool ? pp.bit() : 0) |
805+
fp.bit() | lr.bit());
806+
}
807+
}
766808

767-
void MacroAssembler::PopFixedFrame(Register marker_reg) {
768-
DCHECK(!marker_reg.is_valid() || marker_reg.code() < cp.code());
769-
ldm(ia_w, sp, (marker_reg.is_valid() ? marker_reg.bit() : 0) | cp.bit() |
809+
void MacroAssembler::PushStandardFrame(Register function_reg) {
810+
DCHECK(!function_reg.is_valid() || function_reg.code() < cp.code());
811+
stm(db_w, sp, (function_reg.is_valid() ? function_reg.bit() : 0) | cp.bit() |
770812
(FLAG_enable_embedded_constant_pool ? pp.bit() : 0) |
771813
fp.bit() | lr.bit());
814+
int offset = -StandardFrameConstants::kContextOffset;
815+
offset += function_reg.is_valid() ? kPointerSize : 0;
816+
add(fp, sp, Operand(offset));
772817
}
773818

774819

@@ -1116,19 +1161,15 @@ void MacroAssembler::LoadConstantPoolPointerRegister() {
11161161
LoadConstantPoolPointerRegisterFromCodeTargetAddress(ip);
11171162
}
11181163

1119-
1120-
void MacroAssembler::StubPrologue() {
1121-
PushFixedFrame();
1122-
Push(Smi::FromInt(StackFrame::STUB));
1123-
// Adjust FP to point to saved FP.
1124-
add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
1164+
void MacroAssembler::StubPrologue(StackFrame::Type type) {
1165+
mov(ip, Operand(Smi::FromInt(type)));
1166+
PushCommonFrame(ip);
11251167
if (FLAG_enable_embedded_constant_pool) {
11261168
LoadConstantPoolPointerRegister();
11271169
set_constant_pool_available(true);
11281170
}
11291171
}
11301172

1131-
11321173
void MacroAssembler::Prologue(bool code_pre_aging) {
11331174
{ PredictableCodeSizeScope predictible_code_size_scope(
11341175
this, kNoCodeAgeSequenceLength);
@@ -1141,10 +1182,8 @@ void MacroAssembler::Prologue(bool code_pre_aging) {
11411182
ldr(pc, MemOperand(pc, -4));
11421183
emit_code_stub_address(stub);
11431184
} else {
1144-
PushFixedFrame(r1);
1185+
PushStandardFrame(r1);
11451186
nop(ip.code());
1146-
// Adjust FP to point to saved FP.
1147-
add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
11481187
}
11491188
}
11501189
if (FLAG_enable_embedded_constant_pool) {
@@ -1165,17 +1204,15 @@ void MacroAssembler::EmitLoadTypeFeedbackVector(Register vector) {
11651204
void MacroAssembler::EnterFrame(StackFrame::Type type,
11661205
bool load_constant_pool_pointer_reg) {
11671206
// r0-r3: preserved
1168-
PushFixedFrame();
1207+
mov(ip, Operand(Smi::FromInt(type)));
1208+
PushCommonFrame(ip);
11691209
if (FLAG_enable_embedded_constant_pool && load_constant_pool_pointer_reg) {
11701210
LoadConstantPoolPointerRegister();
11711211
}
1172-
mov(ip, Operand(Smi::FromInt(type)));
1173-
push(ip);
1174-
mov(ip, Operand(CodeObject()));
1175-
push(ip);
1176-
// Adjust FP to point to saved FP.
1177-
add(fp, sp,
1178-
Operand(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize));
1212+
if (type == StackFrame::INTERNAL) {
1213+
mov(ip, Operand(CodeObject()));
1214+
push(ip);
1215+
}
11791216
}
11801217

11811218

@@ -1206,10 +1243,10 @@ void MacroAssembler::EnterExitFrame(bool save_doubles, int stack_space) {
12061243
DCHECK_EQ(2 * kPointerSize, ExitFrameConstants::kCallerSPDisplacement);
12071244
DCHECK_EQ(1 * kPointerSize, ExitFrameConstants::kCallerPCOffset);
12081245
DCHECK_EQ(0 * kPointerSize, ExitFrameConstants::kCallerFPOffset);
1209-
Push(lr, fp);
1210-
mov(fp, Operand(sp)); // Set up new frame pointer.
1246+
mov(ip, Operand(Smi::FromInt(StackFrame::EXIT)));
1247+
PushCommonFrame(ip);
12111248
// Reserve room for saved entry sp and code object.
1212-
sub(sp, sp, Operand(ExitFrameConstants::kFrameSize));
1249+
sub(sp, fp, Operand(ExitFrameConstants::kFixedFrameSizeFromFp));
12131250
if (emit_debug_code()) {
12141251
mov(ip, Operand::Zero());
12151252
str(ip, MemOperand(fp, ExitFrameConstants::kSPOffset));
@@ -1291,7 +1328,7 @@ void MacroAssembler::LeaveExitFrame(bool save_doubles, Register argument_count,
12911328
// Optionally restore all double registers.
12921329
if (save_doubles) {
12931330
// Calculate the stack location of the saved doubles and restore them.
1294-
const int offset = ExitFrameConstants::kFrameSize;
1331+
const int offset = ExitFrameConstants::kFixedFrameSizeFromFp;
12951332
sub(r3, fp,
12961333
Operand(offset + DwVfpRegister::kMaxNumRegisters * kDoubleSize));
12971334
RestoreFPRegs(r3, ip);
@@ -1678,8 +1715,19 @@ void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
16781715
DCHECK(!holder_reg.is(ip));
16791716
DCHECK(!scratch.is(ip));
16801717

1681-
// Load current lexical context from the stack frame.
1682-
ldr(scratch, MemOperand(fp, StandardFrameConstants::kContextOffset));
1718+
// Load current lexical context from the active StandardFrame, which
1719+
// may require crawling past STUB frames.
1720+
Label load_context;
1721+
Label has_context;
1722+
DCHECK(!ip.is(scratch));
1723+
mov(ip, fp);
1724+
bind(&load_context);
1725+
ldr(scratch, MemOperand(ip, CommonFrameConstants::kContextOrFrameTypeOffset));
1726+
JumpIfNotSmi(scratch, &has_context);
1727+
ldr(ip, MemOperand(ip, CommonFrameConstants::kCallerFPOffset));
1728+
b(&load_context);
1729+
bind(&has_context);
1730+
16831731
// In debug mode, make sure the lexical context is set.
16841732
#ifdef DEBUG
16851733
cmp(scratch, Operand::Zero());

‎src/arm/macro-assembler-arm.h‎

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -457,10 +457,14 @@ class MacroAssembler: public Assembler {
457457
}
458458

459459
// Push a fixed frame, consisting of lr, fp, constant pool (if
460-
// FLAG_enable_embedded_constant_pool), context and JS function / marker id if
461-
// marker_reg is a valid register.
462-
void PushFixedFrame(Register marker_reg = no_reg);
463-
void PopFixedFrame(Register marker_reg = no_reg);
460+
// FLAG_enable_embedded_constant_pool)
461+
void PushCommonFrame(Register marker_reg = no_reg);
462+
463+
// Push a standard frame, consisting of lr, fp, constant pool (if
464+
// FLAG_enable_embedded_constant_pool), context and JS function
465+
void PushStandardFrame(Register function_reg);
466+
467+
void PopCommonFrame(Register marker_reg = no_reg);
464468

465469
// Push and pop the registers that can hold pointers, as defined by the
466470
// RegList constant kSafepointSavedRegisters.
@@ -585,7 +589,7 @@ class MacroAssembler: public Assembler {
585589
Label* not_int32);
586590

587591
// Generates function and stub prologue code.
588-
void StubPrologue();
592+
void StubPrologue(StackFrame::Type type);
589593
void Prologue(bool code_pre_aging);
590594

591595
// Enter exit frame.

0 commit comments

Comments
 (0)