CbC/CbC_gcc: gcc/varasm.c comparison

comparison gcc/varasm.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	3bfb6c00c1e0
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* Output variables, constants and external declarations, for GNU compiler.
 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
-1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
-2010  Free Software Foundation, Inc.
+Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "regs.h"
 #include "real.h"
 #include "output.h"
 #include "toplev.h"
 #include "hashtab.h"
-#include "c-pragma.h"
 #include "ggc.h"
 #include "langhooks.h"
 #include "tm_p.h"
 #include "debug.h"
 #include "target.h"
 static tree copy_constant (tree);
 static void output_constant_def_contents (rtx);
 static void output_addressed_constants (tree);
 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
 static unsigned min_align (unsigned, unsigned);
-static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
 static void globalize_decl (tree);
 #ifdef BSS_SECTION_ASM_OP
 #ifdef ASM_OUTPUT_BSS
 static void asm_output_bss (FILE *, tree, const char *,
 			    unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
 prefix_name (const char *prefix, tree name)
 {
 unsigned plen = strlen (prefix);
 unsigned nlen = strlen (IDENTIFIER_POINTER (name));
 char *toname = (char *) alloca (plen + nlen + 1);
 memcpy (toname, prefix, plen);
 memcpy (toname + plen, IDENTIFIER_POINTER (name), nlen + 1);
 return get_identifier (toname);
 }
 tree
 default_emutls_var_fields (tree type, tree *name ATTRIBUTE_UNUSED)
 {
 tree word_type_node, field, next_field;
-field = build_decl (FIELD_DECL, get_identifier ("__templ"), ptr_type_node);
+field = build_decl (UNKNOWN_LOCATION,
+		      FIELD_DECL, get_identifier ("__templ"), ptr_type_node);
 DECL_CONTEXT (field) = type;
 next_field = field;
-field = build_decl (FIELD_DECL, get_identifier ("__offset"),
+field = build_decl (UNKNOWN_LOCATION,
+		      FIELD_DECL, get_identifier ("__offset"),
 		      ptr_type_node);
 DECL_CONTEXT (field) = type;
 TREE_CHAIN (field) = next_field;
 next_field = field;
 word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
-field = build_decl (FIELD_DECL, get_identifier ("__align"),
+field = build_decl (UNKNOWN_LOCATION,
+		      FIELD_DECL, get_identifier ("__align"),
 		      word_type_node);
 DECL_CONTEXT (field) = type;
 TREE_CHAIN (field) = next_field;
 next_field = field;
-field = build_decl (FIELD_DECL, get_identifier ("__size"), word_type_node);
+field = build_decl (UNKNOWN_LOCATION,
+		      FIELD_DECL, get_identifier ("__size"), word_type_node);
 DECL_CONTEXT (field) = type;
 TREE_CHAIN (field) = next_field;
 return field;
 }
 emutls_object_type = type = lang_hooks.types.make_type (RECORD_TYPE);
 type_name = NULL;
 field = targetm.emutls.var_fields (type, &type_name);
 if (!type_name)
 type_name = get_identifier ("__emutls_object");
-type_name = build_decl (TYPE_DECL, type_name, type);
+type_name = build_decl (UNKNOWN_LOCATION,
+			  TYPE_DECL, type_name, type);
 TYPE_NAME (type) = type_name;
 TYPE_FIELDS (type) = field;
 layout_type (type);
 return type;
 static tree
 get_emutls_init_templ_addr (tree decl)
 {
 tree name, to;
 if (targetm.emutls.register_common && !DECL_INITIAL (decl)
 && !DECL_SECTION_NAME (decl))
 return null_pointer_node;
 name = DECL_ASSEMBLER_NAME (decl);
 			    ? targetm.emutls.tmpl_prefix
 			    : "__emutls_t" EMUTLS_SEPARATOR);
 name = prefix_name (prefix, name);
 }
-to = build_decl (VAR_DECL, name, TREE_TYPE (decl));
+to = build_decl (DECL_SOURCE_LOCATION (decl),
+		   VAR_DECL, name, TREE_TYPE (decl));
 SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
 DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
 DECL_ARTIFICIAL (to) = 1;
 TREE_USED (to) = TREE_USED (decl);
 TREE_READONLY (to) = 1;
 DECL_IGNORED_P (to) = 1;
 DECL_CONTEXT (to) = DECL_CONTEXT (decl);
 DECL_SECTION_NAME (to) = DECL_SECTION_NAME (decl);
 DECL_WEAK (to) = DECL_WEAK (decl);
 if (DECL_ONE_ONLY (decl))
 {
-make_decl_one_only (to);
+make_decl_one_only (to, DECL_ASSEMBLER_NAME (to));
 TREE_STATIC (to) = TREE_STATIC (decl);
 TREE_PUBLIC (to) = TREE_PUBLIC (decl);
 DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
 }
 else
 h = (struct tree_map *) *loc;
 if (h != NULL)
 to = h->to;
 else
 {
-to = build_decl (VAR_DECL, get_emutls_object_name (name),
+to = build_decl (DECL_SOURCE_LOCATION (decl),
+		       VAR_DECL, get_emutls_object_name (name),
 		       get_emutls_object_type ());
 h = GGC_NEW (struct tree_map);
 h->hash = in.hash;
 h->base.from = decl;
 DECL_ARTIFICIAL (to) = 1;
 DECL_IGNORED_P (to) = 1;
 TREE_READONLY (to) = 0;
 SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
 if (DECL_ONE_ONLY (decl))
-	make_decl_one_only (to);
+	make_decl_one_only (to, DECL_ASSEMBLER_NAME (to));
 DECL_CONTEXT (to) = DECL_CONTEXT (decl);
 if (targetm.emutls.var_align_fixed)
 	/* If we're not allowed to change the proxy object's
 	   alignment, pretend it's been set by the user.  */
 	DECL_USER_ALIGN (to) = 1;
 args = tree_cons (NULL, x, args);
 x = build_fold_addr_expr (h->to);
 args = tree_cons (NULL, x, args);
 x = built_in_decls[BUILT_IN_EMUTLS_REGISTER_COMMON];
-x = build_function_call_expr (x, args);
+x = build_function_call_expr (UNKNOWN_LOCATION, x, args);
 append_to_statement_list (x, pstmts);
 return 1;
 }
 	return;
 htab_traverse_noresize (emutls_htab, emutls_common_1, &body);
 if (body == NULL_TREE)
 	return;
 cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
 }
 }
 /* Helper routines for maintaining section_htab.  */
 {
 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
 {
-	  size_t len = strlen (name) + 3;
+	  const char *dot;
-	  char* rname = (char *) alloca (len);
+	  size_t len;
+	  char* rname;
+	  dot = strchr (name + 1, '.');
+	  if (!dot)
+	    dot = name;
+	  len = strlen (dot) + 8;
+	  rname = (char *) alloca (len);
 	  strcpy (rname, ".rodata");
-	  strcat (rname, name + 5);
+	  strcat (rname, dot);
 	  return get_section (rname, SECTION_LINKONCE, decl);
 	}
 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo.  */
 else if (DECL_ONE_ONLY (decl)
 	       && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
 section should be used wherever possible.  */
 static section *
 get_variable_section (tree decl, bool prefer_noswitch_p)
 {
+addr_space_t as = ADDR_SPACE_GENERIC;
 int reloc;
-/* If the decl has been given an explicit section name, then it
+if (TREE_TYPE (decl) != error_mark_node)
-isn't common, and shouldn't be handled as such.  */
+as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
-if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL)
+/* If the decl has been given an explicit section name, or it resides
+in a non-generic address space, then it isn't common, and shouldn't
+be handled as such.  */
+if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL
+&& ADDR_SPACE_GENERIC_P (as))
 {
 if (DECL_THREAD_LOCAL_P (decl))
 	return tls_comm_section;
 /* This cannot be common bss for an emulated TLS object without
 	 a register_common hook.  */
 resolve_unique_section (decl, reloc, flag_data_sections);
 if (IN_NAMED_SECTION (decl))
 return get_named_section (decl, NULL, reloc);
-if (!DECL_THREAD_LOCAL_P (decl)
+if (ADDR_SPACE_GENERIC_P (as)
+&& !DECL_THREAD_LOCAL_P (decl)
 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
 && bss_initializer_p (decl))
 {
 if (!TREE_PUBLIC (decl))
 	return lcomm_section;
 DECL_COMMON (decl) = 0;
 if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
 x = create_block_symbol (name, get_block_for_decl (decl), -1);
 else
-x = gen_rtx_SYMBOL_REF (Pmode, name);
+{
+enum machine_mode address_mode = Pmode;
+if (TREE_TYPE (decl) != error_mark_node)
+	{
+	  addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
+	  address_mode = targetm.addr_space.address_mode (as);
+	}
+x = gen_rtx_SYMBOL_REF (address_mode, name);
+}
 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
 SET_SYMBOL_REF_DECL (x, decl);
 x = gen_rtx_MEM (DECL_MODE (decl), x);
 if (TREE_CODE (decl) != FUNCTION_DECL)
 sorry ("global destructors not supported on this target");
 #endif
 }
 /* Write the address of the entity given by SYMBOL to SEC.  */
 void
 assemble_addr_to_section (rtx symbol, section *sec)
 {
 switch_to_section (sec);
 assemble_align (POINTER_SIZE);
 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
 default_named_section_asm_out_destructor (rtx symbol, int priority)
 {
 section *sec;
 if (priority != DEFAULT_INIT_PRIORITY)
 sec = get_cdtor_priority_section (priority,
 				      /*constructor_p=*/false);
 else
 sec = get_section (".dtors", SECTION_WRITE, NULL);
 assemble_addr_to_section (symbol, sec);
 default_named_section_asm_out_constructor (rtx symbol, int priority)
 {
 section *sec;
 if (priority != DEFAULT_INIT_PRIORITY)
 sec = get_cdtor_priority_section (priority,
 				      /*constructor_p=*/true);
 else
 sec = get_section (".ctors", SECTION_WRITE, NULL);
 assemble_addr_to_section (symbol, sec);
 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
 #endif
-(*debug_hooks->begin_function) (decl);
+if (!DECL_IGNORED_P (decl))
+(*debug_hooks->begin_function) (decl);
 /* Make function name accessible from other files, if appropriate.  */
 if (TREE_PUBLIC (decl))
 {
 {
 VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 4);
 constructor_elt *elt;
 tree type = TREE_TYPE (to);
 tree field = TYPE_FIELDS (type);
 elt = VEC_quick_push (constructor_elt, v, NULL);
 elt->index = field;
 elt->value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
 elt = VEC_quick_push (constructor_elt, v, NULL);
 field = TREE_CHAIN (field);
 elt->index = field;
 elt->value = build_int_cst (TREE_TYPE (field),
 			      DECL_ALIGN_UNIT (decl));
 elt = VEC_quick_push (constructor_elt, v, NULL);
 field = TREE_CHAIN (field);
 elt->index = field;
 elt->value = null_pointer_node;
 elt = VEC_quick_push (constructor_elt, v, NULL);
 field = TREE_CHAIN (field);
 elt->index = field;
 elt->value = proxy;
 return build_constructor (type, v);
 }
 /* Assemble everything that is needed for a variable or function declaration.
 Not used for automatic variables, and not used for function definitions.
 	  /* Make sure the template is marked as needed early enough.
 	     Without this, if the variable is placed in a
 	     section-anchored block, the template will only be marked
 	     when it's too late.  */
-	  record_references_in_initializer (to);
+	  record_references_in_initializer (to, false);
 	}
 decl = to;
 }
 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 	  && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
 	return true;
 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
-if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
+if (is_builtin_name (name))
 	return true;
 }
 return false;
 }
 return;
 /* We want to output annotation for weak and external symbols at
 very last to check if they are references or not.  */
-if (SUPPORTS_WEAK
+if (SUPPORTS_WEAK && DECL_WEAK (decl)
-&& DECL_WEAK (decl)
 /* TREE_STATIC is a weird and abused creature which is not
 	 generally the right test for whether an entity has been
 	 locally emitted, inlined or otherwise not-really-extern, but
 	 for declarations that can be weak, it happens to be
 	 match.  */
 && !TREE_STATIC (decl)
-&& lookup_attribute ("weak", DECL_ATTRIBUTES (decl)))
+&& value_member (decl, weak_decls) == NULL_TREE)
 weak_decls = tree_cons (NULL, decl, weak_decls);
 #ifdef ASM_OUTPUT_EXTERNAL
-pending_assemble_externals = tree_cons (0, decl,
+if (value_member (decl, pending_assemble_externals) == NULL_TREE)
-					  pending_assemble_externals);
+pending_assemble_externals = tree_cons (NULL, decl,
+					    pending_assemble_externals);
 #endif
 }
 /* Similar, for calling a library function FUN.  */
 This is done at most once per compilation.
 Returns an RTX for the address of the template.  */
 static GTY(()) rtx initial_trampoline;
-#ifdef TRAMPOLINE_TEMPLATE
 rtx
 assemble_trampoline_template (void)
 {
 char label[256];
 const char *name;
 int align;
 rtx symbol;
+gcc_assert (targetm.asm_out.trampoline_template != NULL);
 if (initial_trampoline)
 return initial_trampoline;
 /* By default, put trampoline templates in read-only data section.  */
 #endif
 /* Write the assembler code to define one.  */
 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
 if (align > 0)
-{
+ASM_OUTPUT_ALIGN (asm_out_file, align);
-ASM_OUTPUT_ALIGN (asm_out_file, align);
-}
 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
-TRAMPOLINE_TEMPLATE (asm_out_file);
+targetm.asm_out.trampoline_template (asm_out_file);
 /* Record the rtl to refer to it.  */
 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
 name = ggc_strdup (label);
 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
-initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
+initial_trampoline = gen_const_mem (BLKmode, symbol);
 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
+set_mem_size (initial_trampoline, GEN_INT (TRAMPOLINE_SIZE));
 return initial_trampoline;
 }
-#endif
 /* A and B are either alignments or offsets.  Return the minimum alignment
 that may be assumed after adding the two together.  */
 static inline unsigned
 if (size > 1)
 {
 enum machine_mode omode, imode;
 unsigned int subalign;
 unsigned int subsize, i;
-unsigned char mclass;
+enum mode_class mclass;
 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
 subalign = MIN (align, subsize * BITS_PER_UNIT);
 if (GET_CODE (x) == CONST_FIXED)
 	mclass = GET_MODE_CLASS (GET_MODE (x));
 /* Given an expression EXP with a constant value,
 reduce it to the sum of an assembler symbol and an integer.
 Store them both in the structure *VALUE.
 EXP must be reducible.  */
-struct addr_const GTY(())
+struct GTY(()) addr_const {
-{
 rtx base;
 HOST_WIDE_INT offset;
 };
 static void
 value->base = x;
 value->offset = offset;
 }
-/* Uniquize all constants that appear in memory.
-Each constant in memory thus far output is recorded
-in `const_desc_table'.  */
-struct constant_descriptor_tree GTY(())
-{
-/* A MEM for the constant.  */
-rtx rtl;
-/* The value of the constant.  */
-tree value;
-/* Hash of value.  Computing the hash from value each time
-hashfn is called can't work properly, as that means recursive
-use of the hash table during hash table expansion.  */
-hashval_t hash;
-};
 static GTY((param_is (struct constant_descriptor_tree)))
 htab_t const_desc_htab;
 static struct constant_descriptor_tree * build_constant_desc (tree);
 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
+/* Constant pool accessor function.  */
+htab_t
+constant_pool_htab (void)
+{
+return const_desc_htab;
+}
 /* Compute a hash code for a constant expression.  */
 static hashval_t
 const_desc_hash (const void *ptr)
 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
 set_mem_attributes (rtl, exp, 1);
 set_mem_alias_set (rtl, 0);
 set_mem_alias_set (rtl, const_alias_set);
+/* We cannot share RTX'es in pool entries.
+Mark this piece of RTL as required for unsharing.  */
+RTX_FLAG (rtl, used) = 1;
 /* Set flags or add text to the name to record information, such as
 that it is a local symbol.  If the name is changed, the macro
 ASM_OUTPUT_LABELREF will have to know how to strip this
 information.  This call might invalidate our local variable
 SYMBOL; we can't use it afterward.  */
 are output once per function, not once per file.  */
 /* ??? Only a few targets need per-function constant pools.  Most
 can use one per-file pool.  Should add a targetm bit to tell the
 difference.  */
-struct rtx_constant_pool GTY(())
+struct GTY(()) rtx_constant_pool {
-{
 /* Pointers to first and last constant in pool, as ordered by offset.  */
 struct constant_descriptor_rtx *first;
 struct constant_descriptor_rtx *last;
 /* Hash facility for making memory-constants from constant rtl-expressions.
 /* Current offset in constant pool (does not include any
 machine-specific header).  */
 HOST_WIDE_INT offset;
 };
-struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
+struct GTY((chain_next ("%h.next"))) constant_descriptor_rtx {
-{
 struct constant_descriptor_rtx *next;
 rtx mem;
 rtx sym;
 rtx constant;
 HOST_WIDE_INT offset;
 {
 case CONST_INT:
 hwi = INTVAL (x);
 fold_hwi:
 {
-	const int shift = sizeof (hashval_t) * CHAR_BIT;
+	int shift = sizeof (hashval_t) * CHAR_BIT;
 	const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
 	int i;
 	h ^= (hashval_t) hwi;
 	for (i = 1; i < n; ++i)
 	  && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE
 	      || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE)
 	  && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (ctor)));
 }
-static tree initializer_constant_valid_p_1 (tree value, tree endtype,
-					    tree *cache);
 /* A subroutine of initializer_constant_valid_p.  VALUE is a MINUS_EXPR,
 PLUS_EXPR or POINTER_PLUS_EXPR.  This looks for cases of VALUE
 which are valid when ENDTYPE is an integer of any size; in
 particular, this does not accept a pointer minus a constant.  This
 returns null_pointer_node if the VALUE is an absolute constant
 which can be used to initialize a static variable.  Otherwise it
 returns NULL.  */
 static tree
-narrowing_initializer_constant_valid_p (tree value, tree endtype, tree *cache)
+narrowing_initializer_constant_valid_p (tree value, tree endtype)
 {
 tree op0, op1;
 if (!INTEGRAL_TYPE_P (endtype))
 return NULL_TREE;
 	      > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
 	break;
 op1 = inner;
 }
-op0 = initializer_constant_valid_p_1 (op0, endtype, cache);
+op0 = initializer_constant_valid_p (op0, endtype);
-if (!op0)
+op1 = initializer_constant_valid_p (op1, endtype);
-return NULL_TREE;
-op1 = initializer_constant_valid_p_1 (op1, endtype,
-					cache ? cache + 2 : NULL);
 /* Both initializers must be known.  */
-if (op1)
+if (op0 && op1)
 {
 if (op0 == op1
 	  && (op0 == null_pointer_node
 	      || TREE_CODE (value) == MINUS_EXPR))
 	return null_pointer_node;
 }
 return NULL_TREE;
 }
-/* Helper function of initializer_constant_valid_p.
+/* Return nonzero if VALUE is a valid constant-valued expression
-Return nonzero if VALUE is a valid constant-valued expression
 for use in initializing a static variable; one that can be an
 element of a "constant" initializer.
 Return null_pointer_node if the value is absolute;
 if it is relocatable, return the variable that determines the relocation.
 We assume that VALUE has been folded as much as possible;
 therefore, we do not need to check for such things as
-arithmetic-combinations of integers.
+arithmetic-combinations of integers.  */
-Use CACHE (pointer to 2 tree values) for caching if non-NULL.  */
+tree
+initializer_constant_valid_p (tree value, tree endtype)
-static tree
-initializer_constant_valid_p_1 (tree value, tree endtype, tree *cache)
 {
 tree ret;
 switch (TREE_CODE (value))
 {
 	{
 	  unsigned HOST_WIDE_INT idx;
 	  tree elt;
 	  bool absolute = true;
-	  if (cache && cache[0] == value)
-	    return cache[1];
 	  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
 	    {
 	      tree reloc;
-	      reloc = initializer_constant_valid_p_1 (elt, TREE_TYPE (elt),
+	      reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
-						      NULL);
 	      if (!reloc)
-		{
+		return NULL_TREE;
-		  if (cache)
-		    {
-		      cache[0] = value;
-		      cache[1] = NULL_TREE;
-		    }
-		  return NULL_TREE;
-		}
 	      if (reloc != null_pointer_node)
 		absolute = false;
 	    }
 	  /* For a non-absolute relocation, there is no single
 	     variable that can be "the variable that determines the
 	     relocation."  */
-	  if (cache)
-	    {
-	      cache[0] = value;
-	      cache[1] = absolute ? null_pointer_node : error_mark_node;
-	    }
 	  return absolute ? null_pointer_node : error_mark_node;
 	}
 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
 		&& TREE_CONSTANT (TREE_OPERAND (op0, 0)))
 	      return null_pointer_node;
 	    /* Taking the address of a nested function involves a trampoline,
 	       unless we don't need or want one.  */
 	    if (TREE_CODE (op0) == FUNCTION_DECL
-		&& decl_function_context (op0)
+		&& DECL_STATIC_CHAIN (op0)
-		&& !DECL_NO_STATIC_CHAIN (op0)
 		&& !TREE_NO_TRAMPOLINE (value))
 	      return NULL_TREE;
 	    /* "&{...}" requires a temporary to hold the constructed
 	       object.  */
 	    if (TREE_CODE (op0) == CONSTRUCTOR)
 	  }
 	return op0;
 }
 case NON_LVALUE_EXPR:
-return initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
+return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
-					     endtype, cache);
 case VIEW_CONVERT_EXPR:
 {
 	tree src = TREE_OPERAND (value, 0);
 	tree src_type = TREE_TYPE (src);
 	   RTL expander won't be able to apply a subsequent transformation
 	   to the underlying constructor.  */
 	if (AGGREGATE_TYPE_P (src_type) && !AGGREGATE_TYPE_P (dest_type))
 	  {
 	    if (TYPE_MODE (endtype) == TYPE_MODE (dest_type))
-	      return initializer_constant_valid_p_1 (src, endtype, cache);
+	      return initializer_constant_valid_p (src, endtype);
 	    else
 	      return NULL_TREE;
 	  }
 	/* Allow all other kinds of view-conversion.  */
-	return initializer_constant_valid_p_1 (src, endtype, cache);
+	return initializer_constant_valid_p (src, endtype);
 }
 CASE_CONVERT:
 {
 	tree src = TREE_OPERAND (value, 0);
 	   types, and offset types.  */
 	if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
 	    || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
 	    || (TREE_CODE (dest_type) == OFFSET_TYPE
 		&& TREE_CODE (src_type) == OFFSET_TYPE))
-	  return initializer_constant_valid_p_1 (src, endtype, cache);
+	  return initializer_constant_valid_p (src, endtype);
 	/* Allow length-preserving conversions between integer types.  */
 	if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
 	    && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
-	  return initializer_constant_valid_p_1 (src, endtype, cache);
+	  return initializer_constant_valid_p (src, endtype);
 	/* Allow conversions between other integer types only if
 	   explicit value.  */
 	if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
 	  {
-	    tree inner = initializer_constant_valid_p_1 (src, endtype, cache);
+	    tree inner = initializer_constant_valid_p (src, endtype);
 	    if (inner == null_pointer_node)
 	      return null_pointer_node;
 	    break;
 	  }
 	/* Allow (int) &foo provided int is as wide as a pointer.  */
 	if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
 	    && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
-	  return initializer_constant_valid_p_1 (src, endtype, cache);
+	  return initializer_constant_valid_p (src, endtype);
 	/* Likewise conversions from int to pointers, but also allow
 	   conversions from 0.  */
 	if ((POINTER_TYPE_P (dest_type)
 	     || TREE_CODE (dest_type) == OFFSET_TYPE)
 		&& TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
 	      return null_pointer_node;
 	    if (integer_zerop (src))
 	      return null_pointer_node;
 	    else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
-	      return initializer_constant_valid_p_1 (src, endtype, cache);
+	      return initializer_constant_valid_p (src, endtype);
 	  }
 	/* Allow conversions to struct or union types if the value
 	   inside is okay.  */
 	if (TREE_CODE (dest_type) == RECORD_TYPE
 	    || TREE_CODE (dest_type) == UNION_TYPE)
-	  return initializer_constant_valid_p_1 (src, endtype, cache);
+	  return initializer_constant_valid_p (src, endtype);
 }
 break;
 case POINTER_PLUS_EXPR:
 case PLUS_EXPR:
 /* Any valid floating-point constants will have been folded by now;
 	 with -frounding-math we hit this with addition of two constants.  */
 if (TREE_CODE (endtype) == REAL_TYPE)
 	return NULL_TREE;
