Re: Object blocks and BSS

[Richard Sandiford <richard at codesourcery dot com>]

Richard Sandiford <richard@codesourcery.com> writes:
> Mark approved this off-list on the condition that I follow up with
> a patch to rename SYMBOL_REF_IN_BLOCK_P to SYMBOL_REF_OK_FOR_BLOCK_P.

In the end we settled for SYMBOL_REF_HAS_BLOCK_INFO_P instead,
as SYMBOL_REF_OK_FOR_BLOCK_P seemed too committal.  ("If it's OK
for a block, why isn't it in one?")

Bootstrapped & regression tested on i686-pc-linux-gnu.  Applied
as pre-approved.

Richard


	* doc/tm.texi: Refer to SYMBOL_REF_HAS_BLOCK_INFO_P instead of
	SYMBOL_REF_IN_BLOCK_P.
	* doc/rtl.texi: Likewise.  Refer to SYMBOL_FLAG_HAS_BLOCK_INFO instead
	of SYMBOL_FLAG_IN_BLOCK.
	* gengtype.c (adjust_field_rtx_def): Use SYMBOL_REF_HAS_BLOCK_INFO_P
	instead of SYMBOL_REF_IN_BLOCK_P.
	* explow.c (use_anchored_address): Likewise.
	* rtl.c (rtx_size): Likewise.
	* varasm.c (create_block_symbol): Set SYMBOL_FLAG_HAS_BLOCK_INFO
	instead of SYMBOL_FLAG_IN_BLOCK.
	(make_decl_rtl): Use SYMBOL_REF_HAS_BLOCK_INFO_P instead of
	SYMBOL_REF_IN_BLOCK_P.
	(assemble_variable): Likewise.
	(output_constant_def_contents): Likewise.
	(output_constant_pool): Likewise.
	(default_encode_section_info): Preserve SYMBOL_FLAG_HAS_BLOCK_INFO
	instead of SYMBOL_FLAG_IN_BLOCK.
	* rtl.h (block_symbol): Refer to SYMBOL_REF_HAS_BLOCK_INFO_P instead of
	SYMBOL_REF_IN_BLOCK_P.
	(SYMBOL_REF_BLOCK): Likewise.
	(SYMBOL_REF_OFFSET): Likewise.
	(BLOCK_SYMBOL_CHECK): Use SYMBOL_REF_HAS_BLOCK_INFO_P instead of
	SYMBOL_REF_IN_BLOCK_P.
	(SYMBOL_FLAG_IN_BLOCK): Replace with...
	(SYMBOL_FLAG_HAS_BLOCK_INFO): ...this.
	(SYMBOL_REF_IN_BLOCK_P): Replace with...
	(SYMBOL_REF_HAS_BLOCK_INFO_P): ...this.

Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi	(revision 111649)
+++ gcc/doc/tm.texi	(working copy)
@@ -5329,7 +5329,7 @@ is @code{NULL}, which disables the use o
 
 @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
+@var{x}.  You can assume @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})} and
 @samp{!SYMBOL_REF_ANCHOR_P (@var{x})}.
 
 The default version is correct for most targets, but you might need to
Index: gcc/doc/rtl.texi
===================================================================
--- gcc/doc/rtl.texi	(revision 111649)
+++ gcc/doc/rtl.texi	(working copy)
@@ -502,12 +502,11 @@ This is a multi-bit field accessor that 
 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_HAS_BLOCK_INFO_P
+@findex SYMBOL_FLAG_HAS_BLOCK_INFO
+@item SYMBOL_FLAG_HAS_BLOCK_INFO
+Set if the symbol has @code{SYMBOL_REF_BLOCK} and
+@code{SYMBOL_REF_BLOCK_OFFSET} fields.
 
 @findex SYMBOL_REF_ANCHOR_P
 @findex SYMBOL_FLAG_ANCHOR
@@ -518,7 +517,7 @@ are symbols that have a known position w
 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.
+If this flag is set, then @code{SYMBOL_FLAG_HAS_BLOCK_INFO} will be too.
 @end table
 
 Bits beginning with @code{SYMBOL_FLAG_MACH_DEP} are available for
@@ -527,14 +526,16 @@ the target's use.
 
 @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, or @code{NULL} if none.
+If @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})}, this is the
+@samp{object_block} structure to which the symbol belongs,
+or @code{NULL} if it has not been assigned a block.
 
 @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}
