[Bug rtl-optimization/41239] New: Scheduler reorders division by zero before a call that might not return

[Bug rtl-optimization/41239] New: Scheduler reorders division by zero before a call that might not return

[jakub at gcc dot gnu dot org]

This testcase distilled from postgresql fails at runtime on s390x-linux with
-O2 -march=z9-109 -mtune=z10:

/* { dg-do run } */
/* { dg-options "-O2" } */
/* { dg-options "-O2 -march=z9-109 -mtune=z10" { target s390x-linux } } */

struct S
{
  short nargs;
  unsigned long arg[2];
};

extern void abort (void);
extern void exit (int);
extern char errstart (int, const char *, int, const char *, const char *);
extern void errfinish (int, ...);
extern int errcode (int);
extern int errmsg (const char *fmt, ...) __attribute__ ((format (printf, 1,
2)));

unsigned long
test (struct S *x)
{
  signed int arg1 = x->arg[0];
  long int arg2 = x->arg[1];

  if (arg2 == 0)
    (errstart (20, "int8.c", 924, __func__, ((void *) 0))
     ? (errfinish (errcode (0x2040082), errmsg ("division by zero")))
     : (void) 0);

  return (long int) arg1 / arg2;
}

int
main (void)
{
  struct S s = { 2, { 5, 0 } };
  test (&s);
  abort ();
}

__attribute__((noinline)) char
errstart (int x, const char *y, int z, const char *w, const char *v)
{
  asm volatile ("" : "+r" (x) : "r" (y), "r" (z), "r" (w), "r" (v) : "memory");
  return x;
}

__attribute__((noinline)) int
errcode (int x)
{
  asm volatile ("" : "+r" (x) : : "memory");
  return x;
}

__attribute__((noinline)) int
errmsg (const char *x, ...)
{
  asm volatile ("" : "+r" (x) : : "memory");
  return *x;
}

__attribute__((noinline)) void
errfinish (int x, ...)
{
  asm volatile ("" : "+r" (x) : : "memory");
  if (x)
    /* Could be a longjmp or throw too.  */
    exit (0);
}

The problem is that 2nd scheduler pass reorders the division before some of the
calls.  If the calls were guaranteed to return, that would be fine, the program
would crash sooner or later, but as shown in the testcase the call can not
return (exit, longjmp, throw) and in that case whether the division is
scheduled before or after the call matters.


-- 
           Summary: Scheduler reorders division by zero before a call that
                    might not return
           Product: gcc
           Version: 4.5.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: rtl-optimization
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: jakub at gcc dot gnu dot org
GCC target triplet: s390x-linux


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[jakub at gcc dot gnu dot org]

------- Comment #1 from jakub at gcc dot gnu dot org  2009-09-03 09:24 -------
sched-deps.c uses may_trap_p only to find out what insns can't be speculated,
possibly trapping MEMs are handled by deps_may_trap_p.
I wonder what exactly we want to forbid to cure this testcase.
Just DIV/MOD/UDIV/UMOD that may_trap_p being moved across a function call that
might not return (all CALL_Ps or all except a few known builtins?  Say memcpy
or strcpy could be said to always return), or all may_trap_p insns across all
calls that might not return, or even across all such calls and all trapping
insns?
Ideas?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[rguenth at gcc dot gnu dot org]

------- Comment #2 from rguenth at gcc dot gnu dot org  2009-09-03 10:31 -------
We can never move maybe trapping instructions across a function call that might
not return (and as we don't have an attribute for returns_always we have to
assume that a function may not return always apart from maybe some known
builtins).


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[jakub at gcc dot gnu dot org]

------- Comment #3 from jakub at gcc dot gnu dot org  2009-09-03 20:11 -------
Looking at sched-deps.c, it might be easiest for may_trap_p insns to be queued
onto deps->sched_before_next_call chain, but I'm not sure whether we want to do
that for all, or if it should ignore trapping memory as that's handled
elsewhere in sched-deps.c.  Vlad, any ideas?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[vmakarov at redhat dot com]

------- Comment #4 from vmakarov at redhat dot com  2009-09-03 21:40 -------
  Oh well, another haifa-scheduler integration issue after so many years to
integrate it into GCC.  It looks like the original haifa-scheduler treated
calls as always returning.

  I think you should use last_function_call and make dependence for trapping
insn to calls on this list which might not return.  You could ignore issue with
already processed insn with trapping memory because you can add as many
dependencies between the two insns as you want.  Sched-deps.c code is pretty
smart with this point of view.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[jakub at gcc dot gnu dot org]

------- Comment #5 from jakub at gcc dot gnu dot org  2009-09-08 09:26 -------
Subject: Bug 41239

Author: jakub
Date: Tue Sep  8 09:25:47 2009
New Revision: 151500

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=151500
Log:
        PR rtl-optimization/41239
        * sched-int.h (struct deps): Add last_function_call_may_noreturn field.
        * sched-rgn.c (deps_join): Join also last_function_call_may_noreturn
        lists.
        * sched-deps.c (sched_analyze_insn): Prevent moving trapping insns
        across calls, as the calls might not always return normally.
        (call_may_noreturn_p): New function.
        (deps_analyze_insn): Update last_function_call_may_noreturn list.
        (init_deps): Initialize it.
        (remove_from_deps): Also remove calls from
        last_function_call_may_noreturn list.

        * gcc.c-torture/execute/pr41239.c: New test.

Added:
    trunk/gcc/testsuite/gcc.c-torture/execute/pr41239.c
Modified:
    trunk/gcc/ChangeLog
    trunk/gcc/sched-deps.c
    trunk/gcc/sched-int.h
    trunk/gcc/sched-rgn.c
    trunk/gcc/testsuite/ChangeLog


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[jakub at gcc dot gnu dot org]

------- Comment #6 from jakub at gcc dot gnu dot org  2009-09-08 09:35 -------
Fixed on the trunk.


-- 

jakub at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |FIXED


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[pinskia at gcc dot gnu dot org]

-- 

pinskia at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |4.5.0


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

[Bug rtl-optimization/41239] Scheduler reorders division by zero before a call that might not return

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=41239

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |tiamat at komi dot mts.ru

--- Comment #7 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
*** Bug 29968 has been marked as a duplicate of this bug. ***