-if (cache && cache[0] == value)
-	return cache[1];
 if (! INTEGRAL_TYPE_P (endtype)
-	  || TYPE_PRECISION (endtype) >= POINTER_SIZE)
+	  || TYPE_PRECISION (endtype) >= TYPE_PRECISION (TREE_TYPE (value)))
 	{
-	  tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE };
+	  tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
-	  tree valid0
+						      endtype);
-	    = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
+	  tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
-					      endtype, ncache);
+						      endtype);
-	  tree valid1
-	    = initializer_constant_valid_p_1 (TREE_OPERAND (value, 1),
-					      endtype, ncache + 2);
 	  /* If either term is absolute, use the other term's relocation.  */
 	  if (valid0 == null_pointer_node)
-	    ret = valid1;
+	    return valid1;
-	  else if (valid1 == null_pointer_node)
+	  if (valid1 == null_pointer_node)
-	    ret = valid0;
+	    return valid0;
-	  /* Support narrowing pointer differences.  */
-	  else
-	    ret = narrowing_initializer_constant_valid_p (value, endtype,
-							  ncache);
 	}
-else
 /* Support narrowing pointer differences.  */
-	ret = narrowing_initializer_constant_valid_p (value, endtype, NULL);
+ret = narrowing_initializer_constant_valid_p (value, endtype);
-if (cache)
+if (ret != NULL_TREE)
-	{
+	return ret;
-	  cache[0] = value;
-	  cache[1] = ret;
+break;
-	}
-return ret;
 case MINUS_EXPR:
 if (TREE_CODE (endtype) == REAL_TYPE)
 	return NULL_TREE;
