From aacd3885eb07280eed4558f0dacad4d977052dc2 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Sat, 18 Feb 2006 22:06:53 +0000 Subject: re PR target/9703 ([arm] Accessing data through constant pool more times could be solved in less instructions) * cselib.c (cselib_init): Change RTX_SIZE to RTX_CODE_SIZE. * emit-rtl.c (copy_rtx_if_shared_1): Use shallow_copy_rtx. (copy_insn_1): Likewise. Don't copy each field individually. Reindent. * read-rtl.c (apply_macro_to_rtx): Use RTX_CODE_SIZE instead of RTX_SIZE. * reload1.c (eliminate_regs): Use shallow_copy_rtx. * rtl.c (rtx_size): Rename variable to... (rtx_code_size): ...this. (rtx_size): New function. (rtx_alloc_stat): Use RTX_CODE_SIZE instead of RTX_SIZE. (copy_rtx): Use shallow_copy_rtx. Don't copy each field individually. Reindent. (shallow_copy_rtx_stat): Use rtx_size instead of RTX_SIZE. * rtl.h (rtx_code_size): New variable. (rtx_size): Change from a variable to a function. (RTX_SIZE): Rename to... (RTX_CODE_SIZE): ...this. PR target/9703 PR tree-optimization/17106 * doc/tm.texi (TARGET_USE_BLOCKS_FOR_CONSTANT_P): Document. (Anchored Addresses): New section. * doc/invoke.texi (-fsection-anchors): Document. * doc/rtl.texi (SYMBOL_REF_IN_BLOCK_P, SYMBOL_FLAG_IN_BLOCK): Likewise. (SYMBOL_REF_ANCHOR_P, SYMBOL_FLAG_ANCHOR): Likewise. (SYMBOL_REF_BLOCK, SYMBOL_REF_BLOCK_OFFSET): Likewise. * hooks.c (hook_bool_mode_rtx_false): New function. * hooks.h (hook_bool_mode_rtx_false): Declare. * gengtype.c (create_optional_field): New function. (adjust_field_rtx_def): Add the "block_sym" field for SYMBOL_REFs when SYMBOL_REF_IN_BLOCK_P is true. * target.h (output_anchor, use_blocks_for_constant_p): New hooks. (min_anchor_offset, max_anchor_offset): Likewise. (use_anchors_for_symbol_p): New hook. * toplev.c (compile_file): Call output_object_blocks. (target_supports_section_anchors_p): New function. (process_options): Check that -fsection-anchors is only used on targets that support it and when -funit-at-a-time is in effect. * tree-ssa-loop-ivopts.c (prepare_decl_rtl): Only create DECL_RTL if the decl doesn't have one. * dwarf2out.c: Remove instantiations of VEC(rtx,gc). * expr.c (emit_move_multi_word, emit_move_insn): Pass the result of force_const_mem through use_anchored_address. (expand_expr_constant): New function. (expand_expr_addr_expr_1): Call it. Use the same modifier when calling expand_expr for INDIRECT_REF. (expand_expr_real_1): Pass DECL_RTL through use_anchored_address for all modifiers except EXPAND_INITIALIZER. Use expand_expr_constant. * expr.h (use_anchored_address): Declare. * loop-unroll.c: Don't declare rtx vectors here. * explow.c: Include output.h. (validize_mem): Call use_anchored_address. (use_anchored_address): New function. * common.opt (-fsection-anchors): New switch. * varasm.c (object_block_htab, anchor_labelno): New variables. (hash_section, object_block_entry_eq, object_block_entry_hash) (use_object_blocks_p, get_block_for_section, create_block_symbol) (use_blocks_for_decl_p, change_symbol_section): New functions. (get_variable_section): New function, split out from assemble_variable. (make_decl_rtl): Create a block symbol if use_object_blocks_p and use_blocks_for_decl_p say so. Use change_symbol_section if the symbol has already been created. (assemble_variable_contents): New function, split out from... (assemble_variable): ...here. Don't output any code for block symbols; just pass them to place_block_symbol. Use get_variable_section and assemble_variable_contents. (get_constant_alignment, get_constant_section, get_constant_size): New functions, split from output_constant_def_contents. (build_constant_desc): Create a block symbol if use_object_blocks_p says so. Or into SYMBOL_REF_FLAGS. (assemble_constant_contents): New function, split from... (output_constant_def_contents): ...here. Don't output any code for block symbols; just pass them to place_section_symbol. Use get_constant_section and get_constant_alignment. (force_const_mem): Create a block symbol if use_object_blocks_p and use_blocks_for_constant_p say so. Or into SYMBOL_REF_FLAGS. (output_constant_pool_1): Add an explicit alignment argument. Don't switch sections here. (output_constant_pool): Adjust call to output_constant_pool_1. Switch sections here instead. Don't output anything for block symbols; just pass them to place_block_symbol. (init_varasm_once): Initialize object_block_htab. (default_encode_section_info): Keep the old SYMBOL_FLAG_IN_BLOCK. (default_asm_output_anchor, default_use_aenchors_for_symbol_p) (place_block_symbol, get_section_anchor, output_object_block) (output_object_block_htab, output_object_blocks): New functions. * target-def.h (TARGET_ASM_OUTPUT_ANCHOR): New macro. (TARGET_ASM_OUT): Include it. (TARGET_USE_BLOCKS_FOR_CONSTANT_P): New macro. (TARGET_MIN_ANCHOR_OFFSET, TARGET_MAX_ANCHOR_OFFSET): New macros. (TARGET_USE_ANCHORS_FOR_SYMBOL_P): New macro. (TARGET_INITIALIZER): Include them. * rtl.c (rtl_check_failed_block_symbol): New function. * rtl.h: Include vec.h. Declare heap and gc rtx vectors. (block_symbol, object_block): New structures. (rtx_def): Add a block_symbol field to the union. (BLOCK_SYMBOL_CHECK): New macro. (rtl_check_failed_block_symbol): Declare. (SYMBOL_FLAG_IN_BLOCK, SYMBOL_FLAG_ANCHOR): New SYMBOL_REF flags. (SYMBOL_REF_IN_BLOCK_P, SYMBOL_REF_ANCHOR_P): New predicates. (SYMBOL_FLAG_MACH_DEP_SHIFT): Bump by 2. (SYMBOL_REF_BLOCK, SYMBOL_REF_BLOCK_OFFSET): New accessors. * output.h (output_section_symbols): Declare. (object_block): Name structure. (place_section_symbol, get_section_anchor, default_asm_output_anchor) (default_use_anchors_for_symbol_p): Declare. * Makefile.in (RTL_BASE_H): Add vec.h. (explow.o): Depend on output.h. * config/rs6000/rs6000.c (TARGET_MIN_ANCHOR_OFFSET): Override default. (TARGET_MAX_ANCHOR_OFFSET): Likewise. (TARGET_USE_BLOCKS_FOR_CONSTANT_P): Likewise. (rs6000_use_blocks_for_constant_p): New function. From-SVN: r111254 --- gcc/doc/invoke.texi | 31 ++++++++++++++++++++- gcc/doc/rtl.texi | 29 ++++++++++++++++++++ gcc/doc/tm.texi | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 138 insertions(+), 1 deletion(-) (limited to 'gcc/doc') diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 1ddd4fe..4b8bf59 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -333,7 +333,7 @@ Objective-C and Objective-C++ Dialects}. -fsched-stalled-insns=@var{n} -fsched-stalled-insns-dep=@var{n} @gol -fsched2-use-superblocks @gol -fsched2-use-traces -freschedule-modulo-scheduled-loops @gol --fsignaling-nans -fsingle-precision-constant @gol +-fsection-anchors -fsignaling-nans -fsingle-precision-constant @gol -fstack-protector -fstack-protector-all @gol -fstrength-reduce -fstrict-aliasing -ftracer -fthread-jumps @gol -funroll-all-loops -funroll-loops -fpeel-loops @gol @@ -5773,6 +5773,35 @@ If a guard check fails, an error message is printed and the program exits. @item -fstack-protector-all Like @option{-fstack-protector} except that all functions are protected. +@item -fsection-anchors +@opindex fsection-anchors +Try to reduce the number of symbolic address calculations by using +shared ``anchor'' symbols to address nearby objects. This transformation +can help to reduce the number of GOT entries and GOT accesses on some +targets. + +For example, the implementation of the following function @code{foo}: + +@smallexample +static int a, b, c; +int foo (void) @{ return a + b + c; @} +@end smallexample + +would usually calculate the addresses of all three variables, but if you +compile it with @option{-fsection-anchors}, it will access the variables +from a common anchor point instead. The effect is similar to the +following pseudocode (which isn't valid C): + +@smallexample +int foo (void) +@{ + register int *xr = &x; + return xr[&a - &x] + xr[&b - &x] + xr[&c - &x]; +@} +@end smallexample + +Not all targets support this option. + @item --param @var{name}=@var{value} @opindex param In some places, GCC uses various constants to control the amount of diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi index c9f7c87..de4a8e73 100644 --- a/gcc/doc/rtl.texi +++ b/gcc/doc/rtl.texi @@ -501,11 +501,40 @@ See @code{TARGET_IN_SMALL_DATA_P}. This is a multi-bit field accessor that returns the @code{tls_model} to be used for a thread-local storage symbol. It returns zero for non-thread-local symbols. + +@findex SYMBOL_REF_IN_BLOCK_P +@findex SYMBOL_FLAG_IN_BLOCK +@item SYMBOL_FLAG_IN_BLOCK +Set if the symbol has been assigned to an @code{object_block} structure. +@code{SYMBOL_REF_BLOCK} and @code{SYMBOL_REF_BLOCK_OFFSET} provide more +information about such symbols. + +@findex SYMBOL_REF_ANCHOR_P +@findex SYMBOL_FLAG_ANCHOR +@cindex @option{-fsection-anchors} +@item SYMBOL_FLAG_ANCHOR +Set if the symbol is used as a section anchor. ``Section anchors'' +are symbols that have a known position within an @code{object_block} +and that can be used to access nearby members of that block. +They are used to implement @option{-fsection-anchors}. + +If this flag is set, then @code{SYMBOL_FLAG_IN_BLOCK} will be too. @end table Bits beginning with @code{SYMBOL_FLAG_MACH_DEP} are available for the target's use. @end table + +@findex SYMBOL_REF_BLOCK +@item SYMBOL_REF_BLOCK (@var{x}) +If @samp{SYMBOL_REF_IN_BLOCK_P (@var{x})}, this is the @samp{object_block} +structure to which the symbol belongs. The value is always nonnull. + +@findex SYMBOL_REF_BLOCK_OFFSET +@item SYMBOL_REF_BLOCK_OFFSET (@var{x}) +If @samp{SYMBOL_REF_IN_BLOCK_P (@var{x})}, this is the offset of @var{x} +from the first object in @samp{SYMBOL_REF_BLOCK (@var{x})}. The value is +negative if @var{x} has not yet been assigned an offset. @end table @node Flags diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 5a04430..4c32cf6 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -38,6 +38,7 @@ through the macros defined in the @file{.h} file. * Trampolines:: Code set up at run time to enter a nested function. * Library Calls:: Controlling how library routines are implicitly called. * Addressing Modes:: Defining addressing modes valid for memory operands. +* Anchored Addresses:: Defining how @option{-fsection-anchors} should work. * Condition Code:: Defining how insns update the condition code. * Costs:: Defining relative costs of different operations. * Scheduling:: Adjusting the behavior of the instruction scheduler. @@ -5207,6 +5208,14 @@ holding the constant. This restriction is often true of addresses of TLS symbols for various targets. @end deftypefn +@deftypefn {Target Hook} bool TARGET_USE_BLOCKS_FOR_CONSTANT_P (enum machine_mode @var{mode}, rtx @var{x}) +This hook should return true if pool entries for constant @var{x} can +be placed in an @code{object_block} structure. @var{mode} is the mode +of @var{x}. + +The default version returns false for all constants. +@end deftypefn + @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD (void) This hook should return the DECL of a function @var{f} that given an address @var{addr} as an argument returns a mask @var{m} that can be @@ -5236,6 +5245,76 @@ the argument @var{OFF} to @code{REALIGN_LOAD}, in which case the low log2(@var{VS})-1 bits of @var{addr} will be considered. @end deftypefn +@node Anchored Addresses +@section Anchored Addresses +@cindex anchored addresses +@cindex @option{-fsection-anchors} + +GCC usually addresses every static object as a separate entity. +For example, if we have: + +@smallexample +static int a, b, c; +int foo (void) @{ return a + b + c; @} +@end smallexample + +the code for @code{foo} will usually calculate three separate symbolic +addresses: those of @code{a}, @code{b} and @code{c}. On some targets, +it would be better to calculate just one symbolic address and access +the three variables relative to it. The equivalent pseudocode would +be something like: + +@smallexample +int foo (void) +@{ + register int *xr = &x; + return xr[&a - &x] + xr[&b - &x] + xr[&c - &x]; +@} +@end smallexample + +(which isn't valid C). We refer to shared addresses like @code{x} as +``section anchors''. Their use is controlled by @option{-fsection-anchors}. + +The hooks below describe the target properties that GCC needs to know +in order to make effective use of section anchors. It won't use +section anchors at all unless either @code{TARGET_MIN_ANCHOR_OFFSET} +or @code{TARGET_MAX_ANCHOR_OFFSET} is set to a nonzero value. + +@deftypevar {Target Hook} HOST_WIDE_INT TARGET_MIN_ANCHOR_OFFSET +The minimum offset that should be applied to a section anchor. +On most targets, it should be the smallest offset that can be +applied to a base register while still giving a legitimate address +for every mode. The default value is 0. +@end deftypevar + +@deftypevar {Target Hook} HOST_WIDE_INT TARGET_MAX_ANCHOR_OFFSET +Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive) +offset that should be applied to section anchors. The default +value is 0. +@end deftypevar + +@deftypefn {Target Hook} void TARGET_ASM_OUTPUT_ANCHOR (rtx @var{x}) +Write the assembly code to define section anchor @var{x}, which is a +@code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true. +The hook is called with the assembly output position set to the beginning +of @code{SYMBOL_REF_BLOCK (@var{x})}. + +If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses +it to define the symbol as @samp{. + SYMBOL_REF_BLOCK_OFFSET (@var{x})}. +If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition +is @code{NULL}, which disables the use of section anchors altogether. +@end deftypefn + +@deftypefn {Target Hook} bool TARGET_USE_ANCHORS_FOR_SYMBOL_P (rtx @var{x}) +Return true if GCC should attempt to use anchors to access @code{SYMBOL_REF} +@var{x}. You can assume @samp{SYMBOL_REF_IN_BLOCK_P (@var{x})} and +@samp{!SYMBOL_REF_ANCHOR_P (@var{x})}. + +The default version is correct for most targets, but you might need to +intercept this hook to handle things like target-specific attributes +or target-specific sections. +@end deftypefn + @node Condition Code @section Condition Code Status @cindex condition code status -- cgit v1.1