config/i386/i386.c

2144   /* flags, fpsr, fpcr, frame */
2176   -1, -1, -1, -1, -1,			/* arg, flags, fpsr, fpcr, frame */
2193   -1, -1, -1, -1, -1,			/* arg, flags, fpsr, fpcr, frame */
2262   -1, 9, -1, -1, -1,			/* arg, flags, fpsr, fpcr, frame */
2309 /* Structure describing stack frame layout.
2318    saved frame pointer			if frame_pointer_needed
2330    [frame]	       |
2708     { "-momit-leaf-frame-pointer",	MASK_OMIT_LEAF_FRAME_POINTER },
3980   /* Keep nonleaf frame pointers.  */
9079 	 Prologue of the function save it right above stack frame.  */
9669    must be saved, so return false then.  Return false if there is no frame
9675   struct ix86_frame frame;
9685   ix86_compute_frame_layout (&frame);
9686   return (frame.stack_pointer_offset == UNITS_PER_WORD
9687 	  && (frame.nregs + frame.nsseregs) == 0);
9691 /* Value should be nonzero if functions must have frame pointers.
9692    Zero means the frame pointer need not be set up (and parms may
9699      to be able to access the saved ebp value in our frame.  */
9703   /* Several x86 os'es need a frame pointer for other reasons,
9708   /* For older 32-bit runtimes setjmp requires valid frame-pointer.  */
9712   /* Win64 SEH, very large frames need a frame-pointer as maximum stack
9717   /* SSE saves require frame-pointer when stack is misaligned.  */
9722      turns off the frame pointer by default.  Turn it back on now if
10074    pointer with hard frame pointer, or replace frame pointer with stack
10075    pointer.  Otherwise, frame pointer elimination is automatically
10096   struct ix86_frame frame;
10097   ix86_compute_frame_layout (&frame);
10100     return frame.hard_frame_pointer_offset;
10103     return frame.hard_frame_pointer_offset - frame.frame_pointer_offset;
10109 	return frame.stack_pointer_offset;
10112       return frame.stack_pointer_offset - frame.frame_pointer_offset;
10117    stack pointer to frame pointer, so we must ensure that setjmp
10119    index from %esp up to the top of the frame across a gap that is
10133 /* Fill structure ix86_frame about frame of currently computed function.  */
10136 ix86_compute_frame_layout (struct ix86_frame *frame)
10144   frame->nregs = ix86_nsaved_regs ();
10145   frame->nsseregs = ix86_nsaved_sseregs ();
10179            && cfun->machine->use_fast_prologue_epilogue_nregs != frame->nregs)
10181       int count = frame->nregs;
10207   frame->save_regs_using_mov
10210 	  the registers need to be saved before allocating the frame.  */
10223   frame->hfp_save_offset = offset;
10225   /* The traditional frame pointer location is at the top of the frame.  */
10226   frame->hard_frame_pointer_offset = offset;
10229   offset += frame->nregs * UNITS_PER_WORD;
10230   frame->reg_save_offset = offset;
10232   /* On SEH target, registers are pushed just before the frame pointer
10235     frame->hard_frame_pointer_offset = offset;
10238   if (frame->nsseregs)
10242 	 within the re-aligned local stack frame to save them.  In case
10246 	 re-aligned local stack frame to 16 bytes.  */
10249       offset += frame->nsseregs * 16;
10251   frame->sse_reg_save_offset = offset;
10261   frame->va_arg_size = ix86_varargs_gpr_size + ix86_varargs_fpr_size;
10262   offset += frame->va_arg_size;
10264   /* Align start of frame for local function.  */
10266       || offset != frame->sse_reg_save_offset
10274   frame->frame_pointer_offset = offset;
10282      of stack frame are unused.  */
10288       frame->outgoing_arguments_size = crtl->outgoing_args_size;
10291     frame->outgoing_arguments_size = 0;
10299   /* We've reached end of stack frame.  */
10300   frame->stack_pointer_offset = offset;
10303   to_allocate = offset - frame->sse_reg_save_offset;
10305   if ((!to_allocate && frame->nregs <= 1)
10307     frame->save_regs_using_mov = false;
10314       frame->red_zone_size = to_allocate;
10315       if (frame->save_regs_using_mov)
10316 	frame->red_zone_size += frame->nregs * UNITS_PER_WORD;
10317       if (frame->red_zone_size > RED_ZONE_SIZE - RED_ZONE_RESERVE)
10318 	frame->red_zone_size = RED_ZONE_SIZE - RED_ZONE_RESERVE;
10321     frame->red_zone_size = 0;
10322   frame->stack_pointer_offset -= frame->red_zone_size;
10324   /* The SEH frame pointer location is near the bottom of the frame.
10326      stack pointer and the frame pointer is limited to 240 bytes in
10332       /* If we can leave the frame pointer where it is, do so.  Also, returns
10333 	 the establisher frame for __builtin_frame_address (0).  */
10334       diff = frame->stack_pointer_offset - frame->hard_frame_pointer_offset;
10339 	  /* Ideally we'd determine what portion of the local stack frame
10341 	     But without that complication, simply bias the frame pointer
10343 	     frame that is addressable with 8-bit offsets.  */
10344 	  frame->hard_frame_pointer_offset = frame->stack_pointer_offset - 128;
10373 /* Return an RTX that points to CFA_OFFSET within the stack frame.
10482   /* SSE saves are not within re-aligned local stack frame.
10496   /* When saving registers into a re-aligned local stack frame, avoid
10505 	     the re-aligned stack frame, which provides us with a copy
10515 	  /* The frame pointer is a stable reference within the
10516 	     aligned frame.  Use it.  */
10614    STYLE should be negative if instructions should be marked as frame related,
10802   /* The incoming stack frame has to be aligned at least at
11101      frame-related ones from the frame-unrelated ones.  */
11418   struct ix86_frame frame;
11436      this is fudged; we're interested to offsets within the local frame.  */
11440   ix86_compute_frame_layout (&frame);
11464 	 What that means is that we've already set up the frame pointer.  */
11471 	  /* We've decided to use the frame pointer already set up.
11509 	  /* The frame pointer is not needed so pop %ebp again.
11568       /* For the purposes of frame and register save area addressing,
11569 	 we've started over with a new frame.  */
11574   int_registers_saved = (frame.nregs == 0);
11575   sse_registers_saved = (frame.nsseregs == 0);
11584       /* Push registers now, before setting the frame pointer
11588 	  && !frame.save_regs_using_mov)
11592 	  gcc_assert (m->fs.sp_offset == frame.reg_save_offset);
11595       if (m->fs.sp_offset == frame.hard_frame_pointer_offset)
11610       if (!frame.save_regs_using_mov)
11614 	  gcc_assert (m->fs.sp_offset == frame.reg_save_offset);
11618 	 the stack frame saving one cycle of the prologue.  However, avoid
11623 		   || frame.stack_pointer_offset < CHECK_STACK_LIMIT))
11625 	  ix86_emit_save_regs_using_mov (frame.reg_save_offset);
11635       /* The computation of the size of the re-aligned stack frame means
11639       if (m->fs.sp_offset != frame.sse_reg_save_offset)
11642 					    - frame.sse_reg_save_offset),
11658   allocate = frame.stack_pointer_offset - m->fs.sp_offset;
11663       HOST_WIDE_INT stack_size = frame.stack_pointer_offset;
11665       /* If it was realigned, take into account the fake frame.  */
11683   /* On SEH target with very large frame size, allocate an area to save
11686       && frame.stack_pointer_offset > SEH_MAX_FRAME_SIZE
11690 	frame.sse_reg_save_offset - frame.reg_save_offset;
11700       ix86_emit_save_sse_regs_using_mov (frame.sse_reg_save_offset);
11754 	   || frame.stack_pointer_offset < CHECK_STACK_LIMIT)
11777 	     pointer even after the frame pointer has been set up.  */
11849   gcc_assert (m->fs.sp_offset == frame.stack_pointer_offset);
11851   /* If we havn't already set up the frame pointer, do so now.  */
11855 			    GEN_INT (frame.stack_pointer_offset
11856 				     - frame.hard_frame_pointer_offset));
11863       m->fs.fp_offset = frame.hard_frame_pointer_offset;
11868     ix86_emit_save_regs_using_mov (frame.reg_save_offset);
11870     ix86_emit_save_sse_regs_using_mov (frame.sse_reg_save_offset);
11896      sequence when access to the redzone area is done through frame pointer.
11897      The offset between the frame pointer and the stack pointer is calculated
11899      prologue, and moving instructions that access redzone area via frame
11901   if (frame_pointer_needed && frame.red_zone_size)
11953   /* When the frame pointer is the CFA, and we pop it, we are
12076  	/* SSE saves are not within re-aligned local stack frame.
12094 /* Restore function stack, frame, and registers.  */
12101   struct ix86_frame frame;
12106   ix86_compute_frame_layout (&frame);
12112 	      || m->fs.sp_offset == frame.stack_pointer_offset);
12114   /* The FP must be valid if the frame pointer is present.  */
12117 	      || m->fs.fp_offset == frame.hard_frame_pointer_offset);
12119   /* We must have *some* valid pointer to the stack frame.  */
12125   /* See the comment about red zone and frame
12127   if (frame_pointer_needed && frame.red_zone_size)
12142 	 matches up with the aligned frame.  */
12152     frame.reg_save_offset -= 2 * UNITS_PER_WORD;
12163   else if (!m->fs.sp_valid && frame.nregs <= 1)
12167 	   && (frame.nregs > 1
12168 	       || m->fs.sp_offset != frame.reg_save_offset))
12171 	   && !frame.nregs
12172 	   && m->fs.sp_offset != frame.reg_save_offset)
12177 	   && frame.nregs == 1)
12182   if (restore_regs_via_mov || frame.nsseregs)
12189 	  && (frame.nsseregs + frame.nregs) != 0)
12193 					      - frame.sse_reg_save_offset),
12201   if (frame.nsseregs)
12202     ix86_emit_restore_sse_regs_using_mov (frame.sse_reg_save_offset,
12209       if (frame.nregs)
12210 	ix86_emit_restore_regs_using_mov (frame.reg_save_offset, style == 2);
12291       /* First step is to deallocate the stack frame so that we can
12293 	 frame as the emitted instructions aren't allowed by the ABI in
12297 	      && (m->fs.sp_offset - frame.reg_save_offset
12302 					      - frame.reg_save_offset),
12305       else if (m->fs.sp_offset != frame.reg_save_offset)
12309 					      - frame.reg_save_offset),
12321       /* If the stack pointer is valid and pointing at the frame
12323       if (m->fs.sp_valid && m->fs.sp_offset == frame.hfp_save_offset)
12373      entire stack frame.  We've delayed this until now because it may
12557   struct ix86_frame frame;
12569   ix86_compute_frame_layout (&frame);
12570   allocate = frame.stack_pointer_offset - INCOMING_FRAME_SP_OFFSET;
12577   /* We need to compare the stack pointer minus the frame size with
12594 	 the required frame size.  Since this is the very start of the
12672 	     frame size in the lower 32 bits.  */
12747      found at the frame pointer value used by __morestack, because
41708           (vec_duplicate:V2DI (reg/f:DI 20 frame)))
41710      Eventually frame gets turned into sp+offset like this:
43340      predicate that can distinguish between frame and non-frame memory.