2017-09-12 Richard Sandiford <richard.sandiford@linaro.org>
Alan Hayward <alan.hayward@arm.com>
David Sherwood <david.sherwood@arm.com>
gcc/
* defaults.h (SLOW_UNALIGNED_ACCESS): Delete.
* target.def (slow_unaligned_access): New hook.
* targhooks.h (default_slow_unaligned_access): Declare.
* targhooks.c (default_slow_unaligned_access): New function.
* doc/tm.texi.in (SLOW_UNALIGNED_ACCESS): Replace with...
(TARGET_SLOW_UNALIGNED_ACCESS): ...this.
* doc/tm.texi: Regenerate.
* config/alpha/alpha.h (SLOW_UNALIGNED_ACCESS): Delete.
* config/arm/arm.h (SLOW_UNALIGNED_ACCESS): Delete.
* config/i386/i386.h (SLOW_UNALIGNED_ACCESS): Delete commented-out
definition.
* config/powerpcspe/powerpcspe.h (SLOW_UNALIGNED_ACCESS): Delete.
* config/powerpcspe/powerpcspe.c (TARGET_SLOW_UNALIGNED_ACCESS):
Redefine.
(rs6000_slow_unaligned_access): New function.
(rs6000_emit_move): Use it instead of SLOW_UNALIGNED_ACCESS.
(expand_block_compare): Likewise.
(expand_strn_compare): Likewise.
(rs6000_rtx_costs): Likewise.
* config/riscv/riscv.h (SLOW_UNALIGNED_ACCESS): Delete.
(riscv_slow_unaligned_access): Likewise.
* config/riscv/riscv.c (riscv_slow_unaligned_access): Rename to...
(riscv_slow_unaligned_access_p): ...this and make static.
(riscv_option_override): Update accordingly.
(riscv_slow_unaligned_access): New function.
(TARGET_SLOW_UNALIGNED_ACCESS): Redefine.
* config/rs6000/rs6000.h (SLOW_UNALIGNED_ACCESS): Delete.
* config/rs6000/rs6000.c (TARGET_SLOW_UNALIGNED_ACCESS): Redefine.
(rs6000_slow_unaligned_access): New function.
(rs6000_emit_move): Use it instead of SLOW_UNALIGNED_ACCESS.
(rs6000_rtx_costs): Likewise.
* config/rs6000/rs6000-string.c (expand_block_compare)
(expand_strn_compare): Use targetm.slow_unaligned_access instead
of SLOW_UNALIGNED_ACCESS.
* config/tilegx/tilegx.h (SLOW_UNALIGNED_ACCESS): Delete.
* config/tilepro/tilepro.h (SLOW_UNALIGNED_ACCESS): Delete.
* calls.c (expand_call): Use targetm.slow_unaligned_access instead
of SLOW_UNALIGNED_ACCESS.
* expmed.c (simple_mem_bitfield_p): Likewise.
* expr.c (alignment_for_piecewise_move): Likewise.
(emit_group_load_1): Likewise.
(emit_group_store): Likewise.
(copy_blkmode_from_reg): Likewise.
(emit_push_insn): Likewise.
(expand_assignment): Likewise.
(store_field): Likewise.
(expand_expr_real_1): Likewise.
* gimple-fold.c (gimple_fold_builtin_memory_op): Likewise.
* lra-constraints.c (simplify_operand_subreg): Likewise.
* stor-layout.c (bit_field_mode_iterator::next_mode): Likewise.
* gimple-ssa-store-merging.c: Likewise in block comment at start
of file.
* tree-ssa-strlen.c: Include target.h.
(handle_builtin_memcmp): Use targetm.slow_unaligned_access instead
of SLOW_UNALIGNED_ACCESS.
* system.h (SLOW_UNALIGNED_ACCESS): Poison.
Co-Authored-By: Alan Hayward <alan.hayward@arm.com>
Co-Authored-By: David Sherwood <david.sherwood@arm.com>
From-SVN: r252009
+2017-09-12 Richard Sandiford <richard.sandiford@linaro.org>
+ Alan Hayward <alan.hayward@arm.com>
+ David Sherwood <david.sherwood@arm.com>
+
+ * defaults.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * target.def (slow_unaligned_access): New hook.
+ * targhooks.h (default_slow_unaligned_access): Declare.
+ * targhooks.c (default_slow_unaligned_access): New function.
+ * doc/tm.texi.in (SLOW_UNALIGNED_ACCESS): Replace with...
+ (TARGET_SLOW_UNALIGNED_ACCESS): ...this.
+ * doc/tm.texi: Regenerate.
+ * config/alpha/alpha.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * config/arm/arm.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * config/i386/i386.h (SLOW_UNALIGNED_ACCESS): Delete commented-out
+ definition.
+ * config/powerpcspe/powerpcspe.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * config/powerpcspe/powerpcspe.c (TARGET_SLOW_UNALIGNED_ACCESS):
+ Redefine.
+ (rs6000_slow_unaligned_access): New function.
+ (rs6000_emit_move): Use it instead of SLOW_UNALIGNED_ACCESS.
+ (expand_block_compare): Likewise.
+ (expand_strn_compare): Likewise.
+ (rs6000_rtx_costs): Likewise.
+ * config/riscv/riscv.h (SLOW_UNALIGNED_ACCESS): Delete.
+ (riscv_slow_unaligned_access): Likewise.
+ * config/riscv/riscv.c (riscv_slow_unaligned_access): Rename to...
+ (riscv_slow_unaligned_access_p): ...this and make static.
+ (riscv_option_override): Update accordingly.
+ (riscv_slow_unaligned_access): New function.
+ (TARGET_SLOW_UNALIGNED_ACCESS): Redefine.
+ * config/rs6000/rs6000.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * config/rs6000/rs6000.c (TARGET_SLOW_UNALIGNED_ACCESS): Redefine.
+ (rs6000_slow_unaligned_access): New function.
+ (rs6000_emit_move): Use it instead of SLOW_UNALIGNED_ACCESS.
+ (rs6000_rtx_costs): Likewise.
+ * config/rs6000/rs6000-string.c (expand_block_compare)
+ (expand_strn_compare): Use targetm.slow_unaligned_access instead
+ of SLOW_UNALIGNED_ACCESS.
+ * config/tilegx/tilegx.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * config/tilepro/tilepro.h (SLOW_UNALIGNED_ACCESS): Delete.
+ * calls.c (expand_call): Use targetm.slow_unaligned_access instead
+ of SLOW_UNALIGNED_ACCESS.
+ * expmed.c (simple_mem_bitfield_p): Likewise.
+ * expr.c (alignment_for_piecewise_move): Likewise.
+ (emit_group_load_1): Likewise.
+ (emit_group_store): Likewise.
+ (copy_blkmode_from_reg): Likewise.
+ (emit_push_insn): Likewise.
+ (expand_assignment): Likewise.
+ (store_field): Likewise.
+ (expand_expr_real_1): Likewise.
+ * gimple-fold.c (gimple_fold_builtin_memory_op): Likewise.
+ * lra-constraints.c (simplify_operand_subreg): Likewise.
+ * stor-layout.c (bit_field_mode_iterator::next_mode): Likewise.
+ * gimple-ssa-store-merging.c: Likewise in block comment at start
+ of file.
+ * tree-ssa-strlen.c: Include target.h.
+ (handle_builtin_memcmp): Use targetm.slow_unaligned_access instead
+ of SLOW_UNALIGNED_ACCESS.
+ * system.h (SLOW_UNALIGNED_ACCESS): Poison.
+
2017-09-12 Richard Sandiford <richard.sandiford@linaro.org>
PR rtl-optimization/82185
&& target
&& MEM_P (target)
&& !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
- && SLOW_UNALIGNED_ACCESS (TYPE_MODE (rettype),
- MEM_ALIGN (target))))
+ && targetm.slow_unaligned_access (TYPE_MODE (rettype),
+ MEM_ALIGN (target))))
structure_value_addr = XEXP (target, 0);
else
{
#define STRICT_ALIGNMENT 1
-/* Set this nonzero if unaligned move instructions are extremely slow.
-
- On the Alpha, they trap. */
-
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
-
/* Standard register usage. */
/* Number of actual hardware registers.
/* Nonzero if access to memory by bytes is slow and undesirable. */
#define SLOW_BYTE_ACCESS 0
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
-
/* Immediate shift counts are truncated by the output routines (or was it
the assembler?). Shift counts in a register are truncated by ARM. Note
that the native compiler puts too large (> 32) immediate shift counts
/* Nonzero if access to memory by shorts is slow and undesirable. */
#define SLOW_SHORT_ACCESS 0
-/* Define this macro to be the value 1 if unaligned accesses have a
- cost many times greater than aligned accesses, for example if they
- are emulated in a trap handler.
-
- When this macro is nonzero, the compiler will act as if
- `STRICT_ALIGNMENT' were nonzero when generating code for block
- moves. This can cause significantly more instructions to be
- produced. Therefore, do not set this macro nonzero if unaligned
- accesses only add a cycle or two to the time for a memory access.
-
- If the value of this macro is always zero, it need not be defined. */
-
-/* #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 0 */
-
/* Define this macro if it is as good or better to call a constant
function address than to call an address kept in a register.
#undef TARGET_HARD_REGNO_CALL_PART_CLOBBERED
#define TARGET_HARD_REGNO_CALL_PART_CLOBBERED \
rs6000_hard_regno_call_part_clobbered
+
+#undef TARGET_SLOW_UNALIGNED_ACCESS
+#define TARGET_SLOW_UNALIGNED_ACCESS rs6000_slow_unaligned_access
\f
/* Processor table. */
return align;
}
+/* Implement TARGET_SLOW_UNALIGNED_ACCESS. Altivec vector memory
+ instructions simply ignore the low bits; SPE vector memory
+ instructions trap on unaligned accesses; VSX memory instructions are
+ aligned to 4 or 8 bytes. */
+
+static bool
+rs6000_slow_unaligned_access (machine_mode mode, unsigned int align)
+{
+ return (STRICT_ALIGNMENT
+ || (!TARGET_EFFICIENT_UNALIGNED_VSX
+ && ((SCALAR_FLOAT_MODE_NOT_VECTOR_P (mode) && align < 32)
+ || ((VECTOR_MODE_P (mode) || FLOAT128_VECTOR_P (mode))
+ && (int) align < VECTOR_ALIGN (mode)))));
+}
+
/* Previous GCC releases forced all vector types to have 16-byte alignment. */
bool
if (GET_CODE (operands[0]) == MEM
&& GET_CODE (operands[1]) == MEM
&& mode == DImode
- && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
- || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
- && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
- ? 32 : MEM_ALIGN (operands[0])))
- || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
- ? 32
- : MEM_ALIGN (operands[1]))))
+ && (rs6000_slow_unaligned_access (DImode, MEM_ALIGN (operands[0]))
+ || rs6000_slow_unaligned_access (DImode, MEM_ALIGN (operands[1])))
+ && ! (rs6000_slow_unaligned_access (SImode,
+ (MEM_ALIGN (operands[0]) > 32
+ ? 32 : MEM_ALIGN (operands[0])))
+ || rs6000_slow_unaligned_access (SImode,
+ (MEM_ALIGN (operands[1]) > 32
+ ? 32 : MEM_ALIGN (operands[1]))))
&& ! MEM_VOLATILE_P (operands [0])
&& ! MEM_VOLATILE_P (operands [1]))
{
unsigned int base_align = UINTVAL (align_rtx) / BITS_PER_UNIT;
- /* SLOW_UNALIGNED_ACCESS -- don't do unaligned stuff. */
- if (SLOW_UNALIGNED_ACCESS (word_mode, MEM_ALIGN (orig_src1))
- || SLOW_UNALIGNED_ACCESS (word_mode, MEM_ALIGN (orig_src2)))
+ /* rs6000_slow_unaligned_access -- don't do unaligned stuff. */
+ if (rs6000_slow_unaligned_access (word_mode, MEM_ALIGN (orig_src1))
+ || rs6000_slow_unaligned_access (word_mode, MEM_ALIGN (orig_src2)))
return false;
gcc_assert (GET_MODE (target) == SImode);
int align1 = MEM_ALIGN (orig_src1) / BITS_PER_UNIT;
int align2 = MEM_ALIGN (orig_src2) / BITS_PER_UNIT;
- /* SLOW_UNALIGNED_ACCESS -- don't do unaligned stuff. */
- if (SLOW_UNALIGNED_ACCESS (word_mode, align1)
- || SLOW_UNALIGNED_ACCESS (word_mode, align2))
+ /* rs6000_slow_unaligned_access -- don't do unaligned stuff. */
+ if (rs6000_slow_unaligned_access (word_mode, align1)
+ || rs6000_slow_unaligned_access (word_mode, align2))
return false;
gcc_assert (GET_MODE (target) == SImode);
than generating address, e.g., (plus (reg) (const)).
L1 cache latency is about two instructions. */
*total = !speed ? COSTS_N_INSNS (1) + 1 : COSTS_N_INSNS (2);
- if (SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (x)))
+ if (rs6000_slow_unaligned_access (mode, MEM_ALIGN (x)))
*total += COSTS_N_INSNS (100);
return true;
/* Nonzero if move instructions will actually fail to work
when given unaligned data. */
#define STRICT_ALIGNMENT 0
-
-/* Define this macro to be the value 1 if unaligned accesses have a cost
- many times greater than aligned accesses, for example if they are
- emulated in a trap handler. */
-/* Altivec vector memory instructions simply ignore the low bits; SPE vector
- memory instructions trap on unaligned accesses; VSX memory instructions are
- aligned to 4 or 8 bytes. */
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) \
- (STRICT_ALIGNMENT \
- || (!TARGET_EFFICIENT_UNALIGNED_VSX \
- && ((SCALAR_FLOAT_MODE_NOT_VECTOR_P (MODE) && (ALIGN) < 32) \
- || ((VECTOR_MODE_P (MODE) || FLOAT128_VECTOR_P (MODE)) \
- && (int) (ALIGN) < VECTOR_ALIGN (MODE)))))
-
\f
/* Standard register usage. */
/* Global variables for machine-dependent things. */
/* Whether unaligned accesses execute very slowly. */
-bool riscv_slow_unaligned_access;
+static bool riscv_slow_unaligned_access_p;
/* Which tuning parameters to use. */
static const struct riscv_tune_info *tune_info;
/* Use -mtune's setting for slow_unaligned_access, even when optimizing
for size. For architectures that trap and emulate unaligned accesses,
the performance cost is too great, even for -Os. */
- riscv_slow_unaligned_access = (cpu->tune_info->slow_unaligned_access
- || TARGET_STRICT_ALIGN);
+ riscv_slow_unaligned_access_p = (cpu->tune_info->slow_unaligned_access
+ || TARGET_STRICT_ALIGN);
/* If the user hasn't specified a branch cost, use the processor's
default. */
return recog_memoized (insn) >= 0 && get_attr_cannot_copy (insn);
}
+/* Implement TARGET_SLOW_UNALIGNED_ACCESS. */
+
+static bool
+riscv_slow_unaligned_access (machine_mode, unsigned int)
+{
+ return riscv_slow_unaligned_access_p;
+}
+
/* Initialize the GCC target structure. */
#undef TARGET_ASM_ALIGNED_HI_OP
#define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
#undef TARGET_MODES_TIEABLE_P
#define TARGET_MODES_TIEABLE_P riscv_modes_tieable_p
+#undef TARGET_SLOW_UNALIGNED_ACCESS
+#define TARGET_SLOW_UNALIGNED_ACCESS riscv_slow_unaligned_access
+
struct gcc_target targetm = TARGET_INITIALIZER;
#include "gt-riscv.h"
of the privileged architecture. */
#define STRICT_ALIGNMENT TARGET_STRICT_ALIGN
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) riscv_slow_unaligned_access
-
/* Define this if you wish to imitate the way many other C compilers
handle alignment of bitfields and the structures that contain
them.
#ifndef USED_FOR_TARGET
extern const enum reg_class riscv_regno_to_class[];
-extern bool riscv_slow_unaligned_access;
#endif
#define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) \
#include "explow.h"
#include "expr.h"
#include "output.h"
+#include "target.h"
/* Expand a block clear operation, and return 1 if successful. Return 0
if we should let the compiler generate normal code.
unsigned int base_align = UINTVAL (align_rtx) / BITS_PER_UNIT;
- /* SLOW_UNALIGNED_ACCESS -- don't do unaligned stuff. */
- if (SLOW_UNALIGNED_ACCESS (word_mode, MEM_ALIGN (orig_src1))
- || SLOW_UNALIGNED_ACCESS (word_mode, MEM_ALIGN (orig_src2)))
+ /* targetm.slow_unaligned_access -- don't do unaligned stuff. */
+ if (targetm.slow_unaligned_access (word_mode, MEM_ALIGN (orig_src1))
+ || targetm.slow_unaligned_access (word_mode, MEM_ALIGN (orig_src2)))
return false;
gcc_assert (GET_MODE (target) == SImode);
int align1 = MEM_ALIGN (orig_src1) / BITS_PER_UNIT;
int align2 = MEM_ALIGN (orig_src2) / BITS_PER_UNIT;
- /* SLOW_UNALIGNED_ACCESS -- don't do unaligned stuff. */
- if (SLOW_UNALIGNED_ACCESS (word_mode, align1)
- || SLOW_UNALIGNED_ACCESS (word_mode, align2))
+ /* targetm.slow_unaligned_access -- don't do unaligned stuff. */
+ if (targetm.slow_unaligned_access (word_mode, align1)
+ || targetm.slow_unaligned_access (word_mode, align2))
return false;
gcc_assert (GET_MODE (target) == SImode);
#undef TARGET_HARD_REGNO_CALL_PART_CLOBBERED
#define TARGET_HARD_REGNO_CALL_PART_CLOBBERED \
rs6000_hard_regno_call_part_clobbered
+
+#undef TARGET_SLOW_UNALIGNED_ACCESS
+#define TARGET_SLOW_UNALIGNED_ACCESS rs6000_slow_unaligned_access
\f
/* Processor table. */
return align;
}
+/* Implement TARGET_SLOW_UNALIGNED_ACCESS. Altivec vector memory
+ instructions simply ignore the low bits; VSX memory instructions
+ are aligned to 4 or 8 bytes. */
+
+static bool
+rs6000_slow_unaligned_access (machine_mode mode, unsigned int align)
+{
+ return (STRICT_ALIGNMENT
+ || (!TARGET_EFFICIENT_UNALIGNED_VSX
+ && ((SCALAR_FLOAT_MODE_NOT_VECTOR_P (mode) && align < 32)
+ || ((VECTOR_MODE_P (mode) || FLOAT128_VECTOR_P (mode))
+ && (int) align < VECTOR_ALIGN (mode)))));
+}
+
/* Previous GCC releases forced all vector types to have 16-byte alignment. */
bool
if (GET_CODE (operands[0]) == MEM
&& GET_CODE (operands[1]) == MEM
&& mode == DImode
- && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
- || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
- && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
- ? 32 : MEM_ALIGN (operands[0])))
- || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
- ? 32
- : MEM_ALIGN (operands[1]))))
+ && (rs6000_slow_unaligned_access (DImode, MEM_ALIGN (operands[0]))
+ || rs6000_slow_unaligned_access (DImode, MEM_ALIGN (operands[1])))
+ && ! (rs6000_slow_unaligned_access (SImode,
+ (MEM_ALIGN (operands[0]) > 32
+ ? 32 : MEM_ALIGN (operands[0])))
+ || rs6000_slow_unaligned_access (SImode,
+ (MEM_ALIGN (operands[1]) > 32
+ ? 32 : MEM_ALIGN (operands[1]))))
&& ! MEM_VOLATILE_P (operands [0])
&& ! MEM_VOLATILE_P (operands [1]))
{
than generating address, e.g., (plus (reg) (const)).
L1 cache latency is about two instructions. */
*total = !speed ? COSTS_N_INSNS (1) + 1 : COSTS_N_INSNS (2);
- if (SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (x)))
+ if (rs6000_slow_unaligned_access (mode, MEM_ALIGN (x)))
*total += COSTS_N_INSNS (100);
return true;
/* Nonzero if move instructions will actually fail to work
when given unaligned data. */
#define STRICT_ALIGNMENT 0
-
-/* Define this macro to be the value 1 if unaligned accesses have a cost
- many times greater than aligned accesses, for example if they are
- emulated in a trap handler. */
-/* Altivec vector memory instructions simply ignore the low bits; VSX memory
- instructions are aligned to 4 or 8 bytes. */
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) \
- (STRICT_ALIGNMENT \
- || (!TARGET_EFFICIENT_UNALIGNED_VSX \
- && ((SCALAR_FLOAT_MODE_NOT_VECTOR_P (MODE) && (ALIGN) < 32) \
- || ((VECTOR_MODE_P (MODE) || FLOAT128_VECTOR_P (MODE)) \
- && (int) (ALIGN) < VECTOR_ALIGN (MODE)))))
-
\f
/* Standard register usage. */
#define BIGGEST_FIELD_ALIGNMENT 128
#define WIDEST_HARDWARE_FP_SIZE 64
-/* Unaligned moves trap and are very slow. */
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
-
/* Make strings word-aligned so strcpy from constants will be
faster. */
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
#define FASTEST_ALIGNMENT 32
#define BIGGEST_FIELD_ALIGNMENT 64
-/* Unaligned moves trap and are very slow. */
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
-
/* Make strings word-aligned so strcpy from constants will be
faster. */
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
#define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT
#endif
-#ifndef SLOW_UNALIGNED_ACCESS
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
-#endif
-
/* For most ports anything that evaluates to a constant symbolic
or integer value is acceptable as a constant address. */
#ifndef CONSTANT_ADDRESS_P
other fields in the same word of the structure, but to different bytes.
@end defmac
-@defmac SLOW_UNALIGNED_ACCESS (@var{mode}, @var{alignment})
-Define this macro to be the value 1 if memory accesses described by the
+@deftypefn {Target Hook} bool TARGET_SLOW_UNALIGNED_ACCESS (machine_mode @var{mode}, unsigned int @var{align})
+This hook returns true if memory accesses described by the
@var{mode} and @var{alignment} parameters have a cost many times greater
-than aligned accesses, for example if they are emulated in a trap
-handler. This macro is invoked only for unaligned accesses, i.e. when
+than aligned accesses, for example if they are emulated in a trap handler.
+This hook is invoked only for unaligned accesses, i.e. when
@code{@var{alignment} < GET_MODE_ALIGNMENT (@var{mode})}.
-When this macro is nonzero, the compiler will act as if
-@code{STRICT_ALIGNMENT} were nonzero when generating code for block
+When this hook returns true, the compiler will act as if
+@code{STRICT_ALIGNMENT} were true when generating code for block
moves. This can cause significantly more instructions to be produced.
-Therefore, do not set this macro nonzero if unaligned accesses only add a
-cycle or two to the time for a memory access.
+Therefore, do not make this hook return true if unaligned accesses only
+add a cycle or two to the time for a memory access.
-If the value of this macro is always zero, it need not be defined. If
-this macro is defined, it should produce a nonzero value when
-@code{STRICT_ALIGNMENT} is nonzero.
-@end defmac
+The hook must return true whenever @code{STRICT_ALIGNMENT} is true.
+The default implementation returns @code{STRICT_ALIGNMENT}.
+@end deftypefn
@defmac MOVE_RATIO (@var{speed})
The threshold of number of scalar memory-to-memory move insns, @emph{below}
other fields in the same word of the structure, but to different bytes.
@end defmac
-@defmac SLOW_UNALIGNED_ACCESS (@var{mode}, @var{alignment})
-Define this macro to be the value 1 if memory accesses described by the
-@var{mode} and @var{alignment} parameters have a cost many times greater
-than aligned accesses, for example if they are emulated in a trap
-handler. This macro is invoked only for unaligned accesses, i.e. when
-@code{@var{alignment} < GET_MODE_ALIGNMENT (@var{mode})}.
-
-When this macro is nonzero, the compiler will act as if
-@code{STRICT_ALIGNMENT} were nonzero when generating code for block
-moves. This can cause significantly more instructions to be produced.
-Therefore, do not set this macro nonzero if unaligned accesses only add a
-cycle or two to the time for a memory access.
-
-If the value of this macro is always zero, it need not be defined. If
-this macro is defined, it should produce a nonzero value when
-@code{STRICT_ALIGNMENT} is nonzero.
-@end defmac
+@hook TARGET_SLOW_UNALIGNED_ACCESS
@defmac MOVE_RATIO (@var{speed})
The threshold of number of scalar memory-to-memory move insns, @emph{below}
return (MEM_P (op0)
&& bitnum % BITS_PER_UNIT == 0
&& bitsize == GET_MODE_BITSIZE (mode)
- && (!SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (op0))
+ && (!targetm.slow_unaligned_access (mode, MEM_ALIGN (op0))
|| (bitnum % GET_MODE_ALIGNMENT (mode) == 0
&& MEM_ALIGN (op0) >= GET_MODE_ALIGNMENT (mode))));
}
{
tmode = mode_iter.require ();
if (GET_MODE_SIZE (tmode) > max_pieces
- || SLOW_UNALIGNED_ACCESS (tmode, align))
+ || targetm.slow_unaligned_access (tmode, align))
break;
xmode = tmode;
}
/* Optimize the access just a bit. */
if (MEM_P (src)
- && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (src))
+ && (! targetm.slow_unaligned_access (mode, MEM_ALIGN (src))
|| MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode))
&& bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
&& bytelen == GET_MODE_SIZE (mode))
/* Optimize the access just a bit. */
else if (MEM_P (dest)
- && (!SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (dest))
+ && (!targetm.slow_unaligned_access (mode, MEM_ALIGN (dest))
|| MEM_ALIGN (dest) >= GET_MODE_ALIGNMENT (mode))
&& bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
&& bytelen == GET_MODE_SIZE (mode))
/* We can use a single move if we have an exact mode for the size. */
else if (MEM_P (target)
- && (!SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (target))
+ && (!targetm.slow_unaligned_access (mode, MEM_ALIGN (target))
|| MEM_ALIGN (target) >= GET_MODE_ALIGNMENT (mode))
&& bytes == GET_MODE_SIZE (mode))
{
/* Here we avoid the case of a structure whose weak alignment
forces many pushes of a small amount of data,
and such small pushes do rounding that causes trouble. */
- && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
+ && ((!targetm.slow_unaligned_access (word_mode, align))
|| align >= BIGGEST_ALIGNMENT
|| (PUSH_ROUNDING (align / BITS_PER_UNIT)
== (align / BITS_PER_UNIT)))
< GET_MODE_ALIGNMENT (mode))
&& (((icode = optab_handler (movmisalign_optab, mode))
!= CODE_FOR_nothing)
- || SLOW_UNALIGNED_ACCESS (mode, align)))
+ || targetm.slow_unaligned_access (mode, align)))
{
rtx reg, mem;
|| (mode != BLKmode
&& ((((MEM_ALIGN (target) < GET_MODE_ALIGNMENT (mode))
|| bitpos % GET_MODE_ALIGNMENT (mode))
- && SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (target)))
+ && targetm.slow_unaligned_access (mode, MEM_ALIGN (target)))
|| (bitpos % BITS_PER_UNIT != 0)))
|| (bitsize >= 0 && mode != BLKmode
&& GET_MODE_BITSIZE (mode) > bitsize)
expand_insn (icode, 2, ops);
temp = ops[0].value;
}
- else if (SLOW_UNALIGNED_ACCESS (mode, align))
+ else if (targetm.slow_unaligned_access (mode, align))
temp = extract_bit_field (temp, GET_MODE_BITSIZE (mode),
0, TYPE_UNSIGNED (TREE_TYPE (exp)),
(modifier == EXPAND_STACK_PARM
&& ((modifier == EXPAND_CONST_ADDRESS
|| modifier == EXPAND_INITIALIZER)
? STRICT_ALIGNMENT
- : SLOW_UNALIGNED_ACCESS (mode1, MEM_ALIGN (op0))))
+ : targetm.slow_unaligned_access (mode1,
+ MEM_ALIGN (op0))))
|| (bitpos % BITS_PER_UNIT != 0)))
/* If the type and the field are a constant size and the
size of the type isn't the same size as the bitfield,
/* If the destination pointer is not aligned we must be able
to emit an unaligned store. */
&& (dest_align >= GET_MODE_ALIGNMENT (mode)
- || !SLOW_UNALIGNED_ACCESS (mode, dest_align)
+ || !targetm.slow_unaligned_access (mode, dest_align)
|| (optab_handler (movmisalign_optab, mode)
!= CODE_FOR_nothing)))
{
if (tem)
srcmem = tem;
else if (src_align < GET_MODE_ALIGNMENT (mode)
- && SLOW_UNALIGNED_ACCESS (mode, src_align)
+ && targetm.slow_unaligned_access (mode, src_align)
&& (optab_handler (movmisalign_optab, mode)
== CODE_FOR_nothing))
srcmem = NULL_TREE;
of a size that is a power of 2. For example it can try to emit a 40-bit
store as a 32-bit store followed by an 8-bit store.
We try to emit as wide stores as we can while respecting STRICT_ALIGNMENT or
- SLOW_UNALIGNED_ACCESS rules.
+ TARGET_SLOW_UNALIGNED_ACCESS rules.
Note on endianness and example:
Consider 2 contiguous 16-bit stores followed by 2 contiguous 8-bit stores:
&& GET_MODE_SIZE (innermode) <= UNITS_PER_WORD
&& WORD_REGISTER_OPERATIONS)
&& (!(MEM_ALIGN (subst) < GET_MODE_ALIGNMENT (mode)
- && SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (subst)))
+ && targetm.slow_unaligned_access (mode, MEM_ALIGN (subst)))
|| (MEM_ALIGN (reg) < GET_MODE_ALIGNMENT (innermode)
- && SLOW_UNALIGNED_ACCESS (innermode, MEM_ALIGN (reg)))))
+ && targetm.slow_unaligned_access (innermode,
+ MEM_ALIGN (reg)))))
return true;
*curr_id->operand_loc[nop] = operand;
/* Stop if the mode requires too much alignment. */
if (GET_MODE_ALIGNMENT (mode) > m_align
- && SLOW_UNALIGNED_ACCESS (mode, m_align))
+ && targetm.slow_unaligned_access (mode, m_align))
break;
*out_mode = mode;
CLEAR_BY_PIECES_P MOVE_BY_PIECES_P SET_BY_PIECES_P \
STORE_BY_PIECES_P TARGET_FLT_EVAL_METHOD \
HARD_REGNO_CALL_PART_CLOBBERED HARD_REGNO_MODE_OK \
- MODES_TIEABLE_P FUNCTION_ARG_PADDING
+ MODES_TIEABLE_P FUNCTION_ARG_PADDING SLOW_UNALIGNED_ACCESS
/* Target macros only used for code built for the target, that have
moved to libgcc-tm.h or have never been present elsewhere. */
int, (machine_mode mode),
default_compare_by_pieces_branch_ratio)
+DEFHOOK
+(slow_unaligned_access,
+ "This hook returns true if memory accesses described by the\n\
+@var{mode} and @var{alignment} parameters have a cost many times greater\n\
+than aligned accesses, for example if they are emulated in a trap handler.\n\
+This hook is invoked only for unaligned accesses, i.e. when\n\
+@code{@var{alignment} < GET_MODE_ALIGNMENT (@var{mode})}.\n\
+\n\
+When this hook returns true, the compiler will act as if\n\
+@code{STRICT_ALIGNMENT} were true when generating code for block\n\
+moves. This can cause significantly more instructions to be produced.\n\
+Therefore, do not make this hook return true if unaligned accesses only\n\
+add a cycle or two to the time for a memory access.\n\
+\n\
+The hook must return true whenever @code{STRICT_ALIGNMENT} is true.\n\
+The default implementation returns @code{STRICT_ALIGNMENT}.",
+ bool, (machine_mode mode, unsigned int align),
+ default_slow_unaligned_access)
+
DEFHOOK
(optab_supported_p,
"Return true if the optimizers should use optab @var{op} with\n\
#endif
}
+/* The default implementation of TARGET_SLOW_UNALIGNED_ACCESS. */
+
+bool
+default_slow_unaligned_access (machine_mode, unsigned int)
+{
+ return STRICT_ALIGNMENT;
+}
+
/* For hooks which use the MOVE_RATIO macro, this gives the legacy default
behavior. SPEED_P is true if we are compiling for speed. */
extern int default_memory_move_cost (machine_mode, reg_class_t, bool);
extern int default_register_move_cost (machine_mode, reg_class_t,
reg_class_t);
+extern bool default_slow_unaligned_access (machine_mode, unsigned int);
extern bool default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT,
unsigned int,
#include "ipa-chkp.h"
#include "tree-hash-traits.h"
#include "builtins.h"
+#include "target.h"
/* A vector indexed by SSA_NAME_VERSION. 0 means unknown, positive value
is an index into strinfo vector, negative value stands for
unsigned align = MIN (align1, align2);
scalar_int_mode mode;
if (int_mode_for_size (leni, 1).exists (&mode)
- && (align >= leni || !SLOW_UNALIGNED_ACCESS (mode, align)))
+ && (align >= leni || !targetm.slow_unaligned_access (mode, align)))
{
location_t loc = gimple_location (stmt2);
tree type, off;
projects / gcc.git / commitdiff