[Bug c/84184] gcc generates wrong relocations with negative offsets in struct arrays (but not integral arrays)

["slyfox at inbox dot ru" <gcc-bugzilla at gcc dot gnu dot org>]

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

Sergei Trofimovich <slyfox at inbox dot ru> changed:

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

--- Comment #1 from Sergei Trofimovich <slyfox at inbox dot ru> ---
Dumping 'val_s_hidden':

    extern char glo_s_middle_hidden[] __attribute__((visibility("hidden")));
    static u64 __attribute__((noinline)) val_s_hidden(void) {
        const struct s * m = (const struct s *)glo_s_middle_hidden;
        return m[-1].a;
    }

$ cat reloc-bug.c.227t.optimized

    ;; Function val_s_hidden (val_s_hidden, funcdef_no=23, decl_uid=2082,
cgraph_uid=23, symbol_order=24) (executed once)

    __attribute__((noinline))
    val_s_hidden ()
    {
      u64 _2;

      <bb 2> [100.00%]:
      _2 = MEM[(const struct s *)&glo_s_middle_hidden + -8B].a;
      return _2;
    }

Still looks ok, right? I guess RTL is doing funny things here (+Eric).

$ cat reloc-bug.c.229r.expand

    ;;
    ;; Full RTL generated for this function:
    ;;
    (note 1 0 3 NOTE_INSN_DELETED)
    (note 3 1 2 2 [bb 2] NOTE_INSN_BASIC_BLOCK)
    (note 2 3 5 2 NOTE_INSN_FUNCTION_BEG)
    (insn 5 2 6 2 (set (reg/f:DI 342)
            (symbol_ref:DI ("glo_s_middle_hidden") [flags 0x42]  <var_decl
0x7f03587b2510 glo_s_middle_hidden>)) "reloc-bug.c":17 -1
         (nil))
    (insn 6 5 7 2 (set (reg:DI 343)
            (reg/f:DI 342)) "reloc-bug.c":17 -1
         (nil))
    (insn 7 6 8 2 (set (reg:DI 345)
            (const_int 2305843009213693944 [0x1ffffffffffffff8]))
"reloc-bug.c":17 -1
         (nil))
    ...

Surprisingly large amount of code is generated here:

$ cat reloc-bug.S

val_s_hidden:
        .prologue
        .body
        .mlx
        nop 0
        movl r14 = @gprel(glo_s_middle_hidden#)
        .mlx
        nop 0
        movl r16 = 2305843009213693945 ; 0x1ffffffffffffff9
        ;;
        .mlx
        add r14 = r1, r14
        movl r15 = 2305843009213693944 ; 0x1ffffffffffffff8
        .mlx
        nop 0
        movl r17 = 2305843009213693946 ; 0x1ffffffffffffffa
        ;;
        .mmi
        add r15 = r14, r15
        add r17 = r14, r17
        add r16 = r14, r16
        ;;
        .mmi
        ld1 r8 = [r15]
        ld1 r16 = [r16]
        nop 0
        ;;
        .mlx
        ld1 r15 = [r17]
        movl r17 = 2305843009213693947 ; 0x1ffffffffffffffb
        .mib
        nop 0
        shl r16 = r16, 8
        nop 0
        ;;
        .mmi
        add r17 = r14, r17
        or r16 = r8, r16
        shl r15 = r15, 16
        ;;
        .mlx
        ld1 r8 = [r17]
        movl r17 = 2305843009213693948 ; 0x1ffffffffffffffc
        .mmi
        or r15 = r16, r15
        ;;
        add r17 = r14, r17
        shl r8 = r8, 24
        ;;
        .mlx
        ld1 r16 = [r17]
        movl r17 = 2305843009213693949 ; 0x1ffffffffffffffd
        .mmi
        or r8 = r15, r8
        ;;
        add r17 = r14, r17
        shl r16 = r16, 32
        ;;
        .mlx
        ld1 r15 = [r17]
        movl r17 = 2305843009213693950 ; 0x1ffffffffffffffe
        .mmi
        or r16 = r8, r16
        ;;
        add r17 = r14, r17
        shl r15 = r15, 40
        ;;
        .mlx
        ld1 r8 = [r17]
        movl r17 = 2305843009213693951 ; 0x1fffffffffffffff
        .mmi
        or r15 = r16, r15
        ;;
        add r14 = r14, r17
        shl r8 = r8, 48
        ;;
        .mii
        ld1 r16 = [r14]
        or r15 = r15, r8
        ;;
        shl r8 = r16, 56
        ;;
        .mib
        nop 0
        or r8 = r15, r8
        br.ret.sptk.many b0
        .endp val_s_hidden#

I hoped to see here single load (something like that):

    mov <reg_rel> = @gprel64(glo_s_middle_hidden#)

    add  <reg> = gp, <reg_rel>

    ld8 r8 = [<reg>]

I see 2 issues here:
- code is invalid
- large amount of code