/* 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
- Free Software Foundation, Inc.
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+ 2010, 2011 Free Software Foundation, Inc.
This file is part of GCC.
#include "expr.h"
#include "hard-reg-set.h"
#include "regs.h"
-#include "real.h"
#include "output.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
#include "hashtab.h"
#include "ggc.h"
#include "langhooks.h"
#include "tm_p.h"
#include "debug.h"
#include "target.h"
+#include "common/common-target.h"
#include "targhooks.h"
#include "tree-mudflap.h"
#include "cgraph.h"
#include "cfglayout.h"
#include "basic-block.h"
#include "tree-iterator.h"
+#include "pointer-set.h"
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h" /* Needed for external data
static alias_set_type const_alias_set;
+/* Whether we saw any functions with no_split_stack. */
+
+static bool saw_no_split_stack;
+
static const char *strip_reg_name (const char *);
static int contains_pointers_p (tree);
#ifdef ASM_OUTPUT_EXTERNAL
static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
static unsigned min_align (unsigned, unsigned);
static void globalize_decl (tree);
+static bool decl_readonly_section_1 (enum section_category);
#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);
-#endif
#ifdef ASM_OUTPUT_ALIGNED_BSS
static void asm_output_aligned_bss (FILE *, tree, const char *,
unsigned HOST_WIDE_INT, int)
static GTY(()) section *unnamed_sections;
/* Return a nonzero value if DECL has a section attribute. */
-#ifndef IN_NAMED_SECTION
#define IN_NAMED_SECTION(DECL) \
((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
&& DECL_SECTION_NAME (DECL) != NULL_TREE)
-#endif
/* Hash table of named sections. */
static GTY((param_is (section))) htab_t section_htab;
/* A pool of constants that can be shared between functions. */
static GTY(()) struct rtx_constant_pool *shared_constant_pool;
-/* TLS emulation. */
-
-static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
- htab_t emutls_htab;
-static GTY (()) tree emutls_object_type;
-/* Emulated TLS objects have the TLS model TLS_MODEL_EMULATED. This
- macro can be used on them to distinguish the control variable from
- the initialization template. */
-#define DECL_EMUTLS_VAR_P(D) (TREE_TYPE (D) == emutls_object_type)
-
-#if !defined (NO_DOT_IN_LABEL)
-# define EMUTLS_SEPARATOR "."
-#elif !defined (NO_DOLLAR_IN_LABEL)
-# define EMUTLS_SEPARATOR "$"
-#else
-# define EMUTLS_SEPARATOR "_"
-#endif
-
-/* Create an IDENTIFIER_NODE by prefixing PREFIX to the
- IDENTIFIER_NODE NAME's name. */
-
-static tree
-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);
-}
-
-/* Create an identifier for the struct __emutls_object, given an identifier
- of the DECL_ASSEMBLY_NAME of the original object. */
-
-static tree
-get_emutls_object_name (tree name)
-{
- const char *prefix = (targetm.emutls.var_prefix
- ? targetm.emutls.var_prefix
- : "__emutls_v" EMUTLS_SEPARATOR);
- return prefix_name (prefix, name);
-}
-
-tree
-default_emutls_var_fields (tree type, tree *name ATTRIBUTE_UNUSED)
-{
- tree word_type_node, field, next_field;
-
- field = build_decl (UNKNOWN_LOCATION,
- FIELD_DECL, get_identifier ("__templ"), ptr_type_node);
- DECL_CONTEXT (field) = type;
- next_field = field;
-
- 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 (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 (UNKNOWN_LOCATION,
- FIELD_DECL, get_identifier ("__size"), word_type_node);
- DECL_CONTEXT (field) = type;
- TREE_CHAIN (field) = next_field;
-
- return field;
-}
-
-/* Create the structure for struct __emutls_object. This should match the
- structure at the top of emutls.c, modulo the union there. */
-
-static tree
-get_emutls_object_type (void)
-{
- tree type, type_name, field;
-
- type = emutls_object_type;
- if (type)
- return type;
-
- 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 (UNKNOWN_LOCATION,
- TYPE_DECL, type_name, type);
- TYPE_NAME (type) = type_name;
- TYPE_FIELDS (type) = field;
- layout_type (type);
-
- return type;
-}
-
-/* Create a read-only variable like DECL, with the same DECL_INITIAL.
- This will be used for initializing the emulated tls data area. */
-
-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);
- if (!targetm.emutls.tmpl_prefix || targetm.emutls.tmpl_prefix[0])
- {
- const char *prefix = (targetm.emutls.tmpl_prefix
- ? targetm.emutls.tmpl_prefix
- : "__emutls_t" EMUTLS_SEPARATOR);
- name = prefix_name (prefix, name);
- }
-
- 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, DECL_ASSEMBLER_NAME (to));
- TREE_STATIC (to) = TREE_STATIC (decl);
- TREE_PUBLIC (to) = TREE_PUBLIC (decl);
- DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
- }
- else
- TREE_STATIC (to) = 1;
-
- DECL_INITIAL (to) = DECL_INITIAL (decl);
- DECL_INITIAL (decl) = NULL;
-
- varpool_finalize_decl (to);
- return build_fold_addr_expr (to);
-}
-
-/* When emulating tls, we use a control structure for use by the runtime.
- Create and return this structure. */
-
-tree
-emutls_decl (tree decl)
-{
- tree name, to;
- struct tree_map *h, in;
- void **loc;
-
- if (targetm.have_tls || decl == NULL || decl == error_mark_node
- || TREE_CODE (decl) != VAR_DECL || ! DECL_THREAD_LOCAL_P (decl))
- return decl;
-
- /* Look up the object in the hash; return the control structure if
- it has already been created. */
- if (! emutls_htab)
- emutls_htab = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
-
- name = DECL_ASSEMBLER_NAME (decl);
-
- /* Note that we use the hash of the decl's name, rather than a hash
- of the decl's pointer. In emutls_finish we iterate through the
- hash table, and we want this traversal to be predictable. */
- in.hash = htab_hash_string (IDENTIFIER_POINTER (name));
- in.base.from = decl;
- loc = htab_find_slot_with_hash (emutls_htab, &in, in.hash, INSERT);
- h = (struct tree_map *) *loc;
- if (h != NULL)
- to = h->to;
- else
- {
- 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;
- h->to = to;
- *(struct tree_map **) loc = h;
-
- DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
- 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, 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;
- }
-
- /* Note that these fields may need to be updated from time to time from
- the original decl. Consider:
- extern __thread int i;
- int foo() { return i; }
- __thread int i = 1;
- in which I goes from external to locally defined and initialized. */
-
- TREE_STATIC (to) = TREE_STATIC (decl);
- TREE_USED (to) = TREE_USED (decl);
- TREE_PUBLIC (to) = TREE_PUBLIC (decl);
- DECL_EXTERNAL (to) = DECL_EXTERNAL (decl);
- DECL_COMMON (to) = DECL_COMMON (decl);
- DECL_WEAK (to) = DECL_WEAK (decl);
- DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
-
- return to;
-}
-
-static int
-emutls_common_1 (void **loc, void *xstmts)
-{
- struct tree_map *h = *(struct tree_map **) loc;
- tree args, x, *pstmts = (tree *) xstmts;
- tree word_type_node;
-
- if (! DECL_COMMON (h->base.from)
- || (DECL_INITIAL (h->base.from)
- && DECL_INITIAL (h->base.from) != error_mark_node))
- return 1;
-
- word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
-
- /* The idea was to call get_emutls_init_templ_addr here, but if we
- do this and there is an initializer, -fanchor_section loses,
- because it would be too late to ensure the template is
- output. */
- x = null_pointer_node;
- args = tree_cons (NULL, x, NULL);
- x = build_int_cst (word_type_node, DECL_ALIGN_UNIT (h->base.from));
- args = tree_cons (NULL, x, args);
- x = fold_convert (word_type_node, DECL_SIZE_UNIT (h->base.from));
- 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 (UNKNOWN_LOCATION, x, args);
-
- append_to_statement_list (x, pstmts);
- return 1;
-}
-
-void
-emutls_finish (void)
-{
- if (targetm.emutls.register_common)
- {
- tree body = NULL_TREE;
-
- if (emutls_htab == NULL)
- 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. */
static int
{
section *sect;
- sect = GGC_NEW (section);
+ sect = ggc_alloc_section ();
sect->unnamed.common.flags = flags | SECTION_UNNAMED;
sect->unnamed.callback = callback;
sect->unnamed.data = data;
{
section *sect;
- sect = GGC_NEW (section);
+ sect = ggc_alloc_section ();
sect->noswitch.common.flags = flags | SECTION_NOSWITCH;
sect->noswitch.callback = callback;
flags |= SECTION_NAMED;
if (*slot == NULL)
{
- sect = GGC_NEW (section);
+ sect = ggc_alloc_section ();
sect->named.common.flags = flags;
sect->named.name = ggc_strdup (name);
sect->named.decl = decl;
if ((sect->common.flags & ~SECTION_DECLARED) != flags
&& ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0)
{
+ /* It is fine if one of the section flags is
+ SECTION_WRITE | SECTION_RELRO and the other has none of these
+ flags (i.e. read-only) in named sections and either the
+ section hasn't been declared yet or has been declared as writable.
+ In that case just make sure the resulting flags are
+ SECTION_WRITE | SECTION_RELRO, ie. writable only because of
+ relocations. */
+ if (((sect->common.flags ^ flags) & (SECTION_WRITE | SECTION_RELRO))
+ == (SECTION_WRITE | SECTION_RELRO)
+ && (sect->common.flags
+ & ~(SECTION_DECLARED | SECTION_WRITE | SECTION_RELRO))
+ == (flags & ~(SECTION_WRITE | SECTION_RELRO))
+ && ((sect->common.flags & SECTION_DECLARED) == 0
+ || (sect->common.flags & SECTION_WRITE)))
+ {
+ sect->common.flags |= (SECTION_WRITE | SECTION_RELRO);
+ return sect;
+ }
/* Sanity check user variables for flag changes. */
if (decl == 0)
decl = sect->named.decl;
gcc_assert (decl);
- error ("%+D causes a section type conflict", decl);
+ error ("%+D causes a section type conflict with %D",
+ decl, sect->named.decl);
+ if (decl != sect->named.decl)
+ inform (DECL_SOURCE_LOCATION (sect->named.decl),
+ "%qD was declared here", sect->named.decl);
+ /* Make sure we don't error about one section multiple times. */
+ sect->common.flags |= SECTION_OVERRIDE;
}
}
return sect;
block = (struct object_block *) *slot;
if (block == NULL)
{
- block = (struct object_block *)
- ggc_alloc_cleared (sizeof (struct object_block));
+ block = ggc_alloc_cleared_object_block ();
block->sect = sect;
*slot = block;
}
/* Create the extended SYMBOL_REF. */
size = RTX_HDR_SIZE + sizeof (struct block_symbol);
- symbol = (rtx) ggc_alloc_zone (size, &rtl_zone);
+ symbol = ggc_alloc_zone_rtx_def (size, &rtl_zone);
/* Initialize the normal SYMBOL_REF fields. */
memset (symbol, 0, size);
return symbol;
}
-static void
-initialize_cold_section_name (void)
-{
- const char *stripped_name;
- char *name, *buffer;
- tree dsn;
-
- gcc_assert (cfun && current_function_decl);
- if (crtl->subsections.unlikely_text_section_name)
- return;
-
- dsn = DECL_SECTION_NAME (current_function_decl);
- if (flag_function_sections && dsn)
- {
- name = (char *) alloca (TREE_STRING_LENGTH (dsn) + 1);
- memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1);
-
- stripped_name = targetm.strip_name_encoding (name);
-
- buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
- crtl->subsections.unlikely_text_section_name = ggc_strdup (buffer);
- }
- else
- crtl->subsections.unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
-}
-
-/* Tell assembler to switch to unlikely-to-be-executed text section. */
-
-section *
-unlikely_text_section (void)
-{
- if (cfun)
- {
- if (!crtl->subsections.unlikely_text_section_name)
- initialize_cold_section_name ();
-
- return get_named_section (NULL, crtl->subsections.unlikely_text_section_name, 0);
- }
- else
- return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
-}
-
-/* When called within a function context, return true if the function
- has been assigned a cold text section and if SECT is that section.
- When called outside a function context, return true if SECT is the
- default cold section. */
-
-bool
-unlikely_text_section_p (section *sect)
-{
- const char *name;
-
- if (cfun)
- name = crtl->subsections.unlikely_text_section_name;
- else
- name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
-
- return (name
- && sect
- && SECTION_STYLE (sect) == SECTION_NAMED
- && strcmp (name, sect->named.name) == 0);
-}
-
/* Return a section with a particular name and with whatever SECTION_*
flags section_type_flags deems appropriate. The name of the section
is taken from NAME if nonnull, otherwise it is taken from DECL's
int flag_function_or_data_sections)
{
if (DECL_SECTION_NAME (decl) == NULL_TREE
- && targetm.have_named_sections
+ && targetm_common.have_named_sections
&& (flag_function_or_data_sections
|| DECL_ONE_ONLY (decl)))
- targetm.asm_out.unique_section (decl, reloc);
+ {
+ targetm.asm_out.unique_section (decl, reloc);
+ DECL_HAS_IMPLICIT_SECTION_NAME_P (decl) = true;
+ }
}
#ifdef BSS_SECTION_ASM_OP
-#ifdef ASM_OUTPUT_BSS
-
-/* Utility function for ASM_OUTPUT_BSS for targets to use if
- they don't support alignments in .bss.
- ??? It is believed that this function will work in most cases so such
- support is localized here. */
-
-static void
-asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
- const char *name,
- unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
- unsigned HOST_WIDE_INT rounded)
-{
- gcc_assert (strcmp (XSTR (XEXP (DECL_RTL (decl), 0), 0), name) == 0);
- targetm.asm_out.globalize_decl_name (file, decl);
- switch_to_section (bss_section);
-#ifdef ASM_DECLARE_OBJECT_NAME
- last_assemble_variable_decl = decl;
- ASM_DECLARE_OBJECT_NAME (file, name, decl);
-#else
- /* Standard thing is just output label for the object. */
- ASM_OUTPUT_LABEL (file, name);
-#endif /* ASM_DECLARE_OBJECT_NAME */
- ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
-}
-
-#endif
-
#ifdef ASM_OUTPUT_ALIGNED_BSS
/* Utility function for targets to use in implementing
{
if (decl != NULL_TREE
&& DECL_SECTION_NAME (decl) != NULL_TREE
- && targetm.have_named_sections)
+ && targetm_common.have_named_sections)
return get_named_section (decl, NULL, 0);
else
return text_section;
}
#endif
+/* Return section for TEXT_SECTION_NAME if DECL or DECL_SECTION_NAME (DECL)
+ is NULL.
+
+ When DECL_SECTION_NAME is non-NULL and it is implicit section and
+ NAMED_SECTION_SUFFIX is non-NULL, then produce section called
+ concatenate the name with NAMED_SECTION_SUFFIX.
+ Otherwise produce "TEXT_SECTION_NAME.IMPLICIT_NAME". */
+
+section *
+get_named_text_section (tree decl,
+ const char *text_section_name,
+ const char *named_section_suffix)
+{
+ if (decl && DECL_SECTION_NAME (decl))
+ {
+ if (named_section_suffix)
+ {
+ tree dsn = DECL_SECTION_NAME (decl);
+ const char *stripped_name;
+ char *name, *buffer;
+
+ name = (char *) alloca (TREE_STRING_LENGTH (dsn) + 1);
+ memcpy (name, TREE_STRING_POINTER (dsn),
+ TREE_STRING_LENGTH (dsn) + 1);
+
+ stripped_name = targetm.strip_name_encoding (name);
+
+ buffer = ACONCAT ((stripped_name, named_section_suffix, NULL));
+ return get_named_section (decl, buffer, 0);
+ }
+ else if (DECL_HAS_IMPLICIT_SECTION_NAME_P (decl))
+ {
+ const char *name;
+
+ /* Do not try to split gnu_linkonce functions. This gets somewhat
+ slipperly. */
+ if (DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP)
+ return NULL;
+ name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+ name = targetm.strip_name_encoding (name);
+ return get_named_section (decl, ACONCAT ((text_section_name, ".",
+ name, NULL)), 0);
+ }
+ else
+ return NULL;
+ }
+ return get_named_section (decl, text_section_name, 0);
+}
+
+/* Choose named function section based on its frequency. */
+
+section *
+default_function_section (tree decl, enum node_frequency freq,
+ bool startup, bool exit)
+{
+#if defined HAVE_LD_EH_GC_SECTIONS && defined HAVE_LD_EH_GC_SECTIONS_BUG
+ /* Old GNU linkers have buggy --gc-section support, which sometimes
+ results in .gcc_except_table* sections being garbage collected. */
+ if (decl
+ && DECL_SECTION_NAME (decl)
+ && DECL_HAS_IMPLICIT_SECTION_NAME_P (decl))
+ return NULL;
+#endif
+
+ if (!flag_reorder_functions
+ || !targetm_common.have_named_sections)
+ return NULL;
+ /* Startup code should go to startup subsection unless it is
+ unlikely executed (this happens especially with function splitting
+ where we can split away unnecesary parts of static constructors. */
+ if (startup && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED)
+ return get_named_text_section (decl, ".text.startup", NULL);
+
+ /* Similarly for exit. */
+ if (exit && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED)
+ return get_named_text_section (decl, ".text.exit", NULL);
+
+ /* Group cold functions together, similarly for hot code. */
+ switch (freq)
+ {
+ case NODE_FREQUENCY_UNLIKELY_EXECUTED:
+ return get_named_text_section (decl, ".text.unlikely", NULL);
+ case NODE_FREQUENCY_HOT:
+ return get_named_text_section (decl, ".text.hot", NULL);
+ default:
+ return NULL;
+ }
+}
+
/* Return the section for function DECL.
If DECL is NULL_TREE, return the text section. We can be passed
- NULL_TREE under some circumstances by dbxout.c at least. */
+ NULL_TREE under some circumstances by dbxout.c at least.
-section *
-function_section (tree decl)
+ If FORCE_COLD is true, return cold function section ignoring
+ the frequency info of cgraph_node. */
+
+static section *
+function_section_1 (tree decl, bool force_cold)
{
- int reloc = 0;
+ section *section = NULL;
+ enum node_frequency freq = NODE_FREQUENCY_NORMAL;
+ bool startup = false, exit = false;
- if (first_function_block_is_cold)
- reloc = 1;
+ if (decl)
+ {
+ struct cgraph_node *node = cgraph_get_node (decl);
+
+ if (node)
+ {
+ freq = node->frequency;
+ startup = node->only_called_at_startup;
+ exit = node->only_called_at_exit;
+ }
+ }
+ if (force_cold)
+ freq = NODE_FREQUENCY_UNLIKELY_EXECUTED;
#ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
if (decl != NULL_TREE
&& DECL_SECTION_NAME (decl) != NULL_TREE)
- return reloc ? unlikely_text_section ()
- : get_named_section (decl, NULL, 0);
+ {
+ if (targetm.asm_out.function_section)
+ section = targetm.asm_out.function_section (decl, freq,
+ startup, exit);
+ if (section)
+ return section;
+ return get_named_section (decl, NULL, 0);
+ }
else
- return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
+ return targetm.asm_out.select_section
+ (decl, freq == NODE_FREQUENCY_UNLIKELY_EXECUTED,
+ DECL_ALIGN (decl));
#else
- return reloc ? unlikely_text_section () : hot_function_section (decl);
+ if (targetm.asm_out.function_section)
+ section = targetm.asm_out.function_section (decl, freq, startup, exit);
+ if (section)
+ return section;
+ return hot_function_section (decl);
#endif
}
+/* Return the section for function DECL.
+
+ If DECL is NULL_TREE, return the text section. We can be passed
+ NULL_TREE under some circumstances by dbxout.c at least. */
+
+section *
+function_section (tree decl)
+{
+ /* Handle cases where function splitting code decides
+ to put function entry point into unlikely executed section
+ despite the fact that the function itself is not cold
+ (i.e. it is called rarely but contains a hot loop that is
+ better to live in hot subsection for the code locality). */
+ return function_section_1 (decl,
+ first_function_block_is_cold);
+}
+
+/* Return the section for the current function, take IN_COLD_SECTION_P
+ into account. */
+
section *
current_function_section (void)
{
-#ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
- if (current_function_decl != NULL_TREE
- && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
- return in_cold_section_p ? unlikely_text_section ()
- : get_named_section (current_function_decl,
- NULL, 0);
- else
- return targetm.asm_out.select_section (current_function_decl,
- in_cold_section_p,
- DECL_ALIGN (current_function_decl));
-#else
- return (in_cold_section_p
- ? unlikely_text_section ()
- : hot_function_section (current_function_decl));
-#endif
+ return function_section_1 (current_function_decl, in_cold_section_p);
+}
+
+/* Tell assembler to switch to unlikely-to-be-executed text section. */
+
+section *
+unlikely_text_section (void)
+{
+ return function_section_1 (current_function_decl, true);
+}
+
+/* When called within a function context, return true if the function
+ has been assigned a cold text section and if SECT is that section.
+ When called outside a function context, return true if SECT is the
+ default cold section. */
+
+bool
+unlikely_text_section_p (section *sect)
+{
+ return sect == function_section_1 (current_function_decl, true);
}
/* Return the read-only data section associated with function DECL. */
const char *str;
HOST_WIDE_INT i;
int j, unit;
- char name[30];
+ const char *prefix = targetm.asm_out.mergeable_rodata_prefix;
+ char *name = (char *) alloca (strlen (prefix) + 30);
mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
modesize = GET_MODE_BITSIZE (mode);
}
if (i == len - unit)
{
- sprintf (name, ".rodata.str%d.%d", modesize / 8,
- (int) (align / 8));
+ sprintf (name, "%s.str%d.%d", prefix,
+ modesize / 8, (int) (align / 8));
flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
return get_section (name, flags, NULL);
}
&& align <= 256
&& (align & (align - 1)) == 0)
{
- char name[24];
+ const char *prefix = targetm.asm_out.mergeable_rodata_prefix;
+ char *name = (char *) alloca (strlen (prefix) + 30);
- sprintf (name, ".rodata.cst%d", (int) (align / 8));
+ sprintf (name, "%s.cst%d", prefix, (int) (align / 8));
flags |= (align / 8) | SECTION_MERGE;
return get_section (name, flags, NULL);
}
Prefixes such as % are optional. */
int
-decode_reg_name (const char *asmspec)
+decode_reg_name_and_count (const char *asmspec, int *pnregs)
{
+ /* Presume just one register is clobbered. */
+ *pnregs = 1;
+
if (asmspec != 0)
{
int i;
&& ! strcmp (asmspec, strip_reg_name (reg_names[i])))
return i;
+#ifdef OVERLAPPING_REGISTER_NAMES
+ {
+ static const struct
+ {
+ const char *const name;
+ const int number;
+ const int nregs;
+ } table[] = OVERLAPPING_REGISTER_NAMES;
+
+ for (i = 0; i < (int) ARRAY_SIZE (table); i++)
+ if (table[i].name[0]
+ && ! strcmp (asmspec, table[i].name))
+ {
+ *pnregs = table[i].nregs;
+ return table[i].number;
+ }
+ }
+#endif /* OVERLAPPING_REGISTER_NAMES */
+
#ifdef ADDITIONAL_REGISTER_NAMES
{
static const struct { const char *const name; const int number; } table[]
return -1;
}
+
+int
+decode_reg_name (const char *name)
+{
+ int count;
+ return decode_reg_name_and_count (name, &count);
+}
+
\f
/* Return true if DECL's initializer is suitable for a BSS section. */
should be placed. PREFER_NOSWITCH_P is true if a noswitch
section should be used wherever possible. */
-static section *
+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
- isn't common, and shouldn't be handled as such. */
- if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL)
+ if (TREE_TYPE (decl) != error_mark_node)
+ as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
+
+ if (DECL_COMMON (decl))
{
+ /* 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. */
+ gcc_assert (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. */
- else if (DECL_TLS_MODEL (decl) == TLS_MODEL_EMULATED
- && !targetm.emutls.register_common)
- ;
else if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
return comm_section;
}
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 (DECL_INITIAL (decl) == decl)
return false;
- /* If this decl is an alias, then we don't want to emit a definition. */
+ /* If this decl is an alias, then we don't want to emit a
+ definition. */
if (lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
return false;
return;
}
+ /* If this variable belongs to the global constant pool, retrieve the
+ pre-computed RTL or recompute it in LTO mode. */
+ if (TREE_CODE (decl) == VAR_DECL && DECL_IN_CONSTANT_POOL (decl))
+ {
+ SET_DECL_RTL (decl, output_constant_def (DECL_INITIAL (decl), 1));
+ return;
+ }
+
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
#endif
nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
while (nregs > 0)
- globalize_reg (reg_number + --nregs);
+ globalize_reg (decl, reg_number + --nregs);
}
/* As a register variable, it has no section. */
/* Specifying a section attribute on a variable forces it into a
non-.bss section, and thus it cannot be common. */
+ /* FIXME: In general this code should not be necessary because
+ visibility pass is doing the same work. But notice_global_symbol
+ is called early and it needs to make DECL_RTL to get the name.
+ we take care of recomputing the DECL_RTL after visibility is changed. */
if (TREE_CODE (decl) == VAR_DECL
&& DECL_SECTION_NAME (decl) != NULL_TREE
&& DECL_INITIAL (decl) == NULL_TREE
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);
if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
mudflap_enqueue_decl (decl);
}
+
+/* Like make_decl_rtl, but inhibit creation of new alias sets when
+ calling make_decl_rtl. Also, reset DECL_RTL before returning the
+ rtl. */
+
+rtx
+make_decl_rtl_for_debug (tree decl)
+{
+ unsigned int save_aliasing_flag, save_mudflap_flag;
+ rtx rtl;
+
+ if (DECL_RTL_SET_P (decl))
+ return DECL_RTL (decl);
+
+ /* Kludge alert! Somewhere down the call chain, make_decl_rtl will
+ call new_alias_set. If running with -fcompare-debug, sometimes
+ we do not want to create alias sets that will throw the alias
+ numbers off in the comparison dumps. So... clearing
+ flag_strict_aliasing will keep new_alias_set() from creating a
+ new set. It is undesirable to register decl with mudflap
+ in this case as well. */
+ save_aliasing_flag = flag_strict_aliasing;
+ flag_strict_aliasing = 0;
+ save_mudflap_flag = flag_mudflap;
+ flag_mudflap = 0;
+
+ rtl = DECL_RTL (decl);
+ /* Reset DECL_RTL back, as various parts of the compiler expects
+ DECL_RTL set meaning it is actually going to be output. */
+ SET_DECL_RTL (decl, NULL);
+
+ flag_strict_aliasing = save_aliasing_flag;
+ flag_mudflap = save_mudflap_flag;
+
+ return rtl;
+}
\f
/* Output a string of literal assembler code
for an `asm' keyword used between functions. */
}
/* Write the address of the entity given by SYMBOL to SEC. */
-void
+void
assemble_addr_to_section (rtx symbol, section *sec)
{
switch_to_section (sec);
section *sec;
if (priority != DEFAULT_INIT_PRIORITY)
- sec = get_cdtor_priority_section (priority,
+ sec = get_cdtor_priority_section (priority,
/*constructor_p=*/false);
else
sec = get_section (".dtors", SECTION_WRITE, NULL);
section *sec;
if (priority != DEFAULT_INIT_PRIORITY)
- sec = get_cdtor_priority_section (priority,
+ sec = get_cdtor_priority_section (priority,
/*constructor_p=*/true);
else
sec = get_section (".ctors", SECTION_WRITE, NULL);
}
}
+/* If not using flag_reorder_blocks_and_partition, decide early whether the
+ current function goes into the cold section, so that targets can use
+ current_function_section during RTL expansion. DECL describes the
+ function. */
+
+void
+decide_function_section (tree decl)
+{
+ first_function_block_is_cold = false;
+
+ if (flag_reorder_blocks_and_partition)
+ /* We will decide in assemble_start_function. */
+ return;
+
+ if (DECL_SECTION_NAME (decl))
+ {
+ struct cgraph_node *node = cgraph_get_node (current_function_decl);
+ /* Calls to function_section rely on first_function_block_is_cold
+ being accurate. */
+ first_function_block_is_cold = (node
+ && node->frequency
+ == NODE_FREQUENCY_UNLIKELY_EXECUTED);
+ }
+
+ in_cold_section_p = first_function_block_is_cold;
+}
+
/* Output assembler code for the constant pool of a function and associated
with defining the name of the function. DECL describes the function.
NAME is the function's name. For the constant pool, we use the current
char tmp_label[100];
bool hot_label_written = false;
- crtl->subsections.unlikely_text_section_name = NULL;
-
- first_function_block_is_cold = false;
if (flag_reorder_blocks_and_partition)
{
ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
if (CONSTANT_POOL_BEFORE_FUNCTION)
output_constant_pool (fnname, decl);
- resolve_unique_section (decl, 0, flag_function_sections);
-
/* Make sure the not and cold text (code) sections are properly
aligned. This is necessary here in the case where the function
has both hot and cold sections, because we don't want to re-set
if (flag_reorder_blocks_and_partition)
{
+ first_function_block_is_cold = false;
+
switch_to_section (unlikely_text_section ());
assemble_align (DECL_ALIGN (decl));
ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label);
hot_label_written = true;
first_function_block_is_cold = true;
}
+ in_cold_section_p = first_function_block_is_cold;
}
- else if (DECL_SECTION_NAME (decl))
- {
- /* Calls to function_section rely on first_function_block_is_cold
- being accurate. The first block may be cold even if we aren't
- doing partitioning, if the entire function was decided by
- choose_function_section (predict.c) to be cold. */
- initialize_cold_section_name ();
-
- if (crtl->subsections.unlikely_text_section_name
- && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
- crtl->subsections.unlikely_text_section_name) == 0)
- first_function_block_is_cold = true;
- }
-
- in_cold_section_p = first_function_block_is_cold;
/* Switch to the correct text section for the start of the function. */
ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
#else
/* Standard thing is just output label for the function. */
- ASM_OUTPUT_LABEL (asm_out_file, fnname);
+ ASM_OUTPUT_FUNCTION_LABEL (asm_out_file, fnname, current_function_decl);
#endif /* ASM_DECLARE_FUNCTION_NAME */
+
+ if (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (decl)))
+ saw_no_split_stack = true;
}
/* Output assembler code associated with defining the size of the
/* A noswitch_section_callback for bss_noswitch_section. */
-#if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
+#if defined ASM_OUTPUT_ALIGNED_BSS
static bool
emit_bss (tree decl ATTRIBUTE_UNUSED,
const char *name ATTRIBUTE_UNUSED,
#if defined ASM_OUTPUT_ALIGNED_BSS
ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
return true;
-#else
- ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
- return false;
#endif
}
#endif
}
}
-/* Initialize emulated tls object TO, which refers to TLS variable
- DECL and is initialized by PROXY. */
-
-tree
-default_emutls_var_init (tree to, tree decl, tree proxy)
-{
- 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.
Should not be called for variables of incomplete structure type.
rtx decl_rtl, symbol;
section *sect;
- if (! targetm.have_tls
- && TREE_CODE (decl) == VAR_DECL
- && DECL_THREAD_LOCAL_P (decl))
- {
- tree to = emutls_decl (decl);
-
- /* If this variable is defined locally, then we need to initialize the
- control structure with size and alignment information. We do this
- at the last moment because tentative definitions can take a locally
- defined but uninitialized variable and initialize it later, which
- would result in incorrect contents. */
- if (! DECL_EXTERNAL (to)
- && (! DECL_COMMON (to)
- || (DECL_INITIAL (decl)
- && DECL_INITIAL (decl) != error_mark_node)))
- {
- DECL_INITIAL (to) = targetm.emutls.var_init
- (to, decl, get_emutls_init_templ_addr (decl));
-
- /* 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);
- }
+ /* This function is supposed to handle VARIABLES. Ensure we have one. */
+ gcc_assert (TREE_CODE (decl) == VAR_DECL);
- decl = to;
- }
+ /* Emulated TLS had better not get this far. */
+ gcc_checking_assert (targetm.have_tls || !DECL_THREAD_LOCAL_P (decl));
last_assemble_variable_decl = 0;
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;
-
/* Do nothing for global register variables. */
if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
{
if (flag_syntax_only)
return;
- app_disable ();
-
if (! dont_output_data
&& ! host_integerp (DECL_SIZE_UNIT (decl), 1))
{
gcc_assert (MEM_P (decl_rtl));
gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
symbol = XEXP (decl_rtl, 0);
+
+ /* If this symbol belongs to the tree constant pool, output the constant
+ if it hasn't already been written. */
+ if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
+ {
+ tree decl = SYMBOL_REF_DECL (symbol);
+ if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl)))
+ output_constant_def_contents (symbol);
+ return;
+ }
+
+ app_disable ();
+
name = XSTR (symbol, 0);
if (TREE_PUBLIC (decl) && DECL_NAME (decl))
notice_global_symbol (decl);
{
tree fields;
/* For a type that has fields, see if the fields have pointers. */
- for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
+ for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields))
if (TREE_CODE (fields) == FIELD_DECL
&& contains_pointers_p (TREE_TYPE (fields)))
return 1;
const char *name;
if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
+ && (DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA
+ || DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA_WITH_ALIGN))
return true;
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
/* We want to output annotation for weak and external symbols at
very last to check if they are references or not. */
- if (SUPPORTS_WEAK && DECL_WEAK (decl)
+ if (TARGET_SUPPORTS_WEAK
+ && 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);
/* Assemble a label named NAME. */
void
-assemble_label (const char *name)
+assemble_label (FILE *file, const char *name)
{
- ASM_OUTPUT_LABEL (asm_out_file, name);
+ ASM_OUTPUT_LABEL (file, name);
}
/* Set the symbol_referenced flag for ID. */
If we know a method will be emitted in other TU and no new
functions can be marked reachable, just use the external
definition. */
- struct cgraph_node *node = cgraph_node (decl);
+ struct cgraph_node *node = cgraph_get_create_node (decl);
if (!DECL_EXTERNAL (decl)
- && (!node->local.vtable_method || !cgraph_global_info_ready
- || !node->local.finalized))
+ && !node->local.finalized)
cgraph_mark_needed_node (node);
}
else if (TREE_CODE (decl) == VAR_DECL)
initial_trampoline = gen_const_mem (BLKmode, symbol);
set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
- set_mem_size (initial_trampoline, GEN_INT (TRAMPOLINE_SIZE));
+ set_mem_size (initial_trampoline, TRAMPOLINE_SIZE);
return initial_trampoline;
}
Store them both in the structure *VALUE.
EXP must be reducible. */
-struct GTY(()) addr_const {
+struct addr_const {
rtx base;
HOST_WIDE_INT offset;
};
{
if (TREE_CODE (target) == COMPONENT_REF
&& host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
-
{
offset += int_byte_position (TREE_OPERAND (target, 1));
target = TREE_OPERAND (target, 0);
* tree_low_cst (TREE_OPERAND (target, 1), 0));
target = TREE_OPERAND (target, 0);
}
+ else if (TREE_CODE (target) == MEM_REF
+ && TREE_CODE (TREE_OPERAND (target, 0)) == ADDR_EXPR)
+ {
+ offset += mem_ref_offset (target).low;
+ target = TREE_OPERAND (TREE_OPERAND (target, 0), 0);
+ }
+ else if (TREE_CODE (target) == INDIRECT_REF
+ && TREE_CODE (TREE_OPERAND (target, 0)) == NOP_EXPR
+ && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target, 0), 0))
+ == ADDR_EXPR)
+ target = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target, 0), 0), 0);
else
break;
}
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
+htab_t
constant_pool_htab (void)
{
return const_desc_htab;
return (const_hash_1 (TREE_REALPART (exp)) * 5
+ const_hash_1 (TREE_IMAGPART (exp)));
+ case VECTOR_CST:
+ {
+ tree link;
+
+ hi = 7 + TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp));
+
+ for (link = TREE_VECTOR_CST_ELTS (exp); link; link = TREE_CHAIN (link))
+ hi = hi * 563 + const_hash_1 (TREE_VALUE (link));
+
+ return hi;
+ }
+
case CONSTRUCTOR:
{
unsigned HOST_WIDE_INT idx;
return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
&& compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
+ case VECTOR_CST:
+ {
+ tree link1, link2;
+
+ if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (t1))
+ != TYPE_VECTOR_SUBPARTS (TREE_TYPE (t2)))
+ return 0;
+
+ link2 = TREE_VECTOR_CST_ELTS (t2);
+ for (link1 = TREE_VECTOR_CST_ELTS (t1);
+ link1;
+ link1 = TREE_CHAIN (link1))
+ {
+ if (!compare_constant (TREE_VALUE (link1), TREE_VALUE (link2)))
+ return 0;
+ link2 = TREE_CHAIN (link2);
+ }
+
+ return 1;
+ }
+
case CONSTRUCTOR:
{
VEC(constructor_elt, gc) *v1, *v2;
case FDESC_EXPR:
{
struct addr_const value1, value2;
+ enum rtx_code code;
+ int ret;
decode_addr_const (t1, &value1);
decode_addr_const (t2, &value2);
- return (value1.offset == value2.offset
- && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
+
+ if (value1.offset != value2.offset)
+ return 0;
+
+ code = GET_CODE (value1.base);
+ if (code != GET_CODE (value2.base))
+ return 0;
+
+ switch (code)
+ {
+ case SYMBOL_REF:
+ ret = (strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
+ break;
+
+ case LABEL_REF:
+ ret = (CODE_LABEL_NUMBER (XEXP (value1.base, 0))
+ == CODE_LABEL_NUMBER (XEXP (value2.base, 0)));
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ return ret;
}
case PLUS_EXPR:
return build1 (TREE_CODE (exp), TREE_TYPE (exp),
copy_constant (TREE_OPERAND (exp, 0)));
+ case VECTOR_CST:
+ return build_vector (TREE_TYPE (exp),
+ copy_list (TREE_VECTOR_CST_ELTS (exp)));
+
case CONSTRUCTOR:
{
tree copy = copy_node (exp);
}
}
\f
-/* Return the alignment of constant EXP in bits. */
-
-static unsigned int
-get_constant_alignment (tree exp)
-{
- unsigned int align;
-
- align = TYPE_ALIGN (TREE_TYPE (exp));
-#ifdef CONSTANT_ALIGNMENT
- align = CONSTANT_ALIGNMENT (exp, align);
-#endif
- return align;
-}
-
/* Return the section into which constant EXP should be placed. */
static section *
-get_constant_section (tree exp)
+get_constant_section (tree exp, unsigned int align)
{
- if (IN_NAMED_SECTION (exp))
- return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
- else
- return targetm.asm_out.select_section (exp,
- compute_reloc_for_constant (exp),
- get_constant_alignment (exp));
+ return targetm.asm_out.select_section (exp,
+ compute_reloc_for_constant (exp),
+ align);
}
/* Return the size of constant EXP in bytes. */
static struct constant_descriptor_tree *
build_constant_desc (tree exp)
{
- rtx symbol;
- rtx rtl;
+ struct constant_descriptor_tree *desc;
+ rtx symbol, rtl;
char label[256];
int labelno;
- struct constant_descriptor_tree *desc;
+ tree decl;
- desc = GGC_NEW (struct constant_descriptor_tree);
+ desc = ggc_alloc_constant_descriptor_tree ();
desc->value = copy_constant (exp);
/* Propagate marked-ness to copied constant. */
labelno = const_labelno++;
ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
- /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
+ /* Construct the VAR_DECL associated with the constant. */
+ decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (label),
+ TREE_TYPE (exp));
+ DECL_ARTIFICIAL (decl) = 1;
+ DECL_IGNORED_P (decl) = 1;
+ TREE_READONLY (decl) = 1;
+ TREE_STATIC (decl) = 1;
+ TREE_ADDRESSABLE (decl) = 1;
+ /* We don't set the RTL yet as this would cause varpool to assume that the
+ variable is referenced. Moreover, it would just be dropped in LTO mode.
+ Instead we set the flag that will be recognized in make_decl_rtl. */
+ DECL_IN_CONSTANT_POOL (decl) = 1;
+ DECL_INITIAL (decl) = desc->value;
+ /* ??? CONSTANT_ALIGNMENT hasn't been updated for vector types on most
+ architectures so use DATA_ALIGNMENT as well, except for strings. */
+ if (TREE_CODE (exp) == STRING_CST)
+ {
+#ifdef CONSTANT_ALIGNMENT
+ DECL_ALIGN (decl) = CONSTANT_ALIGNMENT (exp, DECL_ALIGN (decl));
+#endif
+ }
+ else
+ align_variable (decl, 0);
+
+ /* Now construct the SYMBOL_REF and the MEM. */
if (use_object_blocks_p ())
{
- section *sect = get_constant_section (exp);
+ section *sect = get_constant_section (exp, DECL_ALIGN (decl));
symbol = create_block_symbol (ggc_strdup (label),
get_block_for_section (sect), -1);
}
else
symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
- SET_SYMBOL_REF_DECL (symbol, desc->value);
+ SET_SYMBOL_REF_DECL (symbol, decl);
TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
- rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
+ rtl = gen_const_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);
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. */
-
targetm.encode_section_info (exp, rtl, true);
desc->rtl = rtl;
size = get_constant_size (exp);
/* Do any machine/system dependent processing of the constant. */
-#ifdef ASM_DECLARE_CONSTANT_NAME
- ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
-#else
- /* Standard thing is just output label for the constant. */
- ASM_OUTPUT_LABEL (asm_out_file, label);
-#endif /* ASM_DECLARE_CONSTANT_NAME */
+ targetm.asm_out.declare_constant_name (asm_out_file, label, exp, size);
/* Output the value of EXP. */
output_constant (exp, size, align);
static void
output_constant_def_contents (rtx symbol)
{
- tree exp = SYMBOL_REF_DECL (symbol);
+ tree decl = SYMBOL_REF_DECL (symbol);
+ tree exp = DECL_INITIAL (decl);
unsigned int align;
/* Make sure any other constants whose addresses appear in EXP
output_addressed_constants (exp);
/* We are no longer deferring this constant. */
- TREE_ASM_WRITTEN (exp) = 1;
+ TREE_ASM_WRITTEN (decl) = TREE_ASM_WRITTEN (exp) = 1;
/* 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
place_block_symbol (symbol);
else
{
- switch_to_section (get_constant_section (exp));
- align = get_constant_alignment (exp);
+ align = DECL_ALIGN (decl);
+ switch_to_section (get_constant_section (exp, align));
if (align > BITS_PER_UNIT)
ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
assemble_constant_contents (exp, XSTR (symbol, 0), align);
key.value = exp;
key.hash = const_hash_1 (exp);
- desc = (struct constant_descriptor_tree *)
- htab_find_with_hash (const_desc_htab, &key, key.hash);
+ desc = (struct constant_descriptor_tree *)
+ htab_find_with_hash (const_desc_htab, &key, key.hash);
+
+ return (desc ? desc->rtl : NULL_RTX);
+}
+
+/* Return a tree representing a reference to constant data in memory
+ for the constant expression EXP.
+
+ This is the counterpart of output_constant_def at the Tree level. */
+
+tree
+tree_output_constant_def (tree exp)
+{
+ struct constant_descriptor_tree *desc, key;
+ void **loc;
+ tree decl;
+
+ /* Look up EXP in the table of constant descriptors. If we didn't find
+ it, create a new one. */
+ key.value = exp;
+ key.hash = const_hash_1 (exp);
+ loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
- return (desc ? desc->rtl : NULL_RTX);
+ desc = (struct constant_descriptor_tree *) *loc;
+ if (desc == 0)
+ {
+ desc = build_constant_desc (exp);
+ desc->hash = key.hash;
+ *loc = desc;
+ }
+
+ decl = SYMBOL_REF_DECL (XEXP (desc->rtl, 0));
+ varpool_finalize_decl (decl);
+ return decl;
}
\f
/* Used in the hash tables to avoid outputting the same constant
{
struct rtx_constant_pool *pool;
- pool = GGC_NEW (struct rtx_constant_pool);
+ pool = ggc_alloc_rtx_constant_pool ();
pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
const_desc_rtx_eq, NULL);
pool->first = NULL;
void **slot;
/* If we're not allowed to drop X into the constant pool, don't. */
- if (targetm.cannot_force_const_mem (x))
+ if (targetm.cannot_force_const_mem (mode, x))
return NULL_RTX;
/* Record that this function has used a constant pool entry. */
return copy_rtx (desc->mem);
/* Otherwise, create a new descriptor. */
- desc = GGC_NEW (struct constant_descriptor_rtx);
+ desc = ggc_alloc_constant_descriptor_rtx ();
*slot = desc;
/* Align the location counter as required by EXP's data type. */
pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
desc->next = NULL;
- desc->constant = tmp.constant;
+ desc->constant = copy_rtx (tmp.constant);
desc->offset = pool->offset;
desc->hash = hash;
desc->mode = mode;
}
else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
{
- tree exp = SYMBOL_REF_DECL (x);
- if (!TREE_ASM_WRITTEN (exp))
+ tree decl = SYMBOL_REF_DECL (x);
+ if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl)))
{
n_deferred_constants--;
output_constant_def_contents (x);
{
return (TREE_CONSTANT (ctor)
&& (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE
- || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE)
- && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (ctor)));
+ || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE));
}
+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
returns NULL. */
static tree
-narrowing_initializer_constant_valid_p (tree value, tree endtype)
+narrowing_initializer_constant_valid_p (tree value, tree endtype, tree *cache)
{
tree op0, op1;
op1 = inner;
}
- op0 = initializer_constant_valid_p (op0, endtype);
- op1 = initializer_constant_valid_p (op1, endtype);
+ op0 = initializer_constant_valid_p_1 (op0, endtype, cache);
+ if (!op0)
+ return NULL_TREE;
+ op1 = initializer_constant_valid_p_1 (op1, endtype,
+ cache ? cache + 2 : NULL);
/* Both initializers must be known. */
- if (op0 && op1)
+ if (op1)
{
if (op0 == op1
&& (op0 == null_pointer_node
return NULL_TREE;
}
-/* Return nonzero if VALUE is a valid constant-valued expression
+/* Helper function of initializer_constant_valid_p.
+ 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.
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.
-tree
-initializer_constant_valid_p (tree value, tree endtype)
+ Use CACHE (pointer to 2 tree values) for caching if non-NULL. */
+
+static tree
+initializer_constant_valid_p_1 (tree value, tree endtype, tree *cache)
{
tree ret;
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 (elt, TREE_TYPE (elt));
+ reloc = initializer_constant_valid_p_1 (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;
}
}
case NON_LVALUE_EXPR:
- return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+ return initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
+ endtype, cache);
case VIEW_CONVERT_EXPR:
{
if (AGGREGATE_TYPE_P (src_type) && !AGGREGATE_TYPE_P (dest_type))
{
if (TYPE_MODE (endtype) == TYPE_MODE (dest_type))
- return initializer_constant_valid_p (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
else
return NULL_TREE;
}
/* Allow all other kinds of view-conversion. */
- return initializer_constant_valid_p (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
}
CASE_CONVERT:
|| (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 (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
/* 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 (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
/* 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 (src, endtype);
+ tree inner = initializer_constant_valid_p_1 (src, endtype, cache);
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 (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
/* Likewise conversions from int to pointers, but also allow
conversions from 0. */
if (integer_zerop (src))
return null_pointer_node;
else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
- return initializer_constant_valid_p (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
}
/* 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 (src, endtype);
+ return initializer_constant_valid_p_1 (src, endtype, cache);
}
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 valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
- endtype);
- tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
- endtype);
+ tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE };
+ tree valid0
+ = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
+ endtype, ncache);
+ 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)
- return valid1;
- if (valid1 == null_pointer_node)
- return valid0;
+ ret = valid1;
+ else if (valid1 == null_pointer_node)
+ ret = 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);
- if (ret != NULL_TREE)
- return ret;
-
- break;
+ ret = narrowing_initializer_constant_valid_p (value, endtype, NULL);
+ if (cache)
+ {
+ cache[0] = value;
+ cache[1] = ret;
+ }
+ 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 valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
- endtype);
- tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
- endtype);
+ tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE };
+ tree valid0
+ = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
+ endtype, ncache);
+ 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)
- return valid0;
+ ret = valid0;
/* Win if both arguments have the same relocation.
Then the value is absolute. */
- if (valid0 == valid1 && valid0 != 0)
- return null_pointer_node;
-
+ else if (valid0 == valid1 && valid0 != 0)
+ ret = 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. */
- if (valid0 && TREE_CODE (valid0) == STRING_CST
- && valid1 && TREE_CODE (valid1) == STRING_CST
- && operand_equal_p (valid0, valid1, 1))
- return null_pointer_node;
+ else if (valid0 && TREE_CODE (valid0) == STRING_CST
+ && valid1 && TREE_CODE (valid1) == STRING_CST
+ && operand_equal_p (valid0, valid1, 1))
+ ret = null_pointer_node;
+ /* Support narrowing differences. */
+ else
+ ret = narrowing_initializer_constant_valid_p (value, endtype,
+ ncache);
}
-
- /* Support narrowing differences. */
- ret = narrowing_initializer_constant_valid_p (value, endtype);
- if (ret != NULL_TREE)
- return ret;
-
- break;
+ else
+ /* Support narrowing differences. */
+ ret = narrowing_initializer_constant_valid_p (value, endtype, NULL);
+ if (cache)
+ {
+ cache[0] = value;
+ cache[1] = ret;
+ }
+ return ret;
default:
break;
}
- return 0;
+ return NULL_TREE;
+}
+
+/* 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);
}
\f
/* Return true if VALUE is a valid constant-valued expression
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);
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
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
case REAL_TYPE:
if (TREE_CODE (exp) != REAL_CST)
error ("initializer for floating value is not a floating constant");
-
- assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
+ else
+ assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
break;
case COMPLEX_TYPE:
static unsigned HOST_WIDE_INT
array_size_for_constructor (tree val)
{
- tree max_index, i;
+ tree max_index;
unsigned HOST_WIDE_INT cnt;
tree index, value, tmp;
+ double_int i;
/* This code used to attempt to handle string constants that are not
arrays of single-bytes, but nothing else does, so there's no point in
/* Compute the total number of array elements. */
tmp = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)));
- i = size_binop (MINUS_EXPR, fold_convert (sizetype, max_index),
- fold_convert (sizetype, tmp));
- i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
+ i = double_int_sub (tree_to_double_int (max_index), tree_to_double_int (tmp));
+ i = double_int_add (i, double_int_one);
/* Multiply by the array element unit size to find number of bytes. */
- i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
+ i = double_int_mul (i, tree_to_double_int
+ (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val)))));
- return tree_low_cst (i, 1);
+ gcc_assert (double_int_fits_in_uhwi_p (i));
+ return i.low;
}
/* Other datastructures + helpers for output_constructor. */
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. */
assemble_zeros (fieldsize);
else
output_constant (local->val, fieldsize, align2);
-
+
/* Count its size. */
local->total_bytes += fieldsize;
}
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)
+ {
+ double_int idx = double_int_sub (tree_to_double_int (local->index),
+ tree_to_double_int (local->min_index));
+ gcc_assert (double_int_fits_in_shwi_p (idx));
+ fieldpos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (local->val)), 1)
+ * idx.low);
+ }
+ else if (local->field != NULL_TREE)
fieldpos = int_byte_position (local->field);
else
- fieldpos = 0;
+ fieldpos = 0;
/* Output any buffered-up bit-fields preceding this element. */
if (local->byte_buffer_in_use)
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. */
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);
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,
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);
+ gcc_assert (!fieldsize || !DECL_CHAIN (local->field));
}
+ else
+ 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);
HOST_WIDE_INT relative_index
= (!local->field
? (local->index
- ? (tree_low_cst (local->index, 0)
+ ? (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)
+ ? 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
+ /* 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)
{
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)
{
local->total_bytes = next_offset / BITS_PER_UNIT;
}
}
-
+
/* Set up the buffer if necessary. */
if (!local->byte_buffer_in_use)
{
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)
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. */
+ bit-fields. */
while (next_offset < end_offset)
{
int this_time;
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)
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,
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
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);
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)
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
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);
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;
}
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);
/* As CE goes through the elements of the constant, FIELD goes through the
for (cnt = 0;
VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
- cnt++, local.field = local.field ? TREE_CHAIN (local.field) : 0)
+ cnt++, local.field = local.field ? DECL_CHAIN (local.field) : 0)
{
local.val = ce->value;
local.index = NULL_TREE;
else if (TREE_CODE (local.type) == ARRAY_TYPE)
local.index = ce->index;
-#ifdef ASM_COMMENT_START
if (local.field && flag_verbose_asm)
fprintf (asm_out_file, "%s %s:\n",
ASM_COMMENT_START,
DECL_NAME (local.field)
? IDENTIFIER_POINTER (DECL_NAME (local.field))
: "<anonymous>");
-#endif
/* Eliminate the marker that makes a cast not be an lvalue. */
if (local.val != NULL_TREE)
&& (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);
local.total_bytes = local.size;
}
}
-
+
return local.total_bytes;
}
{
if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
{
- if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
+ if (DECL_WEAK (newdecl) && TARGET_SUPPORTS_WEAK)
{
tree *pwd;
/* We put the NEWDECL on the weak_decls list at some point
/* NEWDECL is weak, but OLDDECL is not. */
/* If we already output the OLDDECL, we're in trouble; we can't
- go back and make it weak. This error cannot be caught in
- declare_weak because the NEWDECL and OLDDECL was not yet
- been merged; therefore, TREE_ASM_WRITTEN was not set. */
- if (TREE_ASM_WRITTEN (olddecl))
- error ("weak declaration of %q+D must precede definition",
- newdecl);
+ go back and make it weak. This should never happen in
+ unit-at-a-time compilation. */
+ gcc_assert (!TREE_ASM_WRITTEN (olddecl));
/* If we've already generated rtl referencing OLDDECL, we may
have done so in a way that will not function properly with
- a weak symbol. */
- else if (TREE_USED (olddecl)
- && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
- warning (0, "weak declaration of %q+D after first use results "
- "in unspecified behavior", newdecl);
+ a weak symbol. Again in unit-at-a-time this should be
+ impossible. */
+ gcc_assert (!TREE_USED (olddecl)
+ || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)));
- if (SUPPORTS_WEAK)
+ if (TARGET_SUPPORTS_WEAK)
{
/* We put the NEWDECL on the weak_decls list at some point.
Replace it with the OLDDECL. */
void
declare_weak (tree decl)
{
+ gcc_assert (TREE_CODE (decl) != FUNCTION_DECL || !TREE_ASM_WRITTEN (decl));
if (! TREE_PUBLIC (decl))
error ("weak declaration of %q+D must be public", decl);
- else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
- error ("weak declaration of %q+D must precede definition", decl);
- else if (!SUPPORTS_WEAK)
+ else if (!TARGET_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
else if (vnode)
{
varpool_mark_needed_node (vnode);
+ vnode->force_output = 1;
return vnode->decl;
}
else
static void
do_assemble_alias (tree decl, tree target)
{
+ /* Emulated TLS had better not get this var. */
+ gcc_assert(!(!targetm.have_tls
+ && TREE_CODE (decl) == VAR_DECL
+ && DECL_THREAD_LOCAL_P (decl)));
+
if (TREE_ASM_WRITTEN (decl))
return;
+ /* We must force creation of DECL_RTL for debug info generation, even though
+ we don't use it here. */
+ make_decl_rtl (decl);
+
TREE_ASM_WRITTEN (decl) = 1;
TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
{
ultimate_transparent_alias_target (&target);
- if (!targetm.have_tls
- && TREE_CODE (decl) == VAR_DECL
- && DECL_THREAD_LOCAL_P (decl))
- {
- decl = emutls_decl (decl);
- target = get_emutls_object_name (target);
- }
-
if (!TREE_SYMBOL_REFERENCED (target))
weakref_targets = tree_cons (decl, target, weakref_targets);
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
IDENTIFIER_POINTER (target));
#else
- if (!SUPPORTS_WEAK)
+ if (!TARGET_SUPPORTS_WEAK)
{
error_at (DECL_SOURCE_LOCATION (decl),
"weakref is not supported in this configuration");
return;
}
- if (!targetm.have_tls
- && TREE_CODE (decl) == VAR_DECL
- && DECL_THREAD_LOCAL_P (decl))
- {
- decl = emutls_decl (decl);
- target = get_emutls_object_name (target);
- }
-
#ifdef ASM_OUTPUT_DEF
/* Make name accessible from other files, if appropriate. */
globalize_decl (decl);
maybe_assemble_visibility (decl);
}
+ if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)))
+ {
+#if defined (ASM_OUTPUT_TYPE_DIRECTIVE) && HAVE_GNU_INDIRECT_FUNCTION
+ ASM_OUTPUT_TYPE_DIRECTIVE
+ (asm_out_file, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
+ IFUNC_ASM_TYPE);
+#else
+ error_at (DECL_SOURCE_LOCATION (decl),
+ "ifunc is not supported in this configuration");
+#endif
+ }
# ifdef ASM_OUTPUT_DEF_FROM_DECLS
ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
}
+/* Allocate and construct a symbol alias set. */
+
+static symbol_alias_set_t *
+symbol_alias_set_create (void)
+{
+ return pointer_set_create ();
+}
+
+/* Destruct and free a symbol alias set. */
+
+void
+symbol_alias_set_destroy (symbol_alias_set_t *aset)
+{
+ pointer_set_destroy (aset);
+}
+
+/* Test if a symbol alias set contains a given name. */
+
+int
+symbol_alias_set_contains (const symbol_alias_set_t *aset, tree t)
+{
+ /* We accept either a DECL or an IDENTIFIER directly. */
+ if (TREE_CODE (t) != IDENTIFIER_NODE)
+ t = DECL_ASSEMBLER_NAME (t);
+ t = targetm.asm_out.mangle_assembler_name (IDENTIFIER_POINTER (t));
+ return pointer_set_contains (aset, t);
+}
+
+/* Enter a new name into a symbol alias set. */
+
+static int
+symbol_alias_set_insert (symbol_alias_set_t *aset, tree t)
+{
+ /* We accept either a DECL or an IDENTIFIER directly. */
+ if (TREE_CODE (t) != IDENTIFIER_NODE)
+ t = DECL_ASSEMBLER_NAME (t);
+ t = targetm.asm_out.mangle_assembler_name (IDENTIFIER_POINTER (t));
+ return pointer_set_insert (aset, t);
+}
+
+/* IN_SET_P is a predicate function assuming to be taken
+ alias_pair->decl, alias_pair->target and DATA arguments.
+
+ Compute set of aliases by including everything where TRIVIALLY_VISIBLE
+ predeicate is true and propagate across aliases such that when
+ alias DECL is included, its TARGET is included too. */
+
+static symbol_alias_set_t *
+propagate_aliases_forward (bool (*in_set_p)
+ (tree decl, tree target, void *data),
+ void *data)
+{
+ symbol_alias_set_t *set;
+ unsigned i;
+ alias_pair *p;
+ bool changed;
+
+ set = symbol_alias_set_create ();
+ for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); ++i)
+ if (in_set_p (p->decl, p->target, data))
+ symbol_alias_set_insert (set, p->decl);
+ do
+ {
+ changed = false;
+ for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); ++i)
+ if (symbol_alias_set_contains (set, p->decl)
+ && !symbol_alias_set_insert (set, p->target))
+ changed = true;
+ }
+ while (changed);
+
+ return set;
+}
+
+/* Like propagate_aliases_forward but do backward propagation. */
+
+symbol_alias_set_t *
+propagate_aliases_backward (bool (*in_set_p)
+ (tree decl, tree target, void *data),
+ void *data)
+{
+ symbol_alias_set_t *set;
+ unsigned i;
+ alias_pair *p;
+ bool changed;
+
+ /* We have to compute the set of set nodes including aliases
+ themselves. */
+ set = symbol_alias_set_create ();
+ for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); ++i)
+ if (in_set_p (p->decl, p->target, data))
+ symbol_alias_set_insert (set, p->target);
+ do
+ {
+ changed = false;
+ for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); ++i)
+ if (symbol_alias_set_contains (set, p->target)
+ && !symbol_alias_set_insert (set, p->decl))
+ changed = true;
+ }
+ while (changed);
+
+ return set;
+}
+/* See if the alias is trivially visible. This means
+ 1) alias is expoerted from the unit or
+ 2) alias is used in the code.
+ We assume that unused cgraph/varpool nodes has been
+ removed.
+ Used as callback for propagate_aliases. */
+
+static bool
+trivially_visible_alias (tree decl, tree target ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
+{
+ struct cgraph_node *fnode = NULL;
+ struct varpool_node *vnode = NULL;
+
+ if (!TREE_PUBLIC (decl))
+ {
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ fnode = cgraph_get_node (decl);
+ else
+ vnode = varpool_get_node (decl);
+ return vnode || fnode;
+ }
+ else
+ return true;
+}
+
+/* See if the target of alias is defined in this unit.
+ Used as callback for propagate_aliases. */
+
+static bool
+trivially_defined_alias (tree decl ATTRIBUTE_UNUSED,
+ tree target,
+ void *data ATTRIBUTE_UNUSED)
+{
+ struct cgraph_node *fnode = NULL;
+ struct varpool_node *vnode = NULL;
+
+ fnode = cgraph_node_for_asm (target);
+ vnode = (fnode == NULL) ? varpool_node_for_asm (target) : NULL;
+ return (fnode && fnode->analyzed) || (vnode && vnode->finalized);
+}
+
/* Remove the alias pairing for functions that are no longer in the call
graph. */
void
remove_unreachable_alias_pairs (void)
{
+ symbol_alias_set_t *visible;
unsigned i;
alias_pair *p;
if (alias_pairs == NULL)
return;
+ /* We have to compute the set of visible nodes including aliases
+ themselves. */
+ visible = propagate_aliases_forward (trivially_visible_alias, NULL);
+
for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); )
{
- if (!DECL_EXTERNAL (p->decl))
+ if (!DECL_EXTERNAL (p->decl)
+ && !symbol_alias_set_contains (visible, 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;
- }
+ VEC_unordered_remove (alias_pair, alias_pairs, i);
+ continue;
}
i++;
}
+
+ symbol_alias_set_destroy (visible);
}
void
finish_aliases_1 (void)
{
+ symbol_alias_set_t *defined;
unsigned i;
alias_pair *p;
- for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
+ if (alias_pairs == NULL)
+ return;
+
+ /* We have to compute the set of defined nodes including aliases
+ themselves. */
+ defined = propagate_aliases_backward (trivially_defined_alias, NULL);
+
+ FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
{
tree target_decl;
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 %qE",
- p->decl, p->target);
+ if (symbol_alias_set_contains (defined, p->target))
+ continue;
+
+ if (! (p->emitted_diags & ALIAS_DIAG_TO_UNDEF)
+ && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
+ {
+ error ("%q+D aliased to undefined symbol %qE",
+ p->decl, p->target);
+ p->emitted_diags |= ALIAS_DIAG_TO_UNDEF;
+ }
}
- 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))
+ else if (! (p->emitted_diags & ALIAS_DIAG_TO_EXTERN)
+ && DECL_EXTERNAL (target_decl)
+ /* We use local aliases for C++ thunks to force the tailcall
+ to bind locally. 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 %qE",
- p->decl, p->target);
+ {
+ error ("%q+D aliased to external symbol %qE",
+ p->decl, p->target);
+ p->emitted_diags |= ALIAS_DIAG_TO_EXTERN;
+ }
}
+
+ symbol_alias_set_destroy (defined);
}
/* Second pass of completing pending aliases. Emit the actual assembly.
unsigned i;
alias_pair *p;
- for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
+ FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
do_assemble_alias (p->decl, p->target);
VEC_truncate (alias_pair, alias_pairs, 0);
# else
if (!DECL_WEAK (decl))
{
- error_at (DECL_SOURCE_LOCATION (decl),
- "only weak aliases are supported in this configuration");
+ if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)))
+ error_at (DECL_SOURCE_LOCATION (decl),
+ "ifunc is not supported in this configuration");
+ else
+ error_at (DECL_SOURCE_LOCATION (decl),
+ "only weak aliases are supported in this configuration");
return;
}
# endif
#endif
}
+ TREE_USED (decl) = 1;
+
+ /* A quirk of the initial implementation of aliases required that the user
+ add "extern" to all of them. Which is silly, but now historical. Do
+ note that the symbol is in fact locally defined. */
+ if (! is_weakref)
+ DECL_EXTERNAL (decl) = 0;
+
+ /* Allow aliases to aliases. */
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ cgraph_get_create_node (decl)->alias = true;
+ else
+ varpool_node (decl)->alias = true;
+
+ /* If the target has already been emitted, we don't have to queue the
+ alias. This saves a tad of memory. */
+ if (cgraph_global_info_ready)
+ target_decl = find_decl_and_mark_needed (decl, target);
+ else
+ target_decl= NULL;
+ if (target_decl && TREE_ASM_WRITTEN (target_decl))
+ do_assemble_alias (decl, target);
+ else
+ {
+ alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
+ p->decl = decl;
+ p->target = target;
+ p->emitted_diags = ALIAS_DIAG_NONE;
+ }
+}
+
+/* Record and output a table of translations from original function
+ to its transaction aware clone. Note that tm_pure functions are
+ considered to be their own clone. */
+
+static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
+ htab_t tm_clone_hash;
+
+void
+record_tm_clone_pair (tree o, tree n)
+{
+ struct tree_map **slot, *h;
+
+ if (tm_clone_hash == NULL)
+ tm_clone_hash = htab_create_ggc (32, tree_map_hash, tree_map_eq, 0);
+
+ h = ggc_alloc_tree_map ();
+ h->hash = htab_hash_pointer (o);
+ h->base.from = o;
+ h->to = n;
+
+ slot = (struct tree_map **)
+ htab_find_slot_with_hash (tm_clone_hash, h, h->hash, INSERT);
+ *slot = h;
+}
+
+tree
+get_tm_clone_pair (tree o)
+{
+ if (tm_clone_hash)
+ {
+ struct tree_map *h, in;
+
+ in.base.from = o;
+ in.hash = htab_hash_pointer (o);
+ h = (struct tree_map *) htab_find_with_hash (tm_clone_hash,
+ &in, in.hash);
+ if (h)
+ return h->to;
+ }
+ return NULL_TREE;
+}
+
+typedef struct tm_alias_pair
+{
+ unsigned int uid;
+ tree from;
+ tree to;
+} tm_alias_pair;
+
+DEF_VEC_O(tm_alias_pair);
+DEF_VEC_ALLOC_O(tm_alias_pair,heap);
+
+/* Helper function for finish_tm_clone_pairs. Dump a hash table entry
+ into a VEC in INFO. */
+
+static int
+dump_tm_clone_to_vec (void **slot, void *info)
+{
+ struct tree_map *map = (struct tree_map *) *slot;
+ VEC(tm_alias_pair,heap) **tm_alias_pairs
+ = (VEC(tm_alias_pair, heap) **) info;
+ tm_alias_pair *p;
+
+ p = VEC_safe_push (tm_alias_pair, heap, *tm_alias_pairs, NULL);
+ p->from = map->base.from;
+ p->to = map->to;
+ p->uid = DECL_UID (p->from);
+ return 1;
+}
+
+/* Dump the actual pairs to the .tm_clone_table section. */
+
+static void
+dump_tm_clone_pairs (VEC(tm_alias_pair,heap) *tm_alias_pairs)
+{
+ unsigned i;
+ tm_alias_pair *p;
+ bool switched = false;
+
+ FOR_EACH_VEC_ELT (tm_alias_pair, tm_alias_pairs, i, p)
+ {
+ tree src = p->from;
+ tree dst = p->to;
+ struct cgraph_node *src_n = cgraph_get_node (src);
+ struct cgraph_node *dst_n = cgraph_get_node (dst);
+
+ /* The function ipa_tm_create_version() marks the clone as needed if
+ the original function was needed. But we also mark the clone as
+ needed if we ever called the clone indirectly through
+ TM_GETTMCLONE. If neither of these are true, we didn't generate
+ a clone, and we didn't call it indirectly... no sense keeping it
+ in the clone table. */
+ if (!dst_n || !dst_n->needed)
+ continue;
+
+ /* This covers the case where we have optimized the original
+ function away, and only access the transactional clone. */
+ if (!src_n || !src_n->needed)
+ continue;
+
+ if (!switched)
+ {
+ switch_to_section (get_named_section (NULL, ".tm_clone_table", 3));
+ assemble_align (POINTER_SIZE);
+ switched = true;
+ }
+
+ assemble_integer (XEXP (DECL_RTL (src), 0),
+ POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
+ assemble_integer (XEXP (DECL_RTL (dst), 0),
+ POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
+ }
+}
- /* We must force creation of DECL_RTL for debug info generation, even though
- we don't use it here. */
- make_decl_rtl (decl);
- TREE_USED (decl) = 1;
+/* Helper comparison function for qsorting by the DECL_UID stored in
+ alias_pair->emitted_diags. */
- /* A quirk of the initial implementation of aliases required that the user
- add "extern" to all of them. Which is silly, but now historical. Do
- note that the symbol is in fact locally defined. */
- if (! is_weakref)
- DECL_EXTERNAL (decl) = 0;
+static int
+tm_alias_pair_cmp (const void *x, const void *y)
+{
+ const tm_alias_pair *p1 = (const tm_alias_pair *) x;
+ const tm_alias_pair *p2 = (const tm_alias_pair *) y;
+ if (p1->uid < p2->uid)
+ return -1;
+ if (p1->uid > p2->uid)
+ return 1;
+ return 0;
+}
- /* Allow aliases to aliases. */
- if (TREE_CODE (decl) == FUNCTION_DECL)
- cgraph_node (decl)->alias = true;
- else
- varpool_node (decl)->alias = true;
+void
+finish_tm_clone_pairs (void)
+{
+ VEC(tm_alias_pair,heap) *tm_alias_pairs = NULL;
- /* If the target has already been emitted, we don't have to queue the
- alias. This saves a tad of memory. */
- if (cgraph_global_info_ready)
- target_decl = find_decl_and_mark_needed (decl, target);
- else
- target_decl= NULL;
- if (target_decl && TREE_ASM_WRITTEN (target_decl))
- do_assemble_alias (decl, target);
- else
- {
- alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
- p->decl = decl;
- p->target = target;
- }
+ if (tm_clone_hash == NULL)
+ return;
+
+ /* We need a determenistic order for the .tm_clone_table, otherwise
+ we will get bootstrap comparison failures, so dump the hash table
+ to a vector, sort it, and dump the vector. */
+
+ /* Dump the hashtable to a vector. */
+ htab_traverse_noresize (tm_clone_hash, dump_tm_clone_to_vec,
+ (void *) &tm_alias_pairs);
+ /* Sort it. */
+ VEC_qsort (tm_alias_pair, tm_alias_pairs, tm_alias_pair_cmp);
+
+ /* Dump it. */
+ dump_tm_clone_pairs (tm_alias_pairs);
+
+ htab_delete (tm_clone_hash);
+ tm_clone_hash = NULL;
+ VEC_free (tm_alias_pair, heap, tm_alias_pairs);
}
+
/* Emit an assembler directive to set symbol for DECL visibility to
the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
void
-default_assemble_visibility (tree decl, int vis)
+default_assemble_visibility (tree decl ATTRIBUTE_UNUSED,
+ int vis ATTRIBUTE_UNUSED)
{
+#ifdef HAVE_GAS_HIDDEN
static const char * const visibility_types[] = {
NULL, "protected", "hidden", "internal"
};
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
type = visibility_types[vis];
-#ifdef HAVE_GAS_HIDDEN
fprintf (asm_out_file, "\t.%s\t", type);
assemble_name (asm_out_file, name);
fprintf (asm_out_file, "\n");
if (vis != VISIBILITY_DEFAULT)
{
- targetm.asm_out.visibility (decl, vis);
+ targetm.asm_out.assemble_visibility (decl, vis);
return 1;
}
else
{
if (SUPPORTS_ONE_ONLY)
return 1;
- return SUPPORTS_WEAK;
+ return TARGET_SUPPORTS_WEAK;
}
/* Set up DECL as a public symbol that can be defined in multiple
DECL_COMMON (decl) = 1;
else
{
- gcc_assert (SUPPORTS_WEAK);
+ gcc_assert (TARGET_SUPPORTS_WEAK);
DECL_WEAK (decl) = 1;
}
}
comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
| SECTION_COMMON, emit_common);
-#if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
+#if defined ASM_OUTPUT_ALIGNED_BSS
bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS,
emit_bss);
#endif
if (decl && TREE_CODE (decl) == FUNCTION_DECL)
flags = SECTION_CODE;
- else if (decl && decl_readonly_section (decl, reloc))
- flags = 0;
- else if (current_function_decl
- && cfun
- && crtl->subsections.unlikely_text_section_name
- && strcmp (name, crtl->subsections.unlikely_text_section_name) == 0)
- flags = SECTION_CODE;
- else if (!decl
- && (!current_function_decl || !cfun)
- && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
- flags = SECTION_CODE;
+ else if (decl)
+ {
+ enum section_category category
+ = categorize_decl_for_section (decl, reloc);
+ if (decl_readonly_section_1 (category))
+ flags = 0;
+ else if (category == SECCAT_DATA_REL_RO
+ || category == SECCAT_DATA_REL_RO_LOCAL)
+ flags = SECTION_WRITE | SECTION_RELRO;
+ else
+ flags = SECTION_WRITE;
+ }
else
- flags = SECTION_WRITE;
+ {
+ flags = SECTION_WRITE;
+ if (strcmp (name, ".data.rel.ro") == 0
+ || strcmp (name, ".data.rel.ro.local") == 0)
+ flags |= SECTION_RELRO;
+ }
if (decl && DECL_ONE_ONLY (decl))
flags |= SECTION_LINKONCE;
gcc_unreachable ();
}
+#ifndef TLS_SECTION_ASM_FLAG
+#define TLS_SECTION_ASM_FLAG 'T'
+#endif
+
void
default_elf_asm_named_section (const char *name, unsigned int flags,
tree decl ATTRIBUTE_UNUSED)
if (!(flags & SECTION_DEBUG))
*f++ = 'a';
+ if (flags & SECTION_EXCLUDE)
+ *f++ = 'e';
if (flags & SECTION_WRITE)
*f++ = 'w';
if (flags & SECTION_CODE)
if (flags & SECTION_STRINGS)
*f++ = 'S';
if (flags & SECTION_TLS)
- *f++ = 'T';
+ *f++ = TLS_SECTION_ASM_FLAG;
if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
*f++ = 'G';
*f = '\0';
type = "progbits";
format = ",@%s";
-#ifdef ASM_COMMENT_START
/* On platforms that use "@" as the assembly comment character,
use "%" instead. */
if (strcmp (ASM_COMMENT_START, "@") == 0)
format = ",%%%s";
-#endif
fprintf (asm_out_file, format, type);
if (flags & SECTION_ENTSIZE)
ret = SECCAT_RODATA;
/* There are no read-only thread-local sections. */
- if (TREE_CODE (decl) == VAR_DECL && DECL_TLS_MODEL (decl))
+ if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
{
- if (DECL_TLS_MODEL (decl) == TLS_MODEL_EMULATED)
- {
- if (DECL_EMUTLS_VAR_P (decl))
- {
- if (targetm.emutls.var_section)
- ret = SECCAT_EMUTLS_VAR;
- }
- else
- {
- if (targetm.emutls.tmpl_prefix)
- ret = SECCAT_EMUTLS_TMPL;
- }
- }
/* Note that this would be *just* SECCAT_BSS, except that there's
no concept of a read-only thread-local-data section. */
- else if (ret == SECCAT_BSS
+ if (ret == SECCAT_BSS
|| (flag_zero_initialized_in_bss
&& initializer_zerop (DECL_INITIAL (decl))))
ret = SECCAT_TBSS;
return ret;
}
-bool
-decl_readonly_section (const_tree decl, int reloc)
+static bool
+decl_readonly_section_1 (enum section_category category)
{
- switch (categorize_decl_for_section (decl, reloc))
+ switch (category)
{
case SECCAT_RODATA:
case SECCAT_RODATA_MERGE_STR:
case SECCAT_RODATA_MERGE_CONST:
case SECCAT_SRODATA:
return true;
- break;
default:
return false;
- break;
}
}
+bool
+decl_readonly_section (const_tree decl, int reloc)
+{
+ return decl_readonly_section_1 (categorize_decl_for_section (decl, reloc));
+}
+
/* Select a section based on the above categorization. */
section *
case SECCAT_TBSS:
sname = ".tbss";
break;
- case SECCAT_EMUTLS_VAR:
- sname = targetm.emutls.var_section;
- break;
- case SECCAT_EMUTLS_TMPL:
- sname = targetm.emutls.tmpl_section;
- break;
default:
gcc_unreachable ();
}
case SECCAT_TBSS:
prefix = one_only ? ".tb" : ".tbss";
break;
- case SECCAT_EMUTLS_VAR:
- prefix = targetm.emutls.var_section;
- break;
- case SECCAT_EMUTLS_TMPL:
- prefix = targetm.emutls.tmpl_section;
- break;
default:
gcc_unreachable ();
}
/* 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_FLAG_FUNCTION;
if (targetm.binds_local_p (decl))
flags |= SYMBOL_FLAG_LOCAL;
- if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)
- && DECL_TLS_MODEL (decl) != TLS_MODEL_EMULATED)
+ if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
else if (targetm.in_small_data_p (decl))
flags |= SYMBOL_FLAG_SMALL;
return true;
}
+/* Return true when RESOLUTION indicate that symbol will be bound to the
+ definition provided by current .o file. */
+
+static bool
+resolution_to_local_definition_p (enum ld_plugin_symbol_resolution resolution)
+{
+ return (resolution == LDPR_PREVAILING_DEF
+ || resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
+ || resolution == LDPR_PREVAILING_DEF_IRONLY);
+}
+
+/* Return true when RESOLUTION indicate that symbol will be bound locally
+ within current executable or DSO. */
+
+static bool
+resolution_local_p (enum ld_plugin_symbol_resolution resolution)
+{
+ return (resolution == LDPR_PREVAILING_DEF
+ || resolution == LDPR_PREVAILING_DEF_IRONLY
+ || resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
+ || resolution == LDPR_PREEMPTED_REG
+ || resolution == LDPR_PREEMPTED_IR
+ || resolution == LDPR_RESOLVED_IR
+ || resolution == LDPR_RESOLVED_EXEC);
+}
+
/* Assume ELF-ish defaults, since that's pretty much the most liberal
wrt cross-module name binding. */
default_binds_local_p_1 (const_tree exp, int shlib)
{
bool local_p;
+ bool resolved_locally = false;
+ bool resolved_to_local_def = false;
+
+ /* With resolution file in hands, take look into resolutions.
+ We can't just return true for resolved_locally symbols,
+ because dynamic linking might overwrite symbols
+ in shared libraries. */
+ if (TREE_CODE (exp) == VAR_DECL && TREE_PUBLIC (exp)
+ && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
+ {
+ struct varpool_node *vnode = varpool_get_node (exp);
+ if (vnode && resolution_local_p (vnode->resolution))
+ resolved_locally = true;
+ if (vnode
+ && resolution_to_local_definition_p (vnode->resolution))
+ resolved_to_local_def = true;
+ }
+ else if (TREE_CODE (exp) == FUNCTION_DECL && TREE_PUBLIC (exp))
+ {
+ struct cgraph_node *node = cgraph_get_node (exp);
+ if (node
+ && resolution_local_p (node->resolution))
+ resolved_locally = true;
+ if (node
+ && resolution_to_local_definition_p (node->resolution))
+ resolved_to_local_def = true;
+ }
/* A non-decl is an entry in the constant pool. */
if (!DECL_P (exp))
local_p = true;
/* Weakrefs may not bind locally, even though the weakref itself is
- always static and therefore local. */
+ always static and therefore local.
+ FIXME: We can resolve this more curefuly by looking at the weakref
+ alias. */
else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)))
local_p = false;
/* Static variables are always local. */
local_p = true;
/* A variable is local if the user has said explicitly that it will
be. */
- else if (DECL_VISIBILITY_SPECIFIED (exp)
+ else if ((DECL_VISIBILITY_SPECIFIED (exp)
+ || resolved_to_local_def)
&& DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
local_p = true;
/* Variables defined outside this object might not be local. */
- else if (DECL_EXTERNAL (exp))
+ else if (DECL_EXTERNAL (exp) && !resolved_locally)
local_p = false;
/* If defined in this object and visibility is not default, must be
local. */
local_p = true;
/* Default visibility weak data can be overridden by a strong symbol
in another module and so are not local. */
- else if (DECL_WEAK (exp))
+ else if (DECL_WEAK (exp)
+ && !resolved_locally)
local_p = false;
/* If PIC, then assume that any global name can be overridden by
- symbols resolved from other modules, unless we are compiling with
- -fwhole-program, which assumes that names are local. */
+ symbols resolved from other modules. */
else if (shlib)
- local_p = flag_whole_program;
+ local_p = false;
/* Uninitialized COMMON variable may be unified with symbols
resolved from other modules. */
else if (DECL_COMMON (exp)
+ && !resolved_locally
&& (DECL_INITIAL (exp) == NULL
|| DECL_INITIAL (exp) == error_mark_node))
local_p = false;
return local_p;
}
-/* Determine whether or not a pointer mode is valid. Assume defaults
- of ptr_mode or Pmode - can be overridden. */
+/* Return true when references to DECL must bind to current definition in
+ final executable.
+
+ The condition is usually equivalent to whether the function binds to the
+ current module (shared library or executable), that is to binds_local_p.
+ We use this fact to avoid need for another target hook and implement
+ the logic using binds_local_p and just special cases where
+ decl_binds_to_current_def_p is stronger than binds_local_p. In particular
+ the weak definitions (that can be overwritten at linktime by other
+ definition from different object file) and when resolution info is available
+ we simply use the knowledge passed to us by linker plugin. */
+bool
+decl_binds_to_current_def_p (tree decl)
+{
+ gcc_assert (DECL_P (decl));
+ if (!TREE_PUBLIC (decl))
+ return true;
+ if (!targetm.binds_local_p (decl))
+ return false;
+ /* When resolution is available, just use it. */
+ if (TREE_CODE (decl) == VAR_DECL
+ && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
+ {
+ struct varpool_node *vnode = varpool_get_node (decl);
+ if (vnode
+ && vnode->resolution != LDPR_UNKNOWN)
+ return resolution_to_local_definition_p (vnode->resolution);
+ }
+ else if (TREE_CODE (decl) == FUNCTION_DECL)
+ {
+ struct cgraph_node *node = cgraph_get_node (decl);
+ if (node
+ && node->resolution != LDPR_UNKNOWN)
+ return resolution_to_local_definition_p (node->resolution);
+ }
+ /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks
+ binds locally but still can be overwritten).
+ This rely on fact that binds_local_p behave as decl_replaceable_p
+ for all other declaration types. */
+ return !DECL_WEAK (decl);
+}
+
+/* A replaceable function or variable is one which may be replaced
+ at link-time with an entirely different definition, provided that the
+ replacement has the same type. For example, functions declared
+ with __attribute__((weak)) on most systems are replaceable.
+
+ COMDAT functions are not replaceable, since all definitions of the
+ function must be equivalent. It is important that COMDAT functions
+ not be treated as replaceable so that use of C++ template
+ instantiations is not penalized. */
+
bool
-default_valid_pointer_mode (enum machine_mode mode)
+decl_replaceable_p (tree decl)
{
- return (mode == ptr_mode || mode == Pmode);
+ gcc_assert (DECL_P (decl));
+ if (!TREE_PUBLIC (decl) || DECL_COMDAT (decl))
+ return false;
+ return !decl_binds_to_current_def_p (decl);
}
/* Default function to output code that will globalize a label. A
the class of label and LABELNO is the number within the class. */
void
+default_generate_internal_label (char *buf, const char *prefix,
+ unsigned long labelno)
+{
+ ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
+}
+
+/* This is how to output an internal numbered label where PREFIX is
+ the class of label and LABELNO is the number within the class. */
+
+void
default_internal_label (FILE *stream, const char *prefix,
unsigned long labelno)
{
ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
}
+
+/* The default implementation of ASM_DECLARE_CONSTANT_NAME. */
+
+void
+default_asm_declare_constant_name (FILE *file, const char *name,
+ const_tree exp ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT size ATTRIBUTE_UNUSED)
+{
+ assemble_label (file, name);
+}
+
/* This is the default behavior at the beginning of a file. It's
controlled by two other target-hook toggles. */
void
default_file_start (void)
{
- if (targetm.file_start_app_off
+ if (targetm.asm_file_start_app_off
&& !(flag_verbose_asm || flag_debug_asm || flag_dump_rtl_in_asm))
fputs (ASM_APP_OFF, asm_out_file);
- if (targetm.file_start_file_directive)
+ if (targetm.asm_file_start_file_directive)
output_file_directive (asm_out_file, main_input_filename);
}
switch_to_section (get_section (".note.GNU-stack", flags, NULL));
}
+/* Emit a special section directive to indicate that this object file
+ was compiled with -fsplit-stack. This is used to let the linker
+ detect calls between split-stack code and non-split-stack code, so
+ that it can modify the split-stack code to allocate a sufficiently
+ large stack. We emit another special section if there are any
+ functions in this file which have the no_split_stack attribute, to
+ prevent the linker from warning about being unable to convert the
+ functions if they call non-split-stack code. */
+
+void
+file_end_indicate_split_stack (void)
+{
+ if (flag_split_stack)
+ {
+ switch_to_section (get_section (".note.GNU-split-stack", SECTION_DEBUG,
+ NULL));
+ if (saw_no_split_stack)
+ switch_to_section (get_section (".note.GNU-no-split-stack",
+ SECTION_DEBUG, NULL));
+ }
+}
+
/* Output DIRECTIVE (a C string) followed by a newline. This is used as
a get_unnamed_section callback. */
switch (SECTION_STYLE (new_section))
{
case SECTION_NAMED:
- if (cfun
- && !crtl->subsections.unlikely_text_section_name
- && strcmp (new_section->named.name,
- UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
- crtl->subsections.unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
-
targetm.asm_out.named_section (new_section->named.name,
new_section->named.common.flags,
new_section->named.decl);
else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
{
decl = SYMBOL_REF_DECL (symbol);
- alignment = get_constant_alignment (decl);
- size = get_constant_size (decl);
+ alignment = DECL_ALIGN (decl);
+ size = get_constant_size (DECL_INITIAL (decl));
}
else
{
/* Define the values of all anchors relative to the current section
position. */
- for (i = 0; VEC_iterate (rtx, block->anchors, i, symbol); i++)
+ FOR_EACH_VEC_ELT (rtx, block->anchors, i, symbol)
targetm.asm_out.output_anchor (symbol);
/* Output the objects themselves. */
offset = 0;
- for (i = 0; VEC_iterate (rtx, block->objects, i, symbol); i++)
+ FOR_EACH_VEC_ELT (rtx, block->objects, i, symbol)
{
/* Move to the object's offset, padding with zeros if necessary. */
assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset);
else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
{
decl = SYMBOL_REF_DECL (symbol);
- assemble_constant_contents (decl, XSTR (symbol, 0),
- get_constant_alignment (decl));
- offset += get_constant_size (decl);
+ assemble_constant_contents (DECL_INITIAL (decl), XSTR (symbol, 0),
+ DECL_ALIGN (decl));
+ offset += get_constant_size (DECL_INITIAL (decl));
}
else
{
int
elf_record_gcc_switches (print_switch_type type, const char * name)
{
- static char buffer[1024];
-
- /* This variable is used as part of a simplistic heuristic to detect
- command line switches which take an argument:
-
- "If a command line option does not start with a dash then
- it is an argument for the previous command line option."
-
- This fails in the case of the command line option which is the name
- of the file to compile, but otherwise it is pretty reasonable. */
- static bool previous_name_held_back = FALSE;
-
switch (type)
{
case SWITCH_TYPE_PASSED:
- if (* name != '-')
- {
- if (previous_name_held_back)
- {
- unsigned int len = strlen (buffer);
-
- snprintf (buffer + len, sizeof buffer - len, " %s", name);
- ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
- ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
- previous_name_held_back = FALSE;
- }
- else
- {
- strncpy (buffer, name, sizeof buffer);
- ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
- ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
- }
- }
- else
- {
- if (previous_name_held_back)
- {
- ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
- ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
- }
-
- strncpy (buffer, name, sizeof buffer);
- previous_name_held_back = TRUE;
- }
+ ASM_OUTPUT_ASCII (asm_out_file, name, strlen (name));
+ ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
break;
case SWITCH_TYPE_DESCRIPTIVE:
/* Distinguish between invocations where name is NULL. */
static bool started = false;
- if (started)
- {
- if (previous_name_held_back)
- {
- ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
- ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
- }
- }
- else
+ if (!started)
{
section * sec;
maybe_assemble_visibility (decl);
}
+/* The default hook for TARGET_ASM_OUTPUT_SOURCE_FILENAME. */
+
+void
+default_asm_output_source_filename (FILE *file, const char *name)
+{
+#ifdef ASM_OUTPUT_SOURCE_FILENAME
+ ASM_OUTPUT_SOURCE_FILENAME (file, name);
+#else
+ fprintf (file, "\t.file\t");
+ output_quoted_string (file, name);
+ putc ('\n', file);
+#endif
+}
+
+/* Output a file name in the form wanted by System V. */
+
+void
+output_file_directive (FILE *asm_file, const char *input_name)
+{
+ int len;
+ const char *na;
+
+ if (input_name == NULL)
+ input_name = "<stdin>";
+ else
+ input_name = remap_debug_filename (input_name);
+
+ len = strlen (input_name);
+ na = input_name + len;
+
+ /* NA gets INPUT_NAME sans directory names. */
+ while (na > input_name)
+ {
+ if (IS_DIR_SEPARATOR (na[-1]))
+ break;
+ na--;
+ }
+
+ targetm.asm_out.output_source_filename (asm_file, na);
+}
+
+/* Create a DEBUG_EXPR_DECL / DEBUG_EXPR pair from RTL expression
+ EXP. */
+rtx
+make_debug_expr_from_rtl (const_rtx exp)
+{
+ tree ddecl = make_node (DEBUG_EXPR_DECL), type;
+ enum machine_mode mode = GET_MODE (exp);
+ rtx dval;
+
+ DECL_ARTIFICIAL (ddecl) = 1;
+ if (REG_P (exp) && REG_EXPR (exp))
+ type = TREE_TYPE (REG_EXPR (exp));
+ else if (MEM_P (exp) && MEM_EXPR (exp))
+ type = TREE_TYPE (MEM_EXPR (exp));
+ else
+ type = NULL_TREE;
+ if (type && TYPE_MODE (type) == mode)
+ TREE_TYPE (ddecl) = type;
+ else
+ TREE_TYPE (ddecl) = lang_hooks.types.type_for_mode (mode, 1);
+ DECL_MODE (ddecl) = mode;
+ dval = gen_rtx_DEBUG_EXPR (mode);
+ DEBUG_EXPR_TREE_DECL (dval) = ddecl;
+ SET_DECL_RTL (ddecl, dval);
+ return dval;
+}
+
+#ifdef ELF_ASCII_ESCAPES
+/* Default ASM_OUTPUT_LIMITED_STRING for ELF targets. */
+
+void
+default_elf_asm_output_limited_string (FILE *f, const char *s)
+{
+ int escape;
+ unsigned char c;
+
+ fputs ("\t.string\t\"", f);
+ while (*s != '\0')
+ {
+ c = *s;
+ escape = ELF_ASCII_ESCAPES[c];
+ switch (escape)
+ {
+ case 0:
+ putc (c, f);
+ break;
+ case 1:
+ /* TODO: Print in hex with fast function, important for -flto. */
+ fprintf (f, "\\%03o", c);
+ break;
+ default:
+ putc ('\\', f);
+ putc (escape, f);
+ break;
+ }
+ s++;
+ }
+ putc ('\"', f);
+ putc ('\n', f);
+}
+
+/* Default ASM_OUTPUT_ASCII for ELF targets. */
+
+void
+default_elf_asm_output_ascii (FILE *f, const char *s, unsigned int len)
+{
+ const char *limit = s + len;
+ const char *last_null = NULL;
+ unsigned bytes_in_chunk = 0;
+ unsigned char c;
+ int escape;
+
+ for (; s < limit; s++)
+ {
+ const char *p;
+
+ if (bytes_in_chunk >= 60)
+ {
+ putc ('\"', f);
+ putc ('\n', f);
+ bytes_in_chunk = 0;
+ }
+
+ if (s > last_null)
+ {
+ for (p = s; p < limit && *p != '\0'; p++)
+ continue;
+ last_null = p;
+ }
+ else
+ p = last_null;
+
+ if (p < limit && (p - s) <= (long) ELF_STRING_LIMIT)
+ {
+ if (bytes_in_chunk > 0)
+ {
+ putc ('\"', f);
+ putc ('\n', f);
+ bytes_in_chunk = 0;
+ }
+
+ default_elf_asm_output_limited_string (f, s);
+ s = p;
+ }
+ else
+ {
+ if (bytes_in_chunk == 0)
+ fputs (ASCII_DATA_ASM_OP "\"", f);
+
+ c = *s;
+ escape = ELF_ASCII_ESCAPES[c];
+ switch (escape)
+ {
+ case 0:
+ putc (c, f);
+ bytes_in_chunk++;
+ break;
+ case 1:
+ /* TODO: Print in hex with fast function, important for -flto. */
+ fprintf (f, "\\%03o", c);
+ bytes_in_chunk += 4;
+ break;
+ default:
+ putc ('\\', f);
+ putc (escape, f);
+ bytes_in_chunk += 2;
+ break;
+ }
+
+ }
+ }
+
+ if (bytes_in_chunk > 0)
+ {
+ putc ('\"', f);
+ putc ('\n', f);
+ }
+}
+#endif
+
+/* Default TARGET_ASM_INTERNAL_LABEL for ELF targets. */
+
+void
+default_elf_internal_label (FILE *f, const char *prefix,
+ unsigned long labelno)
+{
+ putc ('.', f);
+ fputs (prefix, f);
+ fprint_ul (f, labelno);
+ putc (':', f);
+ putc ('\n', f);
+}
+
+static GTY(()) section *elf_init_array_section;
+static GTY(()) section *elf_fini_array_section;
+
+static section *
+get_elf_initfini_array_priority_section (int priority,
+ bool constructor_p)
+{
+ section *sec;
+ if (priority != DEFAULT_INIT_PRIORITY)
+ {
+ char buf[18];
+ sprintf (buf, "%s.%.5u",
+ constructor_p ? ".init_array" : ".fini_array",
+ priority);
+ sec = get_section (buf, SECTION_WRITE, NULL_TREE);
+ }
+ else
+ {
+ if (constructor_p)
+ {
+ if (elf_init_array_section == NULL)
+ elf_init_array_section
+ = get_unnamed_section (0, output_section_asm_op,
+ "\t.section\t.init_array");
+ sec = elf_init_array_section;
+ }
+ else
+ {
+ if (elf_fini_array_section == NULL)
+ elf_fini_array_section
+ = get_unnamed_section (0, output_section_asm_op,
+ "\t.section\t.fini_array");
+ sec = elf_fini_array_section;
+ }
+ }
+ return sec;
+}
+
+/* Use .init_array section for constructors. */
+
+void
+default_elf_init_array_asm_out_constructor (rtx symbol, int priority)
+{
+ section *sec = get_elf_initfini_array_priority_section (priority,
+ true);
+ assemble_addr_to_section (symbol, sec);
+}
+
+/* Use .fini_array section for destructors. */
+
+void
+default_elf_fini_array_asm_out_destructor (rtx symbol, int priority)
+{
+ section *sec = get_elf_initfini_array_priority_section (priority,
+ false);
+ assemble_addr_to_section (symbol, sec);
+}
+
#include "gt-varasm.h"
OSDN Git Service