-if (cache && cache[0] == value)
-	return cache[1];
 if (! INTEGRAL_TYPE_P (endtype)
-	  || TYPE_PRECISION (endtype) >= POINTER_SIZE)
+	  || TYPE_PRECISION (endtype) >= TYPE_PRECISION (TREE_TYPE (value)))
 	{
-	  tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE };
+	  tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
-	  tree valid0
+						      endtype);
-	    = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
+	  tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
-					      endtype, ncache);
+						      endtype);
-	  tree valid1
-	    = initializer_constant_valid_p_1 (TREE_OPERAND (value, 1),
-					      endtype, ncache + 2);
 	  /* Win if second argument is absolute.  */
 	  if (valid1 == null_pointer_node)
-	    ret = valid0;
+	    return valid0;
 	  /* Win if both arguments have the same relocation.
 	     Then the value is absolute.  */
-	  else if (valid0 == valid1 && valid0 != 0)
+	  if (valid0 == valid1 && valid0 != 0)
-	    ret = null_pointer_node;
+	    return null_pointer_node;
 	  /* Since GCC guarantees that string constants are unique in the
 	     generated code, a subtraction between two copies of the same
 	     constant string is absolute.  */
-	  else if (valid0 && TREE_CODE (valid0) == STRING_CST
+	  if (valid0 && TREE_CODE (valid0) == STRING_CST
-		   && valid1 && TREE_CODE (valid1) == STRING_CST
+	      && valid1 && TREE_CODE (valid1) == STRING_CST
-		   && operand_equal_p (valid0, valid1, 1))
+	      && operand_equal_p (valid0, valid1, 1))
-	    ret = null_pointer_node;
+	    return null_pointer_node;
-	  /* Support narrowing differences.  */
-	  else
-	    ret = narrowing_initializer_constant_valid_p (value, endtype,
-							  ncache);
 	}
