@@ -1658,6 +1658,139 @@ rtx_for_function_call (tree fndecl, tree
return funexp;
}
+/* Internal state for internal_arg_pointer_based_exp function and its
+ helpers. */
+static struct
+{
+ /* Last insn that has been already scanned by
+ internal_arg_pointer_based_exp_scan, or NULL_RTX if none has been
+ scanned yet and scan should start at get_insns (), or pc_rtx if
+ internal_arg_pointer_based_exp is called from within
+ internal_arg_pointer_based_exp_scan and scanning shouldn't
+ be performed. */
+ rtx scan_start;
+ /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
+ based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
+ pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
+ with fixed offset, or PC if this is with variable or unknown offset. */
+ VEC(rtx, heap) *cache;
+} internal_arg_pointer_exp_state;
+
+static rtx internal_arg_pointer_based_exp (rtx);
+
+/* Helper function for internal_arg_pointer_based_exp, called through
+ for_each_rtx. Return 1 if a crtl->args.internal_arg_pointer based
+ register is seen anywhere. Return -1 if it is not based on it and
+ subexpressions of *LOC should not be examined. */
+
+static int
+internal_arg_pointer_based_exp_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
+{
+ if (REG_P (*loc) && internal_arg_pointer_based_exp (*loc) != NULL_RTX)
+ return 1;
+ if (MEM_P (*loc))
+ return -1;
+ return 0;
+}
+
+/* Helper function for internal_arg_pointer_based_exp. Scan insns
+ in the tail call sequence, starting with first insn that hasn't been
+ scanned yet, and note for each LHS pseudo whether it is based on
+ crtl->args.internal_arg_pointer or not and what offset from
+ that pointer it has. */
+
+static void
+internal_arg_pointer_based_exp_scan (void)
+{
+ rtx insn, scan_start = internal_arg_pointer_exp_state.scan_start;
+
+ if (scan_start == NULL_RTX)
+ insn = get_insns ();
+ else
+ insn = NEXT_INSN (scan_start);
+
+ /* Disable scanning in the recursive internal_arg_pointer_based_exp
+ calls. */
+ internal_arg_pointer_exp_state.scan_start = pc_rtx;
+
+ while (insn)
+ {
+ rtx set = single_set (insn);
+ if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
+ {
+ rtx val = NULL_RTX;
+ unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
+ /* Punt on pseudos set multiple times. */
+ if (idx < VEC_length (rtx, internal_arg_pointer_exp_state.cache)
+ && (VEC_index (rtx, internal_arg_pointer_exp_state.cache, idx)
+ != NULL_RTX))
+ val = pc_rtx;
+ else
+ val = internal_arg_pointer_based_exp (SET_SRC (set));
+ if (val != NULL_RTX)
+ {
+ VEC_safe_grow_cleared (rtx, heap,
+ internal_arg_pointer_exp_state.cache,
+ idx + 1);
+ VEC_replace (rtx, internal_arg_pointer_exp_state.cache,
+ idx, val);
+ }
+ }
+ if (NEXT_INSN (insn) == NULL_RTX)
+ scan_start = insn;
+ insn = NEXT_INSN (insn);
+ }
+
+ /* Reenable scanning. */
+ internal_arg_pointer_exp_state.scan_start = scan_start;
+}
+
+/* If EXP is based on crtl->args.internal_arg_pointer, return either
+ a CONST_INT offset from crtl->args.internal_arg_pointer if
+ offset from it is known constant, or PC if the offset is unknown.
+ Return NULL_RTX if EXP isn't based on crtl->args.internal_arg_pointer. */
+
+static rtx
+internal_arg_pointer_based_exp (rtx rtl)
+{
+ if (CONSTANT_P (rtl))
+ return NULL_RTX;
+
+ if (rtl == crtl->args.internal_arg_pointer)
+ return const0_rtx;
+
+ if (REG_P (rtl) && HARD_REGISTER_P (rtl))
+ return NULL_RTX;
+
+ if (GET_CODE (rtl) == PLUS && CONST_INT_P (XEXP (rtl, 1)))
+ {
+ rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0));
+ if (val == NULL_RTX || val == pc_rtx)
+ return val;
+ return plus_constant (val, INTVAL (XEXP (rtl, 1)));
+ }
+
+ /* When not called recursively, scan pseudo assignments in between the
+ last scanned instruction in the tail call sequence and the latest insn
+ in that sequence. */
+ if (internal_arg_pointer_exp_state.scan_start != pc_rtx)
+ internal_arg_pointer_based_exp_scan ();
+
+ if (REG_P (rtl))
+ {
+ unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
+ if (idx < VEC_length (rtx, internal_arg_pointer_exp_state.cache))
+ return VEC_index (rtx, internal_arg_pointer_exp_state.cache, idx);
+ else
+ return NULL_RTX;
+ }
+
+ if (for_each_rtx (&rtl, internal_arg_pointer_based_exp_1, NULL))
+ return pc_rtx;
+
+ return NULL_RTX;
+}
+
/* Return true if and only if SIZE storage units (usually bytes)
starting from address ADDR overlap with already clobbered argument
area. This function is used to determine if we should give up a
@@ -1667,26 +1800,17 @@ static bool
mem_overlaps_already_clobbered_arg_p (rtx addr, unsigned HOST_WIDE_INT size)
{
HOST_WIDE_INT i;
+ rtx val;
if (sbitmap_empty_p (stored_args_map))
return false;
- if (addr == crtl->args.internal_arg_pointer)
- i = 0;
- else if (GET_CODE (addr) == PLUS
- && XEXP (addr, 0) == crtl->args.internal_arg_pointer
- && CONST_INT_P (XEXP (addr, 1)))
- i = INTVAL (XEXP (addr, 1));
- /* Return true for arg pointer based indexed addressing. */
- else if (GET_CODE (addr) == PLUS
- && (XEXP (addr, 0) == crtl->args.internal_arg_pointer
- || XEXP (addr, 1) == crtl->args.internal_arg_pointer))
- return true;
- /* If the address comes in a register, we have no idea of its origin so
- give up and conservatively return true. */
- else if (REG_P(addr))
+ val = internal_arg_pointer_based_exp (addr);
+ if (val == NULL_RTX)
+ return false;
+ else if (val == pc_rtx)
return true;
else
- return false;
+ i = INTVAL (val);
#ifdef ARGS_GROW_DOWNWARD
i = -i - size;
@@ -3294,6 +3418,8 @@ expand_call (tree exp, rtx target, int i
}
sbitmap_free (stored_args_map);
+ internal_arg_pointer_exp_state.scan_start = NULL_RTX;
+ VEC_free (rtx, heap, internal_arg_pointer_exp_state.cache);
}
else
{
@@ -0,0 +1,35 @@
+/* PR middle-end/51323 */
+
+extern void abort (void);
+struct S { int a, b, c; };
+int v;
+
+__attribute__((noinline, noclone)) void
+foo (int x, int y, int z)
+{
+ if (x != v || y != 0 || z != 9)
+ abort ();
+}
+
+static inline int
+baz (const struct S *p)
+{
+ return p->b;
+}
+
+__attribute__((noinline, noclone)) void
+bar (int x, struct S y)
+{
+ foo (baz (&y), 0, x);
+}
+
+int
+main ()
+{
+ struct S s;
+ v = 3; s.a = v - 1; s.b = v; s.c = v + 1;
+ bar (9, s);
+ v = 17; s.a = v - 1; s.b = v; s.c = v + 1;
+ bar (9, s);
+ return 0;
+}