Re: local-alloc update_equiv_regs and moving register initialization

Re: local-alloc update_equiv_regs and moving register initialization

[John Wehle]

> a is set and used exactly once, and the set is known to be executed.
> It just happens to come after the use.

Exactly.

> Note that you also have to watch out for cases where the set is statically
> before the use, but dynamically after the use in loop order.

Yes.  I was talking from a CFG point of view.

I'll add moving register initialization within loops to my list of
candidates of things to "play with".  Thanks for pointing out some
of the sharp objects. :-)

-- John
-------------------------------------------------------------------------
|   Feith Systems  |   Voice: 1-215-646-8000  |  Email: john@feith.com  |
|    John Wehle    |     Fax: 1-215-540-5495  |                         |
-------------------------------------------------------------------------

Re: local-alloc update_equiv_regs and moving register initialization

[Joern Rennecke]

> > consider
> > 
> >     if (i)
> >       c = a + b;
> >     a = i * 3;
> 
> The optimization in question requires that the register be set and used
> exactly once.  I was going with the requirement that the set appear
> prior to the use and known to be executed.

a is set and used exactly once, and the set is known to be executed.
It just happens to come after the use.

Note that you also have to watch out for cases where the set is statically
before the use, but dynamically after the use in loop order.

  goto foo;
bar:
  a = i * 3;
  goto baz;
foo:
  if (i)
    c = a + b;
  goto bar;
baz:

Re: local-alloc update_equiv_regs and moving register initialization

[John Wehle]

> consider
> 
>     if (i)
>       c = a + b;
>     a = i * 3;

The optimization in question requires that the register be set and used
exactly once.  I was going with the requirement that the set appear
prior to the use and known to be executed.

Assuming that code (such as that above) is ignored, any other reason
not to move the initialization when both are within the same loop?

-- John
-------------------------------------------------------------------------
|   Feith Systems  |   Voice: 1-215-646-8000  |  Email: john@feith.com  |
|    John Wehle    |     Fax: 1-215-540-5495  |                         |
-------------------------------------------------------------------------

Re: local-alloc update_equiv_regs and moving register initialization

[Joern Rennecke]

> > Because then you might change the semantics of the program.
> 
> That's a good reason, however I'm feeling a bit dense.  How could it
> change the semantics of the program?  If it's safe to change:
> 
>   a = 3;
>   ...
>   c = a + b;
> 
> to
> 
>   ...
>   a = 3;
>   c = a + b;
> 
> when a = 3 and c = a + b are outside a loop, why isn't it safe to make
> the same change when both are inside the same loop?

consider

    if (i)
      c = a + b;
    a = i * 3;

Re: local-alloc update_equiv_regs and moving register initialization

[Jeffrey A Law]

  In message < 7334.968972585@upchuck >you write:
  > 
  > 
  >   In message < 200009142244.SAA18278@jwlab.FEITH.COM >you write:
  >   > update_equiv_regs has the comment:
  >   > 
  >   >   /* Now scan all regs killed in an insn to see if any of them are
  >   >      registers only used that once.  If so, see if we can replace the
  >   >      reference with the equivalent from.  If we can, delete the
  >   >      initializing reference and this register will go away.  If we
  >   >      can't replace the reference, and the instruction is not in a
  >   >      loop, then move the register initialization just before the use,
  >   >      so that they are in the same basic block.  */
  >   > 
  >   > Why isn't desirable to move the register initialization just before the
  >   > use when both are within the same loop?
  > Doesn't that minimize the lifetime of the pseudo holding the initialized
  > value, which in turn gives the allocators more freedom in making
  > register assignments?
Please ignore my answer.  I mis-parsed the question.

jeff

Re: local-alloc update_equiv_regs and moving register initialization

[John Wehle]

>> Why isn't desirable to move the register initialization just before the
>> use when both are within the same loop?
>
> Because then you might change the semantics of the program.

That's a good reason, however I'm feeling a bit dense.  How could it
change the semantics of the program?  If it's safe to change:

  a = 3;
  ...
  c = a + b;

to

  ...
  a = 3;
  c = a + b;

when a = 3 and c = a + b are outside a loop, why isn't it safe to make
the same change when both are inside the same loop?

-- John
-------------------------------------------------------------------------
|   Feith Systems  |   Voice: 1-215-646-8000  |  Email: john@feith.com  |
|    John Wehle    |     Fax: 1-215-540-5495  |                         |
-------------------------------------------------------------------------

Re: local-alloc update_equiv_regs and moving register initialization

[Jeffrey A Law]

  In message < 200009142244.SAA18278@jwlab.FEITH.COM >you write:
  > update_equiv_regs has the comment:
  > 
  >   /* Now scan all regs killed in an insn to see if any of them are
  >      registers only used that once.  If so, see if we can replace the
  >      reference with the equivalent from.  If we can, delete the
  >      initializing reference and this register will go away.  If we
  >      can't replace the reference, and the instruction is not in a
  >      loop, then move the register initialization just before the use,
  >      so that they are in the same basic block.  */
  > 
  > Why isn't desirable to move the register initialization just before the
  > use when both are within the same loop?
Doesn't that minimize the lifetime of the pseudo holding the initialized
value, which in turn gives the allocators more freedom in making
register assignments?

jeff

Re: local-alloc update_equiv_regs and moving register initialization

[Joern Rennecke]

> Why isn't desirable to move the register initialization just before the
> use when both are within the same loop?

Because then you might change the semantics of the program.

local-alloc update_equiv_regs and moving register initialization

[John Wehle]

update_equiv_regs has the comment:

  /* Now scan all regs killed in an insn to see if any of them are
     registers only used that once.  If so, see if we can replace the
     reference with the equivalent from.  If we can, delete the
     initializing reference and this register will go away.  If we
     can't replace the reference, and the instruction is not in a
     loop, then move the register initialization just before the use,
     so that they are in the same basic block.  */

Why isn't desirable to move the register initialization just before the
use when both are within the same loop?

-- John
-------------------------------------------------------------------------
|   Feith Systems  |   Voice: 1-215-646-8000  |  Email: john@feith.com  |
|    John Wehle    |     Fax: 1-215-540-5495  |                         |
-------------------------------------------------------------------------