-else
-	/* Support narrowing differences.  */
+/* Support narrowing differences.  */
-	ret = narrowing_initializer_constant_valid_p (value, endtype, NULL);
+ret = narrowing_initializer_constant_valid_p (value, endtype);
-if (cache)
+if (ret != NULL_TREE)
-	{
+	return ret;
-	  cache[0] = value;
-	  cache[1] = ret;
+break;
-	}
-return ret;
 default:
 break;
 }
-return NULL_TREE;
+return 0;
-}
-/* Return nonzero if VALUE is a valid constant-valued expression
-for use in initializing a static variable; one that can be an
-element of a "constant" initializer.
-Return null_pointer_node if the value is absolute;
-if it is relocatable, return the variable that determines the relocation.
-We assume that VALUE has been folded as much as possible;
-therefore, we do not need to check for such things as
-arithmetic-combinations of integers.  */
-tree
-initializer_constant_valid_p (tree value, tree endtype)
-{
-return initializer_constant_valid_p_1 (value, endtype, NULL);
 }
+/* Return true if VALUE is a valid constant-valued expression
+for use in initializing a static bit-field; one that can be
+an element of a "constant" initializer.  */
+bool
+initializer_constant_valid_for_bitfield_p (tree value)
+{
+/* For bitfields we support integer constants or possibly nested aggregates
+of such.  */
+switch (TREE_CODE (value))
+{
+case CONSTRUCTOR:
+{
+	unsigned HOST_WIDE_INT idx;
+	tree elt;
+	FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
+	  if (!initializer_constant_valid_for_bitfield_p (elt))
+	    return false;
+	return true;
+}
+case INTEGER_CST:
+return true;
+case VIEW_CONVERT_EXPR:
+case NON_LVALUE_EXPR:
+return
+	initializer_constant_valid_for_bitfield_p (TREE_OPERAND (value, 0));
+default:
+break;
+}
+return false;
+}
+/* output_constructor outer state of relevance in recursive calls, typically
+for nested aggregate bitfields.  */
+typedef struct {
+unsigned int bit_offset;  /* current position in ...  */
+int byte;                 /* ... the outer byte buffer.  */
+} oc_outer_state;
+static unsigned HOST_WIDE_INT
+output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int,
+		      oc_outer_state *);
 /* Output assembler code for constant EXP to FILE, with no label.
 This includes the pseudo-op such as ".int" or ".byte", and a newline.
 Assumes output_addressed_constants has been done on EXP already.
 Generate exactly SIZE bytes of assembler data, padding at the end
 to the address of some declaration somewhere.  If the target says
 the mode is valid for pointers, assume the target has a way of
 resolving it.  */
 if (TREE_CODE (exp) == NOP_EXPR
 && POINTER_TYPE_P (TREE_TYPE (exp))
-&& targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
+&& targetm.addr_space.valid_pointer_mode
+	   (TYPE_MODE (TREE_TYPE (exp)),
+	    TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)))))
 {
 tree saved_type = TREE_TYPE (exp);
 /* Peel off any intermediate conversions-to-pointer for valid
 	 pointer modes.  */
 while (TREE_CODE (exp) == NOP_EXPR
 	     && POINTER_TYPE_P (TREE_TYPE (exp))
-	     && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
+	     && targetm.addr_space.valid_pointer_mode
+		  (TYPE_MODE (TREE_TYPE (exp)),
+		   TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)))))
 	exp = TREE_OPERAND (exp, 0);
 /* If what we're left with is the address of something, we can
 	 convert the address to the final type and output it that
 	 way.  */
 	exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0));
 /* Likewise for constant ints.  */
 else if (TREE_CODE (exp) == INTEGER_CST)
 	exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp),
 				  TREE_INT_CST_HIGH (exp));
 }
 /* Eliminate any conversions since we'll be outputting the underlying
 constant.  */
 while (CONVERT_EXPR_P (exp)
 case ARRAY_TYPE:
 case VECTOR_TYPE:
 switch (TREE_CODE (exp))
 	{
 	case CONSTRUCTOR:
-	  output_constructor (exp, size, align);
+	    output_constructor (exp, size, align, NULL);
 	  return;
 	case STRING_CST:
 	  thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
 			  size);
 	  assemble_string (TREE_STRING_POINTER (exp), thissize);
 break;
 case RECORD_TYPE:
 case UNION_TYPE:
 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
-output_constructor (exp, size, align);
+output_constructor (exp, size, align, NULL);
 return;
 case ERROR_MARK:
 return;
 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
 return tree_low_cst (i, 1);
 }
