[Bug target/52055] New: load of 64-bit pointer reads 64 bits even when only 32 are used

[Bug target/52055] New: load of 64-bit pointer reads 64 bits even when only 32 are used

[jhaberman at gmail dot com]

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

             Bug #: 52055
           Summary: load of 64-bit pointer reads 64 bits even when only 32
                    are used
    Classification: Unclassified
           Product: gcc
           Version: 4.6.1
            Status: UNCONFIRMED
          Severity: minor
          Priority: P3
         Component: target
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: jhaberman@gmail.com


The following test program:

#include <stdint.h>
uint32_t rd32(uint64_t *i) { return *i; }

Compiles to this (-O3 -fomit-frame-pointer):

0000000000000000 <rd32>:
   0:    48 8b 07                 mov    rax,QWORD PTR [rdi]
   3:    c3                       ret    

But Clang compiles to this, which seems correct, is one byte shorter and
touches less memory:

0000000000000000 <rd32>:
   0:    8b 07                    mov    eax,DWORD PTR [rdi]
   2:    c3                       ret

[Bug target/52055] load of 64-bit pointer reads 64 bits even when only 32 are used

[rguenth at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |missed-optimization
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2012-01-31
     Ever Confirmed|0                           |1

--- Comment #1 from Richard Guenther <rguenth at gcc dot gnu.org> 2012-01-31 10:56:23 UTC ---
Confirmed.  It's valid to shorten the load for aligned i, it would not be
valid if it were a read from a possibly unaligned memory (it might trap
with 64bit size but not with 32bit).

[Bug target/52055] load of 64-bit pointer reads 64 bits even when only 32 are used

[jhaberman at gmail dot com]

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

--- Comment #2 from Josh Haberman <jhaberman at gmail dot com> 2012-01-31 17:23:51 UTC ---
Is there any requirement that you trap if the 64-bit read would have trapped?  
Aren't unaligned reads undefined behavior that only happen to work on x86-64?

[Bug target/52055] load of 64-bit pointer reads 64 bits even when only 32 are used

[jakub at gcc dot gnu.org]

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

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #3 from Jakub Jelinek <jakub at gcc dot gnu.org> 2012-01-31 18:29:33 UTC ---
Combine can already do this kind of change, as can be seen e.g. on
void foo (unsigned long long *p) { asm volatile ("" : : "rm" ((unsigned) *p));
}
where combine shortens the load into SImode load, but on this testcase we don't
attempt to combine it, because cant_combine_insn_p on the insn with subreg says
we shouldn't combine it (the src is a subreg:SI of the reg:DI initialized by
the DImode memory load, but dest is hard register %eax, which has likely
spilled
register class).
So, shell we do this kind of shortening in fwprop instead?  If a MEM load has
all uses subregged to a narrower mode, try to subreg it and adjust the callers?

[Bug target/52055] load of 64-bit pointer reads 64 bits even when only 32 are used

[ebotcazou at gcc dot gnu.org]

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

--- Comment #4 from Eric Botcazou <ebotcazou at gcc dot gnu.org> 2012-02-01 16:13:43 UTC ---
> So, shell we do this kind of shortening in fwprop instead?  If a MEM load has
> all uses subregged to a narrower mode, try to subreg it and adjust the callers?

This would be backward combining (a la REE) though, not forward propagating.

[Bug target/52055] load of 64-bit pointer reads 64 bits even when only 32 are used

[jakub at gcc dot gnu.org]

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

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> 2012-02-01 16:35:13 UTC ---
That's true, but currently REE is after reload, this combining would be better
done before reload.  Perhaps a separate post-combine pre-ira pass could handle
that and also perhaps PR50176 (if it is somehow possible to insert CC clobbers
to insns that don't have it safely).  The UD/DU links computation REE does is
very expensive I think.

[Bug target/52055] load of 64-bit pointer reads 64 bits even when only 32 are used

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Severity|minor                       |enhancement