[ARM] Unaligned accesses for builtin memcpy [2/2]

Hi,

This is the second of two patches to add unaligned-access support to
the ARM backend. It builds on the first patch to provide support for
unaligned accesses when expanding block moves (i.e. for builtin memcpy
operations). It makes some effort to use load/store multiple
instructions where appropriate (when accessing sufficiently-aligned
source or destination addresses), and also makes some effort to
generate fast code (for -O1/2/3) or small code (for -Os), though some
of the heuristics may need tweaking still.

Examples:

#include <string.h>

void foo (char *dest, char *src)
{
  memcpy (dest, src, AMOUNT);
}

char known[64];

void dst_aligned (char *src)
{
  memcpy (known, src, AMOUNT);
}

void src_aligned (char *dst)
{
  memcpy (dst, known, AMOUNT);
}

For "-mcpu=cortex-m4 -mthumb -O2 -DAMOUNT=15" we get:

foo:
        ldr     r2, [r1, #4]    @ unaligned
        ldr     r3, [r1, #8]    @ unaligned
        push    {r4}
        ldr     r4, [r1, #0]    @ unaligned
        str     r2, [r0, #4]    @ unaligned
        str     r4, [r0, #0]    @ unaligned
        str     r3, [r0, #8]    @ unaligned
        ldrh    r2, [r1, #12]   @ unaligned
        ldrb    r3, [r1, #14]   @ zero_extendqisi2
        strh    r2, [r0, #12]   @ unaligned
        strb    r3, [r0, #14]
        pop     {r4}
        bx      lr

dst_aligned:
        push    {r4}
        mov     r4, r0
        movw    r3, #:lower16:known
        ldr     r1, [r4, #4]    @ unaligned
        ldr     r2, [r4, #8]    @ unaligned
        ldr     r0, [r0, #0]    @ unaligned
        movt    r3, #:upper16:known
        stmia   r3!, {r0, r1, r2}
        ldrh    r1, [r4, #12]   @ unaligned
        ldrb    r2, [r4, #14]   @ zero_extendqisi2
        strh    r1, [r3, #0]    @ unaligned
        strb    r2, [r3, #2]
        pop     {r4}
        bx      lr

src_aligned:
        push    {r4}
        movw    r3, #:lower16:known
        movt    r3, #:upper16:known
        mov     r4, r0
        ldmia   r3!, {r0, r1, r2}
        str     r0, [r4, #0]    @ unaligned
        str     r1, [r4, #4]    @ unaligned
        str     r2, [r4, #8]    @ unaligned
        ldrh    r2, [r3, #0]    @ unaligned
        ldrb    r3, [r3, #2]    @ zero_extendqisi2
        strh    r2, [r4, #12]   @ unaligned
        strb    r3, [r4, #14]
        pop     {r4}
        bx      lr

Whereas for "-mcpu=cortex-m4 -mthumb -Os -DAMOUNT=15", e.g.:

foo:
        add     r3, r1, #12
.L2:
        ldr     r2, [r1], #4    @ unaligned
        cmp     r1, r3
        str     r2, [r0], #4    @ unaligned
        bne     .L2
        ldrh    r3, [r1, #0]    @ unaligned
        strh    r3, [r0, #0]    @ unaligned
        ldrb    r3, [r1, #2]    @ zero_extendqisi2
        strb    r3, [r0, #2]
        bx      lr

Tested (alongside the first patch) with cross to ARM Linux. OK to apply?

Thanks,

Julian

ChangeLog

    gcc/
    * config/arm/arm.c (arm_block_move_unaligned_straight)
    (arm_adjust_block_mem, arm_block_move_unaligned_loop)
    (arm_movmemqi_unaligned): New.
    (arm_gen_movmemqi): Support unaligned block copies.

[ARM] Unaligned accesses for builtin memcpy [2/2]

Commit Message

Comments

Patch