+/* Other datastructures + helpers for output_constructor.  */
+/* output_constructor local state to support interaction with helpers.  */
+typedef struct {
+/* Received arguments.  */
+tree exp;                     /* Constructor expression.  */
+unsigned HOST_WIDE_INT size;  /* # bytes to output - pad if necessary.  */
+unsigned int align;           /* Known initial alignment.  */
+/* Constructor expression data.  */
+tree type;       /* Expression type.  */
+tree field;      /* Current field decl in a record.  */
+tree min_index;  /* Lower bound if specified for an array.  */
+/* Output processing state.  */
+HOST_WIDE_INT total_bytes;  /* # bytes output so far / current position.  */
+bool byte_buffer_in_use;    /* Whether byte ...  */
+int byte;                   /* ... contains part of a bitfield byte yet to
+			         be output.  */
+int last_relative_index;    /* Implicit or explicit index of the last
+				 array element output within a bitfield.  */
+/* Current element.  */
+tree val;    /* Current element value.  */
+tree index;  /* Current element index.  */
+} oc_local_state;
+/* Helper for output_constructor.  From the current LOCAL state, output a
+RANGE_EXPR element.  */
+static void
+output_constructor_array_range (oc_local_state *local)
+{
+unsigned HOST_WIDE_INT fieldsize
+= int_size_in_bytes (TREE_TYPE (local->type));
+HOST_WIDE_INT lo_index
+= tree_low_cst (TREE_OPERAND (local->index, 0), 0);
+HOST_WIDE_INT hi_index
+= tree_low_cst (TREE_OPERAND (local->index, 1), 0);
+HOST_WIDE_INT index;
+unsigned int align2
+= min_align (local->align, fieldsize * BITS_PER_UNIT);
+for (index = lo_index; index <= hi_index; index++)
+{
+/* Output the element's initial value.  */
+if (local->val == NULL_TREE)
+	assemble_zeros (fieldsize);
+else
+	output_constant (local->val, fieldsize, align2);
+/* Count its size.  */
+local->total_bytes += fieldsize;
+}
+}
+/* Helper for output_constructor.  From the current LOCAL state, output a
+field element that is not true bitfield or part of an outer one.  */
+static void
+output_constructor_regular_field (oc_local_state *local)
+{
+/* Field size and position.  Since this structure is static, we know the
+positions are constant.  */
+unsigned HOST_WIDE_INT fieldsize;
+HOST_WIDE_INT fieldpos;
+unsigned int align2;
+if (local->index != NULL_TREE)
+fieldpos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (local->val)), 1)
+		* ((tree_low_cst (local->index, 0)
+		    - tree_low_cst (local->min_index, 0))));
+else if (local->field != NULL_TREE)
+fieldpos = int_byte_position (local->field);
+else
+fieldpos = 0;
+/* Output any buffered-up bit-fields preceding this element.  */
+if (local->byte_buffer_in_use)
+{
+assemble_integer (GEN_INT (local->byte), 1, BITS_PER_UNIT, 1);
+local->total_bytes++;
+local->byte_buffer_in_use = false;
+}
+/* Advance to offset of this element.
+Note no alignment needed in an array, since that is guaranteed
+if each element has the proper size.  */
+if ((local->field != NULL_TREE || local->index != NULL_TREE)
+&& fieldpos != local->total_bytes)
+{
+gcc_assert (fieldpos >= local->total_bytes);
+assemble_zeros (fieldpos - local->total_bytes);
+local->total_bytes = fieldpos;
+}
+/* Find the alignment of this element.  */
+align2 = min_align (local->align, BITS_PER_UNIT * fieldpos);
+/* Determine size this element should occupy.  */
+if (local->field)
+{
+fieldsize = 0;
+/* If this is an array with an unspecified upper bound,
+	 the initializer determines the size.  */
+/* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
+	 but we cannot do this until the deprecated support for
+	 initializing zero-length array members is removed.  */
+if (TREE_CODE (TREE_TYPE (local->field)) == ARRAY_TYPE
+	  && TYPE_DOMAIN (TREE_TYPE (local->field))
+	  && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (local->field))))
+	{
+	  fieldsize = array_size_for_constructor (local->val);
+	  /* Given a non-empty initialization, this field had
+	     better be last.  */
+	  gcc_assert (!fieldsize || !TREE_CHAIN (local->field));
+	}
+else if (DECL_SIZE_UNIT (local->field))
+	{
+	  /* ??? This can't be right.  If the decl size overflows
+	     a host integer we will silently emit no data.  */
+	  if (host_integerp (DECL_SIZE_UNIT (local->field), 1))
+	    fieldsize = tree_low_cst (DECL_SIZE_UNIT (local->field), 1);
+	}
+}
+else
+fieldsize = int_size_in_bytes (TREE_TYPE (local->type));
+/* Output the element's initial value.  */
+if (local->val == NULL_TREE)
+assemble_zeros (fieldsize);
+else
+output_constant (local->val, fieldsize, align2);
+/* Count its size.  */
+local->total_bytes += fieldsize;
+}
+/* Helper for output_constructor.  From the current LOCAL and OUTER states,
+output an element that is a true bitfield or part of an outer one.  */
+static void
+output_constructor_bitfield (oc_local_state *local, oc_outer_state *outer)
+{
+/* Bit size of this element.  */
+HOST_WIDE_INT ebitsize
+= (local->field
+? tree_low_cst (DECL_SIZE (local->field), 1)
+: tree_low_cst (TYPE_SIZE (TREE_TYPE (local->type)), 1));
+/* Relative index of this element if this is an array component.  */
+HOST_WIDE_INT relative_index
+= (!local->field
+? (local->index
+	  ? (tree_low_cst (local->index, 0)
+	     - tree_low_cst (local->min_index, 0))
+	  : local->last_relative_index + 1)
+: 0);
+/* Bit position of this element from the start of the containing
+constructor.  */
+HOST_WIDE_INT constructor_relative_ebitpos
+= (local->field
+	 ? int_bit_position (local->field)
+	 : ebitsize * relative_index);
+/* Bit position of this element from the start of a possibly ongoing
+outer byte buffer.  */
+HOST_WIDE_INT byte_relative_ebitpos
+= ((outer ? outer->bit_offset : 0) + constructor_relative_ebitpos);
+/* From the start of a possibly ongoing outer byte buffer, offsets to
+the first bit of this element and to the first bit past the end of
+this element.  */
+HOST_WIDE_INT next_offset = byte_relative_ebitpos;
+HOST_WIDE_INT end_offset = byte_relative_ebitpos + ebitsize;
+local->last_relative_index = relative_index;
+if (local->val == NULL_TREE)
+local->val = integer_zero_node;
+while (TREE_CODE (local->val) == VIEW_CONVERT_EXPR
+	 || TREE_CODE (local->val) == NON_LVALUE_EXPR)
+local->val = TREE_OPERAND (local->val, 0);
+if (TREE_CODE (local->val) != INTEGER_CST
+&& TREE_CODE (local->val) != CONSTRUCTOR)
+{
+error ("invalid initial value for member %qE", DECL_NAME (local->field));
+return;
+}
+/* If this field does not start in this (or, next) byte,
+skip some bytes.  */
+if (next_offset / BITS_PER_UNIT != local->total_bytes)
+{
+/* Output remnant of any bit field in previous bytes.  */
+if (local->byte_buffer_in_use)
+	{
+	  assemble_integer (GEN_INT (local->byte), 1, BITS_PER_UNIT, 1);
+	  local->total_bytes++;
+	  local->byte_buffer_in_use = false;
+	}
+/* If still not at proper byte, advance to there.  */
+if (next_offset / BITS_PER_UNIT != local->total_bytes)
+	{
+	  gcc_assert (next_offset / BITS_PER_UNIT >= local->total_bytes);
+	  assemble_zeros (next_offset / BITS_PER_UNIT - local->total_bytes);
+	  local->total_bytes = next_offset / BITS_PER_UNIT;
+	}
+}
+/* Set up the buffer if necessary.  */
+if (!local->byte_buffer_in_use)
+{
+local->byte = 0;
+if (ebitsize > 0)
+	local->byte_buffer_in_use = true;
+}
+/* If this is nested constructor, recurse passing the bit offset and the
+pending data, then retrieve the new pending data afterwards.  */
+if (TREE_CODE (local->val) == CONSTRUCTOR)
+{
+oc_outer_state output_state;
+output_state.bit_offset = next_offset % BITS_PER_UNIT;
+output_state.byte = local->byte;
+local->total_bytes
+	  += output_constructor (local->val, 0, 0, &output_state);
+local->byte = output_state.byte;
+return;
+}
+/* Otherwise, we must split the element into pieces that fall within
+separate bytes, and combine each byte with previous or following
+bit-fields.  */
+while (next_offset < end_offset)
+{
+int this_time;
+int shift;
+HOST_WIDE_INT value;
+HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
+HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
+/* Advance from byte to byte
+	 within this element when necessary.  */
+while (next_byte != local->total_bytes)
+	{
+	  assemble_integer (GEN_INT (local->byte), 1, BITS_PER_UNIT, 1);
+	  local->total_bytes++;
+	  local->byte = 0;
+	}
+/* Number of bits we can process at once
+	 (all part of the same byte).  */
+this_time = MIN (end_offset - next_offset,
+		       BITS_PER_UNIT - next_bit);
+if (BYTES_BIG_ENDIAN)
+	{
+	  /* On big-endian machine, take the most significant bits
+	     first (of the bits that are significant)
+	     and put them into bytes from the most significant end.  */
+	  shift = end_offset - next_offset - this_time;
+	  /* Don't try to take a bunch of bits that cross
+	     the word boundary in the INTEGER_CST. We can
+	     only select bits from the LOW or HIGH part
+	     not from both.  */
+	  if (shift < HOST_BITS_PER_WIDE_INT
+	      && shift + this_time > HOST_BITS_PER_WIDE_INT)
+	    {
+	      this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
+	      shift = HOST_BITS_PER_WIDE_INT;
+	    }
+	  /* Now get the bits from the appropriate constant word.  */
+	  if (shift < HOST_BITS_PER_WIDE_INT)
+	    value = TREE_INT_CST_LOW (local->val);
+	  else
+	    {
+	      gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
+	      value = TREE_INT_CST_HIGH (local->val);
+	      shift -= HOST_BITS_PER_WIDE_INT;
+	    }
+	  /* Get the result. This works only when:
+	     1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
+	  local->byte |= (((value >> shift)
+			   & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
+			  << (BITS_PER_UNIT - this_time - next_bit));
+	}
+else
+	{
+	  /* On little-endian machines,
+	     take first the least significant bits of the value
+	     and pack them starting at the least significant
+	     bits of the bytes.  */
+	  shift = next_offset - byte_relative_ebitpos;
+	  /* Don't try to take a bunch of bits that cross
+	     the word boundary in the INTEGER_CST. We can
+	     only select bits from the LOW or HIGH part
+	     not from both.  */
+	  if (shift < HOST_BITS_PER_WIDE_INT
+	      && shift + this_time > HOST_BITS_PER_WIDE_INT)
+	    this_time = (HOST_BITS_PER_WIDE_INT - shift);
+	  /* Now get the bits from the appropriate constant word.  */
+	  if (shift < HOST_BITS_PER_WIDE_INT)
+	    value = TREE_INT_CST_LOW (local->val);
+	  else
+	    {
+	      gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
+	      value = TREE_INT_CST_HIGH (local->val);
+	      shift -= HOST_BITS_PER_WIDE_INT;
+	    }
+	  /* Get the result. This works only when:
+	     1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
+	  local->byte |= (((value >> shift)
+			   & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
+			  << next_bit);
+	}
+next_offset += this_time;
+local->byte_buffer_in_use = true;
+}
+}
 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
-Generate at least SIZE bytes, padding if necessary.  */
+Generate at least SIZE bytes, padding if necessary.  OUTER designates the
+caller output state of relevance in recursive invocations.  */
-static void
+static unsigned HOST_WIDE_INT
 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
-		    unsigned int align)
+		    unsigned int align, oc_outer_state * outer)
 {
-tree type = TREE_TYPE (exp);
-tree field = 0;
-tree min_index = 0;
-/* Number of bytes output or skipped so far.
-In other words, current position within the constructor.  */
-HOST_WIDE_INT total_bytes = 0;
-/* Nonzero means BYTE contains part of a byte, to be output.  */
-int byte_buffer_in_use = 0;
-int byte = 0;
 unsigned HOST_WIDE_INT cnt;
 constructor_elt *ce;
+oc_local_state local;
+/* Setup our local state to communicate with helpers.  */
+local.exp = exp;
+local.size = size;
+local.align = align;
+local.total_bytes = 0;
+local.byte_buffer_in_use = outer != NULL;
+local.byte = outer ? outer->byte : 0;
+local.type = TREE_TYPE (exp);
+local.last_relative_index = -1;
+local.min_index = NULL_TREE;
+if (TREE_CODE (local.type) == ARRAY_TYPE
+&& TYPE_DOMAIN (local.type) != NULL_TREE)
+local.min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (local.type));
 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
-if (TREE_CODE (type) == RECORD_TYPE)
+/* As CE goes through the elements of the constant, FIELD goes through the
-field = TYPE_FIELDS (type);
+structure fields if the constant is a structure.  If the constant is a
+union, we override this by getting the field from the TREE_LIST element.
-if (TREE_CODE (type) == ARRAY_TYPE
-&& TYPE_DOMAIN (type) != 0)
-min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
-/* As LINK goes through the elements of the constant,
-FIELD goes through the structure fields, if the constant is a structure.
-if the constant is a union, then we override this,
-by getting the field from the TREE_LIST element.
 But the constant could also be an array.  Then FIELD is zero.
 There is always a maximum of one element in the chain LINK for unions
 (even if the initializer in a source program incorrectly contains
 more one).  */
+local.field = NULL_TREE;
+if (TREE_CODE (local.type) == RECORD_TYPE)
+local.field = TYPE_FIELDS (local.type);
 for (cnt = 0;
 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
-cnt++, field = field ? TREE_CHAIN (field) : 0)
+cnt++, local.field = local.field ? TREE_CHAIN (local.field) : 0)
 {
-tree val = ce->value;
+local.val = ce->value;
-tree index = 0;
+local.index = NULL_TREE;
 /* The element in a union constructor specifies the proper field
 	 or index.  */
-if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
+if ((TREE_CODE (local.type) == RECORD_TYPE
-	   || TREE_CODE (type) == QUAL_UNION_TYPE)
+	   || TREE_CODE (local.type) == UNION_TYPE
-	  && ce->index != 0)
+	   || TREE_CODE (local.type) == QUAL_UNION_TYPE)
-	field = ce->index;
+	  && ce->index != NULL_TREE)
+	local.field = ce->index;
-else if (TREE_CODE (type) == ARRAY_TYPE)
-	index = ce->index;
+else if (TREE_CODE (local.type) == ARRAY_TYPE)
+	local.index = ce->index;
 #ifdef ASM_COMMENT_START
