[Bug middle-end/107411] trivial-auto-var-init=zero invalid uninitialized variable warning

["rguenth at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Blocks|                            |24639
                 CC|                            |qing.zhao at oracle dot com,
                   |                            |rguenth at gcc dot gnu.org

--- Comment #2 from Richard Biener <rguenth at gcc dot gnu.org> ---
(In reply to Andrew Pinski from comment #1)
> Confirmed. reduced testcase:
> int t();
> void f(int);
>   
> void j()
> {
> 	const int& e = t();
> 	f(e);
> }
> 
> Someone who understands the uininit pass should look into this but the IR at
> that point we get is (with -fno-exceptions due to extra clobbers otherwise
> which don't make a difference):
>   _1 = .DEFERRED_INIT (4, 2, &"D.2374"[0]);
>   D.2374 = _1;
>   e_6 = .DEFERRED_INIT (8, 2, &"e"[0]);
>   _2 = t ();
>   D.2374 = _2;
>   e_9 = &D.2374;
>   _3 = *e_9;
>   f (_3);
>   D.2374 ={v} {CLOBBER(eol)};
> 
> There is no read from D.2374 in the call to t at all and then we do a full
> write after the call.

We diagnose the

  D.2374 = _1;

store which uses uninitialized _1.  The FE emits

  <<cleanup_point <<< Unknown tree: expr_stmt
    (void) (e = D.2389 = t ();, (const int &) &D.2389;) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
    f ((int) *e) >>>>>;

note that without -ftrivial-auto-var-init=zero we see

  <bb 2> :
  _6 = t ();

  <bb 3> :
  _1 = _6;
  D.2389 = _1;
  e_8 = &D.2389;
  _2 = *e_8;
  f (_2);

  <bb 4> :
  D.2389 ={v} {CLOBBER(eol)};
  return;

  <bb 5> :
<L0>:
  D.2389 ={v} {CLOBBER(eol)};
  resx 1

while with the flag we have

  <bb 2> :
  _1 = .DEFERRED_INIT (4, 2, &"D.2389"[0]);
  D.2389 = _1;
  e_7 = .DEFERRED_INIT (8, 2, &"e"[0]);
  _9 = t ();

  <bb 3> :
  _2 = _9;
  D.2389 = _2;
  e_11 = &D.2389;
  _3 = *e_11;
  f (_3);

  <bb 4> :
  D.2389 ={v} {CLOBBER(eol)};
  return;

  <bb 5> :
<L0>:
  D.2389 ={v} {CLOBBER(eol)};
  resx 1

The gimplifier instead of

      _1 = t ();
      D.2389 = _1;
      e = &D.2389;
      _2 = *e;
      f (_2);

produces

      _1 = .DEFERRED_INIT (4, 2, &"D.2389"[0]);
      D.2389 = _1;
      e = .DEFERRED_INIT (8, 2, &"e"[0]);
      _2 = t ();
      D.2389 = _2;
      e = &D.2389;
      _3 = *e;
      f (_3);

which is odd and sub-optimal at least.  Doing such things makes us rely
on DSE to elide the uninit "inits".


Referenced Bugs:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=24639
[Bug 24639] [meta-bug] bug to track all Wuninitialized issues