+If @samp{SYMBOL_REF_HAS_BLOCK_INFO_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.
+negative if @var{x} has not yet been assigned to a block, or it has not
+been given an offset within that block.
 @end table
 
 @node Flags
Index: gcc/gengtype.c
===================================================================
--- gcc/gengtype.c	(revision 111649)
+++ gcc/gengtype.c	(working copy)
@@ -675,10 +675,11 @@ adjust_field_rtx_def (type_p t, options_
 
       if (i == SYMBOL_REF)
 	{
-	  /* Add the "block_sym" field if SYMBOL_REF_IN_BLOCK_P holds.  */
+	  /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds.  */
 	  type_p field_tp = find_structure ("block_symbol", 0);
-	  subfields = create_optional_field (subfields, field_tp, "block_sym",
-					     "SYMBOL_REF_IN_BLOCK_P (&%0)");
+	  subfields
+	    = create_optional_field (subfields, field_tp, "block_sym",
+				     "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
 	}
 
       sname = xasprintf ("rtx_def_%s", rtx_name[i]);
Index: gcc/explow.c
===================================================================
--- gcc/explow.c	(revision 111649)
+++ gcc/explow.c	(working copy)
@@ -566,7 +566,7 @@ use_anchored_address (rtx x)
 
   /* Check whether BASE is suitable for anchors.  */
   if (GET_CODE (base) != SYMBOL_REF
-      || !SYMBOL_REF_IN_BLOCK_P (base)
+      || !SYMBOL_REF_HAS_BLOCK_INFO_P (base)
       || SYMBOL_REF_ANCHOR_P (base)
       || SYMBOL_REF_BLOCK (base) == NULL
       || !targetm.use_anchors_for_symbol_p (base))
Index: gcc/varasm.c
===================================================================
--- gcc/varasm.c	(revision 111649)
+++ gcc/varasm.c	(working copy)
@@ -365,7 +365,7 @@ create_block_symbol (const char *label, 
   PUT_CODE (symbol, SYMBOL_REF);
   PUT_MODE (symbol, Pmode);
   XSTR (symbol, 0) = label;
-  SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_IN_BLOCK;
+  SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO;
 
   /* Initialize the block_symbol stuff.  */
   SYMBOL_REF_BLOCK (symbol) = block;
@@ -986,11 +986,11 @@ make_decl_rtl (tree decl)
 	 decl attribute overrides another.  */
       targetm.encode_section_info (decl, DECL_RTL (decl), false);
 
-      /* If the old address was assigned to an object block, see whether
-	 that block is still in the right section.  */
+      /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
+	 on the new decl information.  */
       if (MEM_P (x)
 	  && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
-	  && SYMBOL_REF_IN_BLOCK_P (XEXP (x, 0)))
+	  && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
 	change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
 
       /* Make this function static known to the mudflap runtime.  */
@@ -1819,7 +1819,7 @@ assemble_variable (tree decl, int top_le
   /* If the decl is part of an object_block, make sure that the decl
      has been positioned within its block, but do not write out its
      definition yet.  output_object_blocks will do that later.  */
-  if (SYMBOL_REF_IN_BLOCK_P (symbol) && SYMBOL_REF_BLOCK (symbol))
+  if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
     {
       gcc_assert (!dont_output_data);
       place_block_symbol (symbol);
@@ -2947,7 +2947,7 @@ output_constant_def_contents (rtx symbol
   /* If the constant is part of an object block, make sure that the
      decl has been positioned within its block, but do not write out
      its definition yet.  output_object_blocks will do that later.  */
-  if (SYMBOL_REF_IN_BLOCK_P (symbol) && SYMBOL_REF_BLOCK (symbol))
+  if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
     place_block_symbol (symbol);
   else
     {
@@ -3508,7 +3508,8 @@ output_constant_pool (const char *fnname
 	   the constant has been positioned within its block, but do not
 	   write out its definition yet.  output_object_blocks will do
 	   that later.  */
-	if (SYMBOL_REF_IN_BLOCK_P (desc->sym) && SYMBOL_REF_BLOCK (desc->sym))
+	if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
+	    && SYMBOL_REF_BLOCK (desc->sym))
 	  place_block_symbol (desc->sym);
 	else
 	  {
@@ -5683,7 +5684,7 @@ default_encode_section_info (tree decl, 
   if (GET_CODE (symbol) != SYMBOL_REF)
     return;
 
-  flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_IN_BLOCK;
+  flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO;
   if (TREE_CODE (decl) == FUNCTION_DECL)
     flags |= SYMBOL_FLAG_FUNCTION;
   if (targetm.binds_local_p (decl))
Index: gcc/rtl.c
===================================================================
--- gcc/rtl.c	(revision 111649)
+++ gcc/rtl.c	(working copy)
@@ -175,7 +175,7 @@ rtvec_alloc (int n)
 unsigned int
 rtx_size (rtx x)
 {
-  if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_IN_BLOCK_P (x))
+  if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
     return RTX_HDR_SIZE + sizeof (struct block_symbol);
   return RTX_CODE_SIZE (GET_CODE (x));
 }
Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h	(revision 111649)
+++ gcc/rtl.h	(working copy)
@@ -178,7 +178,7 @@ typedef union rtunion_def rtunion;
 
 /* This structure remembers the position of a SYMBOL_REF within an
    object_block structure.  A SYMBOL_REF only provides this information
-   if SYMBOL_REF_IN_BLOCK_P is true.  */
+   if SYMBOL_REF_HAS_BLOCK_INFO_P is true.  */
 struct block_symbol GTY(()) {
   /* The usual SYMBOL_REF fields.  */
   rtunion GTY ((skip)) fld[3];
@@ -212,7 +212,7 @@ struct object_block GTY(())
      order of increasing offset and the following conditions will
      hold for each element X:
 
-	 SYMBOL_REF_IN_BLOCK_P (X)
+	 SYMBOL_REF_HAS_BLOCK_INFO_P (X)
 	 !SYMBOL_REF_ANCHOR_P (X)
 	 SYMBOL_REF_BLOCK (X) == [address of this structure]
 	 SYMBOL_REF_BLOCK_OFFSET (X) >= 0.  */
@@ -222,7 +222,7 @@ struct object_block GTY(())
      in order of increasing offset, and then increasing TLS model.
      The following conditions will hold for each element X in this vector:
 
-	 SYMBOL_REF_IN_BLOCK_P (X)
+	 SYMBOL_REF_HAS_BLOCK_INFO_P (X)
 	 SYMBOL_REF_ANCHOR_P (X)
 	 SYMBOL_REF_BLOCK (X) == [address of this structure]
 	 SYMBOL_REF_BLOCK_OFFSET (X) >= 0.  */
@@ -529,7 +529,7 @@ #define XCNMPRV(RTX, C, M) __extension__
 #define BLOCK_SYMBOL_CHECK(RTX) __extension__				\
 ({ rtx const _symbol = (RTX);						\
    unsigned int flags = RTL_CHECKC1 (_symbol, 1, SYMBOL_REF).rt_int;	\
-   if ((flags & SYMBOL_FLAG_IN_BLOCK) == 0)				\
+   if ((flags & SYMBOL_FLAG_HAS_BLOCK_INFO) == 0)			\
      rtl_check_failed_block_symbol (__FILE__, __LINE__,			\
 				    __FUNCTION__);			\
    &_symbol->u.block_sym; })
@@ -1318,11 +1318,11 @@ #define SYMBOL_FLAG_EXTERNAL	(1 << 6)
 #define SYMBOL_REF_EXTERNAL_P(RTX) \
   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_EXTERNAL) != 0)
 /* Set if this symbol has a block_symbol structure associated with it.  */
-#define SYMBOL_FLAG_IN_BLOCK	(1 << 7)
-#define SYMBOL_REF_IN_BLOCK_P(RTX) \
-  ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_IN_BLOCK) != 0)
+#define SYMBOL_FLAG_HAS_BLOCK_INFO (1 << 7)
+#define SYMBOL_REF_HAS_BLOCK_INFO_P(RTX) \
+  ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_HAS_BLOCK_INFO) != 0)
 /* Set if this symbol is a section anchor.  SYMBOL_REF_ANCHOR_P implies
-   SYMBOL_REF_IN_BLOCK_P.  */
+   SYMBOL_REF_HAS_BLOCK_INFO_P.  */
 #define SYMBOL_FLAG_ANCHOR	(1 << 8)
 #define SYMBOL_REF_ANCHOR_P(RTX) \
   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_ANCHOR) != 0)
@@ -1331,13 +1331,15 @@ #define SYMBOL_REF_ANCHOR_P(RTX) \
 #define SYMBOL_FLAG_MACH_DEP_SHIFT	9
 #define SYMBOL_FLAG_MACH_DEP		(1 << SYMBOL_FLAG_MACH_DEP_SHIFT)
 
-/* The block to which the given SYMBOL_REF belongs, or NULL if none.
-   Only valid if SYMBOL_REF_IN_BLOCK_P (RTX).  */
+/* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the object_block
+   structure to which the symbol belongs, or NULL if it has not been
+   assigned a block.  */
 #define SYMBOL_REF_BLOCK(RTX) (BLOCK_SYMBOL_CHECK (RTX)->block)
 
-/* The byte offset of the given SYMBOL_REF from the start of its block,
-   or a negative value if the symbol has not yet been assigned a position.
-   Only valid if SYMBOL_REF_IN_BLOCK_P (RTX).  */
+/* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the offset of RTX from
+   the first object in SYMBOL_REF_BLOCK (RTX).  The value is negative if
+   RTX has not yet been assigned to a block, or it has not been given an
+   offset within that block.  */
 #define SYMBOL_REF_BLOCK_OFFSET(RTX) (BLOCK_SYMBOL_CHECK (RTX)->offset)
 
 /* Define a macro to look for REG_INC notes,