-if (field && flag_verbose_asm)
+if (local.field && flag_verbose_asm)
 	fprintf (asm_out_file, "%s %s:\n",
 		 ASM_COMMENT_START,
-		 DECL_NAME (field)
+		 DECL_NAME (local.field)
-		 ? IDENTIFIER_POINTER (DECL_NAME (field))
+		 ? IDENTIFIER_POINTER (DECL_NAME (local.field))
 		 : "<anonymous>");
 #endif
 /* Eliminate the marker that makes a cast not be an lvalue.  */
-if (val != 0)
+if (local.val != NULL_TREE)
-	STRIP_NOPS (val);
+	STRIP_NOPS (local.val);
-if (index && TREE_CODE (index) == RANGE_EXPR)
+/* Output the current element, using the appropriate helper ...  */
+/* For an array slice not part of an outer bitfield.  */
+if (!outer
+	  && local.index != NULL_TREE
+	  && TREE_CODE (local.index) == RANGE_EXPR)
+	output_constructor_array_range (&local);
+/* For a field that is neither a true bitfield nor part of an outer one,
+	 known to be at least byte aligned and multiple-of-bytes long.  */
+else if (!outer
+	       && (local.field == NULL_TREE
+		   || !CONSTRUCTOR_BITFIELD_P (local.field)))
+	output_constructor_regular_field (&local);
+/* For a true bitfield or part of an outer one.  */
+else
+	output_constructor_bitfield (&local, outer);
+}
+/* If we are not at toplevel, save the pending data for our caller.
+Otherwise output the pending data and padding zeros as needed. */
+if (outer)
+outer->byte = local.byte;
+else
+{
+if (local.byte_buffer_in_use)
 	{
-	  unsigned HOST_WIDE_INT fieldsize
+	  assemble_integer (GEN_INT (local.byte), 1, BITS_PER_UNIT, 1);
-	    = int_size_in_bytes (TREE_TYPE (type));
+	  local.total_bytes++;
-	  HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
-	  HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
-	  HOST_WIDE_INT index;
-	  unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
-	  for (index = lo_index; index <= hi_index; index++)
-	    {
-	      /* Output the element's initial value.  */
-	      if (val == 0)
-		assemble_zeros (fieldsize);
-	      else
-		output_constant (val, fieldsize, align2);
-	      /* Count its size.  */
-	      total_bytes += fieldsize;
-	    }
 	}
-else if (field == 0 || !DECL_BIT_FIELD (field))
+if ((unsigned HOST_WIDE_INT)local.total_bytes < local.size)
 	{
-	  /* An element that is not a bit-field.  */
+	  assemble_zeros (local.size - local.total_bytes);
+	  local.total_bytes = local.size;
-	  unsigned HOST_WIDE_INT fieldsize;
-	  /* Since this structure is static,
-	     we know the positions are constant.  */
-	  HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
-	  unsigned int align2;
-	  if (index != 0)
-	    pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
-		   * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
-	  /* Output any buffered-up bit-fields preceding this element.  */
-	  if (byte_buffer_in_use)
-	    {
-	      assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
-	      total_bytes++;
-	      byte_buffer_in_use = 0;
-	    }
-	  /* Advance to offset of this element.
-	     Note no alignment needed in an array, since that is guaranteed
-	     if each element has the proper size.  */
-	  if ((field != 0 || index != 0) && pos != total_bytes)
-	    {
-	      gcc_assert (pos >= total_bytes);
-	      assemble_zeros (pos - total_bytes);
-	      total_bytes = pos;
-	    }
-	  /* Find the alignment of this element.  */
-	  align2 = min_align (align, BITS_PER_UNIT * pos);
-	  /* Determine size this element should occupy.  */
-	  if (field)
-	    {
-	      fieldsize = 0;
-	      /* If this is an array with an unspecified upper bound,
-		 the initializer determines the size.  */
-	      /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
-		 but we cannot do this until the deprecated support for
-		 initializing zero-length array members is removed.  */
-	      if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
-		  && TYPE_DOMAIN (TREE_TYPE (field))
-		  && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
-		{
-		  fieldsize = array_size_for_constructor (val);
-		  /* Given a non-empty initialization, this field had
-		     better be last.  */
-		  gcc_assert (!fieldsize || !TREE_CHAIN (field));
-		}
-	      else if (DECL_SIZE_UNIT (field))
-		{
-		  /* ??? This can't be right.  If the decl size overflows
-		     a host integer we will silently emit no data.  */
-		  if (host_integerp (DECL_SIZE_UNIT (field), 1))
-		    fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
-		}
-	    }
-	  else
-	    fieldsize = int_size_in_bytes (TREE_TYPE (type));
-	  /* Output the element's initial value.  */
-	  if (val == 0)
-	    assemble_zeros (fieldsize);
-	  else
-	    output_constant (val, fieldsize, align2);
-	  /* Count its size.  */
-	  total_bytes += fieldsize;
 	}
-else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
+}
-	error ("invalid initial value for member %qs",
-	       IDENTIFIER_POINTER (DECL_NAME (field)));
+return local.total_bytes;
-else
-	{
-	  /* Element that is a bit-field.  */
-	  HOST_WIDE_INT next_offset = int_bit_position (field);
-	  HOST_WIDE_INT end_offset
-	    = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
-	  if (val == 0)
-	    val = integer_zero_node;
-	  /* If this field does not start in this (or, next) byte,
-	     skip some bytes.  */
-	  if (next_offset / BITS_PER_UNIT != total_bytes)
-	    {
-	      /* Output remnant of any bit field in previous bytes.  */
-	      if (byte_buffer_in_use)
-		{
-		  assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
-		  total_bytes++;
-		  byte_buffer_in_use = 0;
-		}
-	      /* If still not at proper byte, advance to there.  */
-	      if (next_offset / BITS_PER_UNIT != total_bytes)
-		{
-		  gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
-		  assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
-		  total_bytes = next_offset / BITS_PER_UNIT;
-		}
-	    }
-	  if (! byte_buffer_in_use)
-	    byte = 0;
-	  /* We must split the element into pieces that fall within
-	     separate bytes, and combine each byte with previous or
-	     following bit-fields.  */
-	  /* next_offset is the offset n fbits from the beginning of
-	     the structure to the next bit of this element to be processed.
-	     end_offset is the offset of the first bit past the end of
-	     this element.  */
-	  while (next_offset < end_offset)
-	    {
-	      int this_time;
-	      int shift;
-	      HOST_WIDE_INT value;
-	      HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
-	      HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
-	      /* Advance from byte to byte
-		 within this element when necessary.  */
-	      while (next_byte != total_bytes)
-		{
-		  assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
-		  total_bytes++;
-		  byte = 0;
-		}
-	      /* Number of bits we can process at once
-		 (all part of the same byte).  */
-	      this_time = MIN (end_offset - next_offset,
-			       BITS_PER_UNIT - next_bit);
-	      if (BYTES_BIG_ENDIAN)
-		{
-		  /* On big-endian machine, take the most significant bits
-		     first (of the bits that are significant)
-		     and put them into bytes from the most significant end.  */
-		  shift = end_offset - next_offset - this_time;
-		  /* Don't try to take a bunch of bits that cross
-		     the word boundary in the INTEGER_CST. We can
-		     only select bits from the LOW or HIGH part
-		     not from both.  */
-		  if (shift < HOST_BITS_PER_WIDE_INT
-		      && shift + this_time > HOST_BITS_PER_WIDE_INT)
-		    {
-		      this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
-		      shift = HOST_BITS_PER_WIDE_INT;
-		    }
-		  /* Now get the bits from the appropriate constant word.  */
-		  if (shift < HOST_BITS_PER_WIDE_INT)
-		    value = TREE_INT_CST_LOW (val);
-		  else
-		    {
-		      gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
-		      value = TREE_INT_CST_HIGH (val);
-		      shift -= HOST_BITS_PER_WIDE_INT;
-		    }
-		  /* Get the result. This works only when:
-		     1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
-		  byte |= (((value >> shift)
-			    & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
-			   << (BITS_PER_UNIT - this_time - next_bit));
-		}
-	      else
-		{
-		  /* On little-endian machines,
-		     take first the least significant bits of the value
-		     and pack them starting at the least significant
-		     bits of the bytes.  */
-		  shift = next_offset - int_bit_position (field);
-		  /* Don't try to take a bunch of bits that cross
-		     the word boundary in the INTEGER_CST. We can
-		     only select bits from the LOW or HIGH part
-		     not from both.  */
-		  if (shift < HOST_BITS_PER_WIDE_INT
-		      && shift + this_time > HOST_BITS_PER_WIDE_INT)
-		    this_time = (HOST_BITS_PER_WIDE_INT - shift);
-		  /* Now get the bits from the appropriate constant word.  */
-		  if (shift < HOST_BITS_PER_WIDE_INT)
-		    value = TREE_INT_CST_LOW (val);
-		  else
-		    {
-		      gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
-		      value = TREE_INT_CST_HIGH (val);
-		      shift -= HOST_BITS_PER_WIDE_INT;
-		    }
-		  /* Get the result. This works only when:
-		     1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
-		  byte |= (((value >> shift)
-			    & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
-			   << next_bit);
-		}
-	      next_offset += this_time;
-	      byte_buffer_in_use = 1;
-	    }
-	}
-}
-if (byte_buffer_in_use)
-{
-assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
-total_bytes++;
-}
-if ((unsigned HOST_WIDE_INT)total_bytes < size)
-assemble_zeros (size - total_bytes);
 }
 /* Mark DECL as weak.  */
 static void
 error ("weak declaration of %q+D must precede definition", decl);
 else if (!SUPPORTS_WEAK)
 warning (0, "weak declaration of %q+D not supported", decl);
 mark_weak (decl);
-if (!lookup_attribute ("weak", DECL_ATTRIBUTES (decl)))
-DECL_ATTRIBUTES (decl)
-= tree_cons (get_identifier ("weak"), NULL, DECL_ATTRIBUTES (decl));
 }
 static void
 weak_finish_1 (tree decl)
 {
 # else
 	  tree decl = find_decl_and_mark_needed (alias_decl, target);
 	  if (! decl)
 	    {
-	      decl = build_decl (TREE_CODE (alias_decl), target,
+	      decl = build_decl (DECL_SOURCE_LOCATION (alias_decl),
+				 TREE_CODE (alias_decl), target,
 				 TREE_TYPE (alias_decl));
 	      DECL_EXTERNAL (decl) = 1;
 	      TREE_PUBLIC (decl) = 1;
 	      DECL_ARTIFICIAL (decl) = 1;
 #endif
 targetm.asm_out.globalize_decl_name (asm_out_file, decl);
 }
-/* We have to be able to tell cgraph about the needed-ness of the target
+VEC(alias_pair,gc) *alias_pairs;
-of an alias.  This requires that the decl have been defined.  Aliases
-that precede their definition have to be queued for later processing.  */
-typedef struct alias_pair GTY(())
-{
-tree decl;
-tree target;
-} alias_pair;
-/* Define gc'd vector type.  */
-DEF_VEC_O(alias_pair);
-DEF_VEC_ALLOC_O(alias_pair,gc);
-static GTY(()) VEC(alias_pair,gc) *alias_pairs;
 /* Given an assembly name, find the decl it is associated with.  At the
 same time, mark it needed for cgraph.  */
 static tree
 	fnode = cgraph_node_for_asm (target);
 }
 if (fnode)
 {
-/* We can't mark function nodes as used after cgraph global info
+cgraph_mark_needed_node (fnode);
-	 is finished.  This wouldn't generally be necessary, but C++
-	 virtual table thunks are introduced late in the game and
-	 might seem like they need marking, although in fact they
-	 don't.  */
-if (! cgraph_global_info_ready)
-	cgraph_mark_needed_node (fnode);
 return fnode->decl;
 }
 else if (vnode)
 {
 varpool_mark_needed_node (vnode);
 			  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
 			  IDENTIFIER_POINTER (target));
 #else
 if (!SUPPORTS_WEAK)
 	{
-	  error ("%Jweakref is not supported in this configuration", decl);
+	  error_at (DECL_SOURCE_LOCATION (decl),
+		    "weakref is not supported in this configuration");
 	  return;
 	}
 #endif
 return;
 }
 }
 }
 #endif
 }
