if (DECL_WEAK (decl)) ASM_WEAKEN_LABEL (asm_out_file, name);
if (DECL_WEAK (decl)) { ASM_WEAKEN_LABEL (asm_out_file, name);  remove_from_pending_weak_list (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); }
assemble_variable (decl, top_level, at_end, dont_output_data)     tree decl;     int top_level ATTRIBUTE_UNUSED;     int at_end;     int dont_output_data;{  register char *name;  unsigned int align;  tree size_tree;  int reloc = 0;  enum in_section saved_in_section;  last_assemble_variable_decl = 0;  if (GET_CODE (DECL_RTL (decl)) == REG)    {      /* Do output symbol info for global register variables, but do nothing	 else for them.  */      if (TREE_ASM_WRITTEN (decl))	return;      TREE_ASM_WRITTEN (decl) = 1;      /* Do no output if -fsyntax-only.  */      if (flag_syntax_only)	return;#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)      /* File-scope global variables are output here.  */      if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)	   && top_level)	dbxout_symbol (decl, 0);#endif#ifdef SDB_DEBUGGING_INFO      if (write_symbols == SDB_DEBUG && top_level	  /* Leave initialized global vars for end of compilation;	     see comment in compile_file.  */	  && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))	sdbout_symbol (decl, 0);#endif      /* Don't output any DWARF debugging information for variables here.	 In the case of local variables, the information for them is output	 when we do our recursive traversal of the tree representation for	 the entire containing function.  In the case of file-scope variables,	 we output information for all of them at the very end of compilation	 while we are doing our final traversal of the chain of file-scope	 declarations.  */      return;    }  /* Normally no need to say anything here for external references,     since assemble_external is called by the language-specific code     when a declaration is first seen.  */  if (DECL_EXTERNAL (decl))    return;  /* Output no assembler code for a function declaration.     Only definitions of functions output anything.  */  if (TREE_CODE (decl) == FUNCTION_DECL)    return;  /* If type was incomplete when the variable was declared,     see if it is complete now.  */  if (DECL_SIZE (decl) == 0)    layout_decl (decl, 0);  /* Still incomplete => don't allocate it; treat the tentative defn     (which is what it must have been) as an `extern' reference.  */  if (!dont_output_data && DECL_SIZE (decl) == 0)    {      error_with_file_and_line (DECL_SOURCE_FILE (decl),				DECL_SOURCE_LINE (decl),				"storage size of `%s' isn't known",				IDENTIFIER_POINTER (DECL_NAME (decl)));      TREE_ASM_WRITTEN (decl) = 1;      return;    }  /* The first declaration of a variable that comes through this function     decides whether it is global (in C, has external linkage)     or local (in C, has internal linkage).  So do nothing more     if this function has already run.  */  if (TREE_ASM_WRITTEN (decl))    return;  TREE_ASM_WRITTEN (decl) = 1;  /* Do no output if -fsyntax-only.  */  if (flag_syntax_only)    return;  app_disable ();  if (! dont_output_data)    {      int size;      if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)	goto finish;      /* This is better than explicit arithmetic, since it avoids overflow.  */      size_tree = size_binop (CEIL_DIV_EXPR,			      DECL_SIZE (decl), size_int (BITS_PER_UNIT));      size = TREE_INT_CST_LOW (size_tree);      if (TREE_INT_CST_HIGH (size_tree) != 0	  || size != TREE_INT_CST_LOW (size_tree))	{	  error_with_decl (decl, "size of variable `%s' is too large");	  goto finish;	}    }  name = XSTR (XEXP (DECL_RTL (decl), 0), 0);  if (TREE_PUBLIC (decl) && DECL_NAME (decl)      && ! first_global_object_name      && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0				   || DECL_INITIAL (decl) == error_mark_node))      && ! DECL_WEAK (decl)      && ! DECL_ONE_ONLY (decl))    {      char *p;      STRIP_NAME_ENCODING (p, name);      first_global_object_name = permalloc (strlen (p) + 1);      strcpy (first_global_object_name, p);    }  /* Compute the alignment of this data.  */  align = DECL_ALIGN (decl);  /* In the case for initialing an array whose length isn't specified,     where we have not yet been able to do the layout,     figure out the proper alignment now.  */  if (dont_output_data && DECL_SIZE (decl) == 0      && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)    align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));  /* Some object file formats have a maximum alignment which they support.     In particular, a.out format supports a maximum alignment of 4.  */#ifndef MAX_OFILE_ALIGNMENT#define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT#endif  if (align > MAX_OFILE_ALIGNMENT)    {      warning_with_decl (decl,	"alignment of `%s' is greater than maximum object file alignment. Using %d.",                    MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);      align = MAX_OFILE_ALIGNMENT;    }  /* On some machines, it is good to increase alignment sometimes.  */#ifdef DATA_ALIGNMENT  align = DATA_ALIGNMENT (TREE_TYPE (decl), align);#endif#ifdef CONSTANT_ALIGNMENT  if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)    align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);#endif  /* Reset the alignment in case we have made it tighter, so we can benefit     from it in get_pointer_alignment.  */  DECL_ALIGN (decl) = align;  /* Handle uninitialized definitions.  */  if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)      /* If the target can't output uninitialized but not common global data	 in .bss, then we have to use .data.  */#if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)      && DECL_COMMON (decl)#endif      && DECL_SECTION_NAME (decl) == 0      && ! dont_output_data)    {      int size = TREE_INT_CST_LOW (size_tree);      int rounded = size;      /* Don't allocate zero bytes of common,	 since that means "undefined external" in the linker.  */      if (size == 0) rounded = 1;      /* Round size up to multiple of BIGGEST_ALIGNMENT bits	 so that each uninitialized object starts on such a boundary.  */      rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;      rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)		 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));      #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)      if ( (DECL_ALIGN (decl) / BITS_PER_UNIT) > rounded)         warning_with_decl            (decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);#endif       #ifdef DBX_DEBUGGING_INFO      /* File-scope global variables are output here.  */      if (write_symbols == DBX_DEBUG && top_level)	dbxout_symbol (decl, 0);#endif#ifdef SDB_DEBUGGING_INFO      if (write_symbols == SDB_DEBUG && top_level	  /* Leave initialized global vars for end of compilation;	     see comment in compile_file.  */	  && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))	sdbout_symbol (decl, 0);#endif      /* Don't output any DWARF debugging information for variables here.	 In the case of local variables, the information for them is output	 when we do our recursive traversal of the tree representation for	 the entire containing function.  In the case of file-scope variables,	 we output information for all of them at the very end of compilation	 while we are doing our final traversal of the chain of file-scope	 declarations.  */#if 0 /* ??? We should either delete this or add a comment describing what	 it was intended to do and why we shouldn't delete it.  */      if (flag_shared_data)	data_section ();#endif      if (TREE_PUBLIC (decl)#if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)	  && DECL_COMMON (decl)#endif	  )	{#ifdef ASM_OUTPUT_SHARED_COMMON	  if (flag_shared_data)	    ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);	  else#endif	      {#ifdef ASM_OUTPUT_ALIGNED_DECL_COMMON		ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size,						   DECL_ALIGN (decl));#else#ifdef ASM_OUTPUT_ALIGNED_COMMON		ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,					   DECL_ALIGN (decl));#else		ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);#endif#endif	      }	}#if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)      else if (TREE_PUBLIC (decl))	{#ifdef ASM_OUTPUT_SHARED_BSS	  if (flag_shared_data)	    ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);	  else#endif	      {#ifdef ASM_OUTPUT_ALIGNED_BSS		ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size,					DECL_ALIGN (decl));#else		ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);#endif	      }	}#endif /* ASM_OUTPUT_BSS || ASM_OUTPUT_ALIGNED_BSS */      else	{#ifdef ASM_OUTPUT_SHARED_LOCAL	  if (flag_shared_data)	    ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);	  else#endif	      {#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL		ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size,						  DECL_ALIGN (decl));#else#ifdef ASM_OUTPUT_ALIGNED_LOCAL		ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,					  DECL_ALIGN (decl));#else		ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);#endif#endif	      }	}      goto finish;    }  /* Handle initialized definitions.     Also handle uninitialized global definitions if -fno-common and the     target doesn't support ASM_OUTPUT_BSS.  */  /* First make the assembler name(s) global if appropriate.  */  if (TREE_PUBLIC (decl) && DECL_NAME (decl))    {#ifdef ASM_WEAKEN_LABEL      if (DECL_WEAK (decl))	ASM_WEAKEN_LABEL (asm_out_file, name);      else#endif      ASM_GLOBALIZE_LABEL (asm_out_file, name);    }#if 0  for (d = equivalents; d; d = TREE_CHAIN (d))    {      tree e = TREE_VALUE (d);      if (TREE_PUBLIC (e) && DECL_NAME (e))	ASM_GLOBALIZE_LABEL (asm_out_file,			     XSTR (XEXP (DECL_RTL (e), 0), 0));    }#endif  /* Output any data that we will need to use the address of.  */  if (DECL_INITIAL (decl) == error_mark_node)    reloc = contains_pointers_p (TREE_TYPE (decl));  else if (DECL_INITIAL (decl))    reloc = output_addressed_constants (DECL_INITIAL (decl));#ifdef ASM_OUTPUT_SECTION_NAME  if ((flag_data_sections != 0       && DECL_SECTION_NAME (decl) == NULL_TREE)      || UNIQUE_SECTION_P (decl))    UNIQUE_SECTION (decl, reloc);#endif  /* Switch to the appropriate section.  */  variable_section (decl, reloc);  /* dbxout.c needs to know this.  */  if (in_text_section ())    DECL_IN_TEXT_SECTION (decl) = 1;  /* Record current section so we can restore it if dbxout.c clobbers it.  */  saved_in_section = in_section;  /* Output the dbx info now that we have chosen the section.  */#ifdef DBX_DEBUGGING_INFO  /* File-scope global variables are output here.  */  if (write_symbols == DBX_DEBUG && top_level)    dbxout_symbol (decl, 0);#endif#ifdef SDB_DEBUGGING_INFO  if (write_symbols == SDB_DEBUG && top_level      /* Leave initialized global vars for end of compilation;	 see comment in compile_file.  */      && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))    sdbout_symbol (decl, 0);#endif  /* Don't output any DWARF debugging information for variables here.     In the case of local variables, the information for them is output     when we do our recursive traversal of the tree representation for     the entire containing function.  In the case of file-scope variables,     we output information for all of them at the very end of compilation     while we are doing our final traversal of the chain of file-scope     declarations.  */  /* If the debugging output changed sections, reselect the section     that's supposed to be selected.  */  if (in_section != saved_in_section)    variable_section (decl, reloc);  /* Output the alignment of this data.  */  if (align > BITS_PER_UNIT)    ASM_OUTPUT_ALIGN (asm_out_file,		      floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));  /* Do any machine/system dependent processing of the object.  */#ifdef ASM_DECLARE_OBJECT_NAME  last_assemble_variable_decl = decl;  ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);#else  /* Standard thing is just output label for the object.  */  ASM_OUTPUT_LABEL (asm_out_file, name);#endif /* ASM_DECLARE_OBJECT_NAME */  if (!dont_output_data)    {      if (DECL_INITIAL (decl))	/* Output the actual data.  */	output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));      else	/* Leave space for it.  */	assemble_zeros (TREE_INT_CST_LOW (size_tree));    } finish:#ifdef XCOFF_DEBUGGING_INFO  /* Unfortunately, the IBM assembler cannot handle stabx before the actual     declaration.  When something like ".stabx  "aa:S-2",aa,133,0" is emitted      and `aa' hasn't been output yet, the assembler generates a stab entry with     a value of zero, in addition to creating an unnecessary external entry     for `aa'.  Hence, we must postpone dbxout_symbol to here at the end.  */  /* File-scope global variables are output here.  */  if (write_symbols == XCOFF_DEBUG && top_level)    {      saved_in_section = in_section;      dbxout_symbol (decl, 0);      if (in_section != saved_in_section)	variable_section (decl, reloc);    }#else  /* There must be a statement after a label.  */  ;#endif}