Lines Matching full:stack
62 /// included as part of the stack frame.
67 // stack frame. ARM (especially Thumb) has small immediate offset to
68 // address the stack frame. So a large call frame can cause poor codegen
216 // Set FP to point to the stack slot that contains the previous FP.
257 // The code inserted by emitAlignedDPRCS2Spills realigns the stack, and
258 // leaves the stack pointer pointing to the DPRCS2 area.
260 // Adjust NumBytes to represent the stack slots below the DPRCS2 area.
289 // If we need dynamic stack realignment, do it here. Be paranoid and make
291 // If aligned NEON registers were spilled, the stack has already been
323 // of the stack pointer is at this point. Any variable size objects
390 // Reset SP based on frame pointer only if the stack frame extends beyond
391 // frame pointer stack slot or target is ELF and the function has FP.
440 // Tail call return: adjust the stack pointer and jump to callee.
515 // When dynamically realigning the stack, use the frame pointer for
516 // parameters, and the stack/base pointer for locals.
518 assert (hasFP(MF) && "dynamic stack realignment without a FP!");
524 "VLAs and dynamic stack alignment, but missing base pointer!");
561 // Otherwise, use SP or FP, whichever is closer to the stack slot.
728 /// starting from d8. Also insert stack realignment code and leave the stack
742 // stack slot layout backwards, this can actually mean that the d-reg stack
753 // The stack slot for D8 needs to be maximally aligned because this is
754 // actually the point where we align the stack pointer. MachineFrameInfo
755 // computes all offsets relative to the incoming stack pointer which is a
756 // bit weird when realigning the stack. Any extra padding for this
758 // the stack pointer by numregs * 8 before aligning the stack pointer.
763 // Move the stack pointer to the d8 spill slot, and align it at the same
764 // time. Leave the stack slot address in the scratch register r4.
771 assert(!AFI->isThumb1OnlyFunction() && "Can't realign stack for thumb1");
789 // The stack pointer must be adjusted before spilling anything, otherwise
790 // the stack slots could be clobbered by an interrupt handler.
800 // r4 holds the stack slot address.
888 /// stack is still aligned, unlike the code inserted by emitPopInst.
908 // This can be fairly complicated if the stack frame is large, so just use
910 // the initial part of the epilog where the stack and base pointers haven't
913 assert(!AFI->isThumb1OnlyFunction() && "Can't realign stack for thumb1");
991 // The stack realignment code will be inserted between the push instructions
1043 /// estimateRSStackSizeLimit - Look at each instruction that references stack
1044 /// frames and return the stack size limit beyond which some of these
1057 // When using ADDri to get the address of a stack object, 255 is the
1083 // immediate offset for stack references.
1096 // In functions that realign the stack, it can be an advantage to spill the
1097 // callee-saved vector registers after realigning the stack. The vst1 and vld1
1114 // Don't bother if the default stack alignment is sufficiently high.
1118 // Aligned spills require stack realignment.
1139 // Spill the first NumSpills D-registers after realigning the stack.
1168 // Spill R4 if Thumb2 function requires stack realignment - it will be used as
1183 // for sure what the stack size will be, but for this, an estimate is good
1193 // See if we can spill vector registers to aligned stack.
1267 // If any of the stack slot references may be out of range of an immediate
1270 // effective stack size is 4 bytes larger since the FP points to the stack
1272 // function, stack slot references will often be negative, and some of
1275 // the function adjusts the stack pointer during execution and the
1276 // adjustments aren't already part of our stack size estimate, our offset
1309 // If stack and double are 8-byte aligned and we are spilling an odd number
1335 // to materialize a stack offset. If so, either spill one additional
1337 // register scavenging. Thumb1 needs a spill slot for stack pointer
1370 // note: Thumb1 functions spill to R12, not the stack. Reserve a slot
1400 // We need to keep the stack aligned properly. To do this, we round the