+/* Remove the alias pairing for functions that are no longer in the call
+graph.  */
+void
+remove_unreachable_alias_pairs (void)
+{
+unsigned i;
+alias_pair *p;
+if (alias_pairs == NULL)
+return;
+for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); )
+{
+if (!DECL_EXTERNAL (p->decl))
+	{
+	  struct cgraph_node *fnode = NULL;
+	  struct varpool_node *vnode = NULL;
+	  fnode = cgraph_node_for_asm (p->target);
+	  vnode = (fnode == NULL) ? varpool_node_for_asm (p->target) : NULL;
+	  if (fnode == NULL && vnode == NULL)
+	    {
+	      VEC_unordered_remove (alias_pair, alias_pairs, i);
+	      continue;
+	    }
+	}
+i++;
+}
+}
 /* First pass of completing pending aliases.  Make sure that cgraph knows
 which symbols will be required.  */
 void
 finish_aliases_1 (void)
 target_decl = find_decl_and_mark_needed (p->decl, p->target);
 if (target_decl == NULL)
 	{
 	  if (! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
-	    error ("%q+D aliased to undefined symbol %qs",
+	    error ("%q+D aliased to undefined symbol %qE",
-		   p->decl, IDENTIFIER_POINTER (p->target));
+		   p->decl, p->target);
 	}
 else if (DECL_EXTERNAL (target_decl)
+	       /* We use local aliases for C++ thunks to force the tailcall
+		  to bind locally.  Of course this is a hack - to keep it
+		  working do the following (which is not strictly correct).  */
+	       && (! TREE_CODE (target_decl) == FUNCTION_DECL
+		   || ! DECL_VIRTUAL_P (target_decl))
 	       && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
-	error ("%q+D aliased to external symbol %qs",
+	error ("%q+D aliased to external symbol %qE",
-	       p->decl, IDENTIFIER_POINTER (p->target));
+	       p->decl, p->target);
 }
 }
 /* Second pass of completing pending aliases.  Emit the actual assembly.
 This happens at the end of compilation and thus it is assured that the
 }
 else
 {
 #if !defined (ASM_OUTPUT_DEF)
 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
-error ("%Jalias definitions not supported in this configuration", decl);
+error_at (DECL_SOURCE_LOCATION (decl),
+		"alias definitions not supported in this configuration");
 return;
 # else
 if (!DECL_WEAK (decl))
 	{
-	  error ("%Jonly weak aliases are supported in this configuration", decl);
+	  error_at (DECL_SOURCE_LOCATION (decl),
+		    "only weak aliases are supported in this configuration");
 	  return;
 	}
 # endif
 #endif
 }
 /* Set up DECL as a public symbol that can be defined in multiple
 translation units without generating a linker error.  */
 void
-make_decl_one_only (tree decl)
+make_decl_one_only (tree decl, tree comdat_group)
 {
 gcc_assert (TREE_CODE (decl) == VAR_DECL
 	      || TREE_CODE (decl) == FUNCTION_DECL);
 TREE_PUBLIC (decl) = 1;
 if (SUPPORTS_ONE_ONLY)
 {
 #ifdef MAKE_DECL_ONE_ONLY
 MAKE_DECL_ONE_ONLY (decl);
 #endif
-DECL_ONE_ONLY (decl) = 1;
+DECL_COMDAT_GROUP (decl) = comdat_group;
 }
 else if (TREE_CODE (decl) == VAR_DECL
 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
 DECL_COMMON (decl) = 1;
 else
 fprintf (asm_out_file, format, type);
 if (flags & SECTION_ENTSIZE)
 	fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
-	fprintf (asm_out_file, ",%s,comdat",
+	{
-		 lang_hooks.decls.comdat_group (decl));
+	  if (TREE_CODE (decl) == IDENTIFIER_NODE)
+	    fprintf (asm_out_file, ",%s,comdat", IDENTIFIER_POINTER (decl));
+	  else
+	    fprintf (asm_out_file, ",%s,comdat",
+		     IDENTIFIER_POINTER (DECL_COMDAT_GROUP (decl)));
+	}
 }
 putc ('\n', asm_out_file);
 }
 name = targetm.strip_name_encoding (name);
 /* If we're using one_only, then there needs to be a .gnu.linkonce
 prefix to the section name.  */
 linkonce = one_only ? ".gnu.linkonce" : "";
 string = ACONCAT ((linkonce, prefix, ".", name, NULL));
 DECL_SECTION_NAME (decl) = build_string (strlen (string), string);
 }
 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))
 flags |= SYMBOL_FLAG_LOCAL;
-if (targetm.have_tls && TREE_CODE (decl) == VAR_DECL
+if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)
-&& DECL_THREAD_LOCAL_P (decl))
+&& DECL_TLS_MODEL (decl) != TLS_MODEL_EMULATED)
 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
 else if (targetm.in_small_data_p (decl))
 flags |= SYMBOL_FLAG_SMALL;
 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names?  Without
 being PUBLIC, the thing *must* be defined in this translation unit.
 local_p = true;
 return local_p;
 }
-/* Determine whether or not a pointer mode is valid. Assume defaults
-of ptr_mode or Pmode - can be overridden.  */
-bool
-default_valid_pointer_mode (enum machine_mode mode)
-{
-return (mode == ptr_mode || mode == Pmode);
-}
 /* Default function to output code that will globalize a label.  A
 target must define GLOBAL_ASM_OP or provide its own function to
 globalize a label.  */
 #ifdef GLOBAL_ASM_OP
 void

Mercurial > hg > CbC > CbC_gcc

comparison gcc/varasm.c @ 55:77e2b8dfacca gcc-4.4.5