X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;ds=sidebyside;f=gcc%2Fvarasm.c;h=d9468c4997dcd068ba90e04e475c1ac9d1260dc5;hb=d37446aa31ac9074242fa8b45d2cd48082a1714c;hp=9837e0de14742bca6f6dbc36533b5cace9dd080b;hpb=393cc65b6088b70b2e72b05c9f5ffb9e4910de3f;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/varasm.c b/gcc/varasm.c index 9837e0de147..d9468c4997d 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -1,13 +1,13 @@ /* 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 + 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free -Software Foundation; either version 2, or (at your option) any later +Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY @@ -16,9 +16,8 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ /* This file handles generation of all the assembler code @@ -49,10 +48,12 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "tm_p.h" #include "debug.h" #include "target.h" +#include "targhooks.h" #include "tree-mudflap.h" #include "cgraph.h" #include "cfglayout.h" #include "basic-block.h" +#include "tree-iterator.h" #ifdef XCOFF_DEBUGGING_INFO #include "xcoffout.h" /* Needed for external data @@ -70,17 +71,7 @@ struct addr_const; struct constant_descriptor_rtx; struct rtx_constant_pool; -struct varasm_status GTY(()) -{ - /* If we're using a per-function constant pool, this is it. */ - struct rtx_constant_pool *pool; - - /* Number of tree-constants deferred during the expansion of this - function. */ - unsigned int deferred_constants; -}; - -#define n_deferred_constants (cfun->varasm->deferred_constants) +#define n_deferred_constants (crtl->varasm.deferred_constants) /* Number for making the label on the next constant that is stored in memory. */ @@ -107,7 +98,7 @@ bool first_function_block_is_cold; /* We give all constants their own alias set. Perhaps redundant with MEM_READONLY_P, but pre-dates it. */ -static HOST_WIDE_INT const_alias_set; +static alias_set_type const_alias_set; static const char *strip_reg_name (const char *); static int contains_pointers_p (tree); @@ -126,7 +117,6 @@ static unsigned HOST_WIDE_INT array_size_for_constructor (tree); static unsigned min_align (unsigned, unsigned); static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int); static void globalize_decl (tree); -static void maybe_assemble_visibility (tree); #ifdef BSS_SECTION_ASM_OP #ifdef ASM_OUTPUT_BSS static void asm_output_bss (FILE *, tree, const char *, @@ -200,6 +190,280 @@ static GTY(()) int anchor_labelno; /* 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 = 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 (FIELD_DECL, get_identifier ("__templ"), ptr_type_node); + DECL_CONTEXT (field) = type; + next_field = field; + + field = build_decl (FIELD_DECL, get_identifier ("__offset"), + ptr_type_node); + DECL_CONTEXT (field) = type; + TREE_CHAIN (field) = next_field; + next_field = field; + + word_type_node = lang_hooks.types.type_for_mode (word_mode, 1); + field = build_decl (FIELD_DECL, get_identifier ("__align"), + word_type_node); + DECL_CONTEXT (field) = type; + TREE_CHAIN (field) = next_field; + next_field = field; + + field = build_decl (FIELD_DECL, get_identifier ("__size"), word_type_node); + 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 (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 (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); + 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 = *loc; + if (h != NULL) + to = h->to; + else + { + to = build_decl (VAR_DECL, get_emutls_object_name (name), + get_emutls_object_type ()); + + h = ggc_alloc (sizeof (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_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 (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 @@ -386,7 +650,7 @@ initialize_cold_section_name (void) tree dsn; gcc_assert (cfun && current_function_decl); - if (cfun->unlikely_text_section_name) + if (crtl->subsections.unlikely_text_section_name) return; dsn = DECL_SECTION_NAME (current_function_decl); @@ -398,10 +662,10 @@ initialize_cold_section_name (void) stripped_name = targetm.strip_name_encoding (name); buffer = ACONCAT ((stripped_name, "_unlikely", NULL)); - cfun->unlikely_text_section_name = ggc_strdup (buffer); + crtl->subsections.unlikely_text_section_name = ggc_strdup (buffer); } else - cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; + crtl->subsections.unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; } /* Tell assembler to switch to unlikely-to-be-executed text section. */ @@ -411,10 +675,10 @@ unlikely_text_section (void) { if (cfun) { - if (!cfun->unlikely_text_section_name) + if (!crtl->subsections.unlikely_text_section_name) initialize_cold_section_name (); - return get_named_section (NULL, cfun->unlikely_text_section_name, 0); + return get_named_section (NULL, crtl->subsections.unlikely_text_section_name, 0); } else return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0); @@ -431,7 +695,7 @@ unlikely_text_section_p (section *sect) const char *name; if (cfun) - name = cfun->unlikely_text_section_name; + name = crtl->subsections.unlikely_text_section_name; else name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; @@ -490,7 +754,8 @@ asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED, unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, unsigned HOST_WIDE_INT rounded) { - targetm.asm_out.globalize_label (file, name); + 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; @@ -820,7 +1085,7 @@ decode_reg_name (const char *asmspec) /* Return true if DECL's initializer is suitable for a BSS section. */ static bool -bss_initializer_p (tree decl) +bss_initializer_p (const_tree decl) { return (DECL_INITIAL (decl) == NULL || DECL_INITIAL (decl) == error_mark_node @@ -860,11 +1125,22 @@ align_variable (tree decl, bool dont_output_data) if (! DECL_USER_ALIGN (decl)) { #ifdef DATA_ALIGNMENT - align = DATA_ALIGNMENT (TREE_TYPE (decl), align); + unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align); + /* Don't increase alignment too much for TLS variables - TLS space + is too precious. */ + if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD) + align = data_align; #endif #ifdef CONSTANT_ALIGNMENT if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node) - align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align); + { + unsigned int const_align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), + align); + /* Don't increase alignment too much for TLS variables - TLS space + is too precious. */ + if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD) + align = const_align; + } #endif } @@ -888,7 +1164,12 @@ get_variable_section (tree decl, bool prefer_noswitch_p) { if (DECL_THREAD_LOCAL_P (decl)) return tls_comm_section; - if (TREE_PUBLIC (decl) && bss_initializer_p (decl)) + /* 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; } @@ -981,6 +1262,10 @@ use_blocks_for_decl_p (tree decl) if (DECL_INITIAL (decl) == decl) return false; + /* 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 true; } @@ -1162,17 +1447,6 @@ make_decl_rtl (tree decl) if (flag_mudflap && TREE_CODE (decl) == VAR_DECL) mudflap_enqueue_decl (decl); } - -/* Make the rtl for variable VAR be volatile. - Use this only for static variables. */ - -void -make_var_volatile (tree var) -{ - gcc_assert (MEM_P (DECL_RTL (var))); - - MEM_VOLATILE_P (DECL_RTL (var)) = 1; -} /* Output a string of literal assembler code for an `asm' keyword used between functions. */ @@ -1207,26 +1481,44 @@ default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED, #endif } -void -default_named_section_asm_out_destructor (rtx symbol, int priority) +/* Write the address of the entity given by SYMBOL to SEC. */ +void +assemble_addr_to_section (rtx symbol, section *sec) +{ + switch_to_section (sec); + assemble_align (POINTER_SIZE); + assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); +} + +/* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if + not) section for PRIORITY. */ +section * +get_cdtor_priority_section (int priority, bool constructor_p) { - const char *section = ".dtors"; char buf[16]; /* ??? This only works reliably with the GNU linker. */ + sprintf (buf, "%s.%.5u", + constructor_p ? ".ctors" : ".dtors", + /* Invert the numbering so the linker puts us in the proper + order; constructors are run from right to left, and the + linker sorts in increasing order. */ + MAX_INIT_PRIORITY - priority); + return get_section (buf, SECTION_WRITE, NULL); +} + +void +default_named_section_asm_out_destructor (rtx symbol, int priority) +{ + section *sec; + if (priority != DEFAULT_INIT_PRIORITY) - { - sprintf (buf, ".dtors.%.5u", - /* Invert the numbering so the linker puts us in the proper - order; constructors are run from right to left, and the - linker sorts in increasing order. */ - MAX_INIT_PRIORITY - priority); - section = buf; - } + sec = get_cdtor_priority_section (priority, + /*constructor_p=*/false); + else + sec = get_section (".dtors", SECTION_WRITE, NULL); - switch_to_section (get_section (section, SECTION_WRITE, NULL)); - assemble_align (POINTER_SIZE); - assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); + assemble_addr_to_section (symbol, sec); } #ifdef DTORS_SECTION_ASM_OP @@ -1234,9 +1526,7 @@ void default_dtor_section_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED) { - switch_to_section (dtors_section); - assemble_align (POINTER_SIZE); - assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); + assemble_addr_to_section (symbol, dtors_section); } #endif @@ -1260,23 +1550,15 @@ default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED, void default_named_section_asm_out_constructor (rtx symbol, int priority) { - const char *section = ".ctors"; - char buf[16]; + section *sec; - /* ??? This only works reliably with the GNU linker. */ if (priority != DEFAULT_INIT_PRIORITY) - { - sprintf (buf, ".ctors.%.5u", - /* Invert the numbering so the linker puts us in the proper - order; constructors are run from right to left, and the - linker sorts in increasing order. */ - MAX_INIT_PRIORITY - priority); - section = buf; - } + sec = get_cdtor_priority_section (priority, + /*constructor_p=*/true); + else + sec = get_section (".ctors", SECTION_WRITE, NULL); - switch_to_section (get_section (section, SECTION_WRITE, NULL)); - assemble_align (POINTER_SIZE); - assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); + assemble_addr_to_section (symbol, sec); } #ifdef CTORS_SECTION_ASM_OP @@ -1284,9 +1566,7 @@ void default_ctor_section_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED) { - switch_to_section (ctors_section); - assemble_align (POINTER_SIZE); - assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); + assemble_addr_to_section (symbol, ctors_section); } #endif @@ -1323,7 +1603,7 @@ notice_global_symbol (tree decl) /* We win when global object is found, but it is useful to know about weak symbol as well so we can produce nicer unique names. */ - if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl)) + if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl) || flag_shlib) type = &weak_global_object_name; if (!*type) @@ -1351,27 +1631,27 @@ assemble_start_function (tree decl, const char *fnname) char tmp_label[100]; bool hot_label_written = false; - cfun->unlikely_text_section_name = NULL; + 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); - cfun->hot_section_label = ggc_strdup (tmp_label); + crtl->subsections.hot_section_label = ggc_strdup (tmp_label); ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno); - cfun->cold_section_label = ggc_strdup (tmp_label); + crtl->subsections.cold_section_label = ggc_strdup (tmp_label); ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno); - cfun->hot_section_end_label = ggc_strdup (tmp_label); + crtl->subsections.hot_section_end_label = ggc_strdup (tmp_label); ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno); - cfun->cold_section_end_label = ggc_strdup (tmp_label); + crtl->subsections.cold_section_end_label = ggc_strdup (tmp_label); const_labelno++; } else { - cfun->hot_section_label = NULL; - cfun->cold_section_label = NULL; - cfun->hot_section_end_label = NULL; - cfun->cold_section_end_label = NULL; + crtl->subsections.hot_section_label = NULL; + crtl->subsections.cold_section_label = NULL; + crtl->subsections.hot_section_end_label = NULL; + crtl->subsections.cold_section_end_label = NULL; } /* The following code does not need preprocessing in the assembler. */ @@ -1391,18 +1671,18 @@ assemble_start_function (tree decl, const char *fnname) if (flag_reorder_blocks_and_partition) { switch_to_section (unlikely_text_section ()); - assemble_align (FUNCTION_BOUNDARY); - ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label); + assemble_align (DECL_ALIGN (decl)); + ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label); /* When the function starts with a cold section, we need to explicitly align the hot section and write out the hot section label. But if the current function is a thunk, we do not have a CFG. */ - if (!current_function_is_thunk + if (!crtl->is_thunk && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION) { switch_to_section (text_section); - assemble_align (FUNCTION_BOUNDARY); - ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label); + assemble_align (DECL_ALIGN (decl)); + ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label); hot_label_written = true; first_function_block_is_cold = true; } @@ -1416,9 +1696,9 @@ assemble_start_function (tree decl, const char *fnname) initialize_cold_section_name (); - if (cfun->unlikely_text_section_name + if (crtl->subsections.unlikely_text_section_name && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), - cfun->unlikely_text_section_name) == 0) + crtl->subsections.unlikely_text_section_name) == 0) first_function_block_is_cold = true; } @@ -1429,21 +1709,20 @@ assemble_start_function (tree decl, const char *fnname) switch_to_section (function_section (decl)); if (flag_reorder_blocks_and_partition && !hot_label_written) - ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label); + ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label); /* Tell assembler to move to target machine's alignment for functions. */ - align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT); - if (align < force_align_functions_log) - align = force_align_functions_log; + align = floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT); if (align > 0) { ASM_OUTPUT_ALIGN (asm_out_file, align); } /* Handle a user-specified function alignment. - Note that we still need to align to FUNCTION_BOUNDARY, as above, + Note that we still need to align to DECL_ALIGN, as above, because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */ - if (align_functions_log > align + if (! DECL_USER_ALIGN (decl) + && align_functions_log > align && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED) { #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN @@ -1508,12 +1787,12 @@ assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED) save_text_section = in_section; switch_to_section (unlikely_text_section ()); - ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label); + ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_end_label); if (first_function_block_is_cold) switch_to_section (text_section); else switch_to_section (function_section (decl)); - ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label); + ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_end_label); switch_to_section (save_text_section); } } @@ -1715,6 +1994,40 @@ assemble_variable_contents (tree decl, const char *name, } } +/* 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. @@ -1733,8 +2046,34 @@ assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, rtx decl_rtl, symbol; section *sect; - if (lang_hooks.decls.prepare_assemble_variable) - lang_hooks.decls.prepare_assemble_variable (decl); + 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); + } + + decl = to; + } last_assemble_variable_decl = 0; @@ -1964,11 +2303,10 @@ assemble_external (tree decl ATTRIBUTE_UNUSED) if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl)) return; - if (flag_unit_at_a_time) - pending_assemble_externals = tree_cons (0, decl, - pending_assemble_externals); - else - assemble_external_real (decl); + /* We want to output external symbols at very last to check if they + are references or not. */ + pending_assemble_externals = tree_cons (0, decl, + pending_assemble_externals); #endif } @@ -2018,8 +2356,8 @@ mark_decl_referenced (tree decl) } else if (TREE_CODE (decl) == VAR_DECL) { - struct cgraph_varpool_node *node = cgraph_varpool_node (decl); - cgraph_varpool_mark_needed_node (node); + struct varpool_node *node = varpool_node (decl); + varpool_mark_needed_node (node); /* C++ frontend use mark_decl_references to force COMDAT variables to be output that might appear dead otherwise. */ node->force_output = true; @@ -2276,11 +2614,17 @@ assemble_integer (rtx x, unsigned int size, unsigned int align, int force) enum machine_mode omode, imode; unsigned int subalign; unsigned int subsize, i; + unsigned char mclass; subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1; subalign = MIN (align, subsize * BITS_PER_UNIT); - omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0); - imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0); + if (GET_CODE (x) == CONST_FIXED) + mclass = GET_MODE_CLASS (GET_MODE (x)); + else + mclass = MODE_INT; + + omode = mode_for_size (subsize * BITS_PER_UNIT, mclass, 0); + imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0); for (i = 0; i < size; i += subsize) { @@ -2392,6 +2736,7 @@ decode_addr_const (tree exp, struct addr_const *value) break; case REAL_CST: + case FIXED_CST: case STRING_CST: case COMPLEX_CST: case CONSTRUCTOR: @@ -2439,7 +2784,7 @@ static void maybe_output_constant_def_contents (struct constant_descriptor_tree static hashval_t const_desc_hash (const void *ptr) { - return ((struct constant_descriptor_tree *)ptr)->hash; + return ((const struct constant_descriptor_tree *)ptr)->hash; } static hashval_t @@ -2463,6 +2808,9 @@ const_hash_1 (const tree exp) case REAL_CST: return real_hash (TREE_REAL_CST_PTR (exp)); + case FIXED_CST: + return fixed_hash (TREE_FIXED_CST_PTR (exp)); + case STRING_CST: p = TREE_STRING_POINTER (exp); len = TREE_STRING_LENGTH (exp); @@ -2514,13 +2862,12 @@ const_hash_1 (const tree exp) return hi; case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9 + const_hash_1 (TREE_OPERAND (exp, 1))); - case NOP_EXPR: - case CONVERT_EXPR: - case NON_LVALUE_EXPR: + CASE_CONVERT: return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2; default: @@ -2580,6 +2927,13 @@ compare_constant (const tree t1, const tree t2) return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); + case FIXED_CST: + /* Fixed constants are the same only if the same width of type. */ + if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2))) + return 0; + + return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2)); + case STRING_CST: if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))) return 0; @@ -2660,27 +3014,18 @@ compare_constant (const tree t1, const tree t2) } case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: case RANGE_EXPR: return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)) && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))); - case NOP_EXPR: - case CONVERT_EXPR: - case NON_LVALUE_EXPR: + CASE_CONVERT: case VIEW_CONVERT_EXPR: return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); default: - { - tree nt1, nt2; - nt1 = lang_hooks.expand_constant (t1); - nt2 = lang_hooks.expand_constant (t2); - if (nt1 != t1 || nt2 != t2) - return compare_constant (nt1, nt2); - else - return 0; - } + return 0; } gcc_unreachable (); @@ -2705,6 +3050,7 @@ copy_constant (tree exp) case INTEGER_CST: case REAL_CST: + case FIXED_CST: case STRING_CST: return copy_node (exp); @@ -2714,14 +3060,13 @@ copy_constant (tree exp) copy_constant (TREE_IMAGPART (exp))); case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: return build2 (TREE_CODE (exp), TREE_TYPE (exp), copy_constant (TREE_OPERAND (exp, 0)), copy_constant (TREE_OPERAND (exp, 1))); - case NOP_EXPR: - case CONVERT_EXPR: - case NON_LVALUE_EXPR: + CASE_CONVERT: case VIEW_CONVERT_EXPR: return build1 (TREE_CODE (exp), TREE_TYPE (exp), copy_constant (TREE_OPERAND (exp, 0))); @@ -2746,12 +3091,7 @@ copy_constant (tree exp) } default: - { - tree t = lang_hooks.expand_constant (exp); - - gcc_assert (t == exp); - return copy_constant (t); - } + gcc_unreachable (); } } @@ -3098,6 +3438,10 @@ const_rtx_hash_1 (rtx *xp, void *data) h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x)); break; + case CONST_FIXED: + h ^= fixed_hash (CONST_FIXED_VALUE (x)); + break; + case CONST_VECTOR: { int i; @@ -3158,15 +3502,10 @@ create_constant_pool (void) /* Initialize constant pool hashing for a new function. */ void -init_varasm_status (struct function *f) +init_varasm_status (void) { - struct varasm_status *p; - - p = ggc_alloc (sizeof (struct varasm_status)); - f->varasm = p; - - p->pool = create_constant_pool (); - p->deferred_constants = 0; + crtl->varasm.pool = create_constant_pool (); + crtl->varasm.deferred_constants = 0; } /* Given a MINUS expression, simplify it if both sides @@ -3198,12 +3537,12 @@ force_const_mem (enum machine_mode mode, rtx x) return NULL_RTX; /* Record that this function has used a constant pool entry. */ - current_function_uses_const_pool = 1; + crtl->uses_const_pool = 1; /* Decide which pool to use. */ pool = (targetm.use_blocks_for_constant_p (mode, x) ? shared_constant_pool - : cfun->varasm->pool); + : crtl->varasm.pool); /* Lookup the value in the hashtable. */ tmp.constant = x; @@ -3305,7 +3644,7 @@ get_pool_constant_mark (rtx addr, bool *pmarked) /* Similar, return the mode. */ enum machine_mode -get_pool_mode (rtx addr) +get_pool_mode (const_rtx addr) { return SYMBOL_REF_CONSTANT (addr)->mode; } @@ -3315,7 +3654,7 @@ get_pool_mode (rtx addr) int get_pool_size (void) { - return cfun->varasm->pool->offset; + return crtl->varasm.pool->offset; } /* Worker function for output_constant_pool_1. Emit assembly for X @@ -3339,11 +3678,19 @@ output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align) case MODE_INT: case MODE_PARTIAL_INT: + case MODE_FRACT: + case MODE_UFRACT: + case MODE_ACCUM: + case MODE_UACCUM: assemble_integer (x, GET_MODE_SIZE (mode), align, 1); break; case MODE_VECTOR_FLOAT: case MODE_VECTOR_INT: + case MODE_VECTOR_FRACT: + case MODE_VECTOR_UFRACT: + case MODE_VECTOR_ACCUM: + case MODE_VECTOR_UACCUM: { int i, units; enum machine_mode submode = GET_MODE_INNER (mode); @@ -3386,20 +3733,20 @@ output_constant_pool_1 (struct constant_descriptor_rtx *desc, functioning even with INSN_DELETED_P and friends. */ tmp = x; - switch (GET_CODE (x)) + switch (GET_CODE (tmp)) { case CONST: - if (GET_CODE (XEXP (x, 0)) != PLUS - || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF) + if (GET_CODE (XEXP (tmp, 0)) != PLUS + || GET_CODE (XEXP (XEXP (tmp, 0), 0)) != LABEL_REF) break; - tmp = XEXP (XEXP (x, 0), 0); + tmp = XEXP (XEXP (tmp, 0), 0); /* FALLTHRU */ case LABEL_REF: - tmp = XEXP (x, 0); + tmp = XEXP (tmp, 0); gcc_assert (!INSN_DELETED_P (tmp)); gcc_assert (!NOTE_P (tmp) - || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED); + || NOTE_KIND (tmp) != NOTE_INSN_DELETED); break; default: @@ -3504,13 +3851,13 @@ mark_constant_pool (void) { rtx insn, link; - if (!current_function_uses_const_pool && n_deferred_constants == 0) + if (!crtl->uses_const_pool && n_deferred_constants == 0) return; for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) mark_constants (insn); - for (link = current_function_epilogue_delay_list; + for (link = crtl->epilogue_delay_list; link; link = XEXP (link, 1)) mark_constants (XEXP (link, 0)); @@ -3549,7 +3896,7 @@ static void output_constant_pool (const char *fnname ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED) { - struct rtx_constant_pool *pool = cfun->varasm->pool; + struct rtx_constant_pool *pool = crtl->varasm.pool; /* It is possible for gcc to call force_const_mem and then to later discard the instructions which refer to the constant. In such a @@ -3583,10 +3930,6 @@ compute_reloc_for_constant (tree exp) int reloc = 0, reloc2; tree tem; - /* Give the front-end a chance to convert VALUE to something that - looks more like a constant to the back-end. */ - exp = lang_hooks.expand_constant (exp); - switch (TREE_CODE (exp)) { case ADDR_EXPR: @@ -3605,6 +3948,7 @@ compute_reloc_for_constant (tree exp) break; case PLUS_EXPR: + case POINTER_PLUS_EXPR: reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1)); break; @@ -3619,9 +3963,7 @@ compute_reloc_for_constant (tree exp) reloc |= reloc2; break; - case NOP_EXPR: - case CONVERT_EXPR: - case NON_LVALUE_EXPR: + CASE_CONVERT: case VIEW_CONVERT_EXPR: reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); break; @@ -3650,10 +3992,6 @@ output_addressed_constants (tree exp) { tree tem; - /* Give the front-end a chance to convert VALUE to something that - looks more like a constant to the back-end. */ - exp = lang_hooks.expand_constant (exp); - switch (TREE_CODE (exp)) { case ADDR_EXPR: @@ -3674,13 +4012,12 @@ output_addressed_constants (tree exp) break; case PLUS_EXPR: + case POINTER_PLUS_EXPR: case MINUS_EXPR: output_addressed_constants (TREE_OPERAND (exp, 1)); /* Fall through. */ - case NOP_EXPR: - case CONVERT_EXPR: - case NON_LVALUE_EXPR: + CASE_CONVERT: case VIEW_CONVERT_EXPR: output_addressed_constants (TREE_OPERAND (exp, 0)); break; @@ -3705,7 +4042,7 @@ output_addressed_constants (tree exp) evaluate the property while walking a constructor for other purposes. */ bool -constructor_static_from_elts_p (tree ctor) +constructor_static_from_elts_p (const_tree ctor) { return (TREE_CONSTANT (ctor) && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE @@ -3726,10 +4063,6 @@ constructor_static_from_elts_p (tree ctor) tree initializer_constant_valid_p (tree value, tree endtype) { - /* Give the front-end a chance to convert VALUE to something that - looks more like a constant to the back-end. */ - value = lang_hooks.expand_constant (value); - switch (TREE_CODE (value)) { case CONSTRUCTOR: @@ -3759,6 +4092,7 @@ initializer_constant_valid_p (tree value, tree endtype) case INTEGER_CST: case VECTOR_CST: case REAL_CST: + case FIXED_CST: case STRING_CST: case COMPLEX_CST: return null_pointer_node; @@ -3775,9 +4109,8 @@ initializer_constant_valid_p (tree value, tree endtype) return null_pointer_node; /* Taking the address of a nested function involves a trampoline. */ if (TREE_CODE (value) == FUNCTION_DECL - && ((decl_function_context (value) - && !DECL_NO_STATIC_CHAIN (value)) - || DECL_DLLIMPORT_P (value))) + && decl_function_context (value) + && !DECL_NO_STATIC_CHAIN (value)) return NULL_TREE; /* "&{...}" requires a temporary to hold the constructed object. */ @@ -3790,8 +4123,7 @@ initializer_constant_valid_p (tree value, tree endtype) case NON_LVALUE_EXPR: return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype); - case CONVERT_EXPR: - case NOP_EXPR: + CASE_CONVERT: { tree src; tree src_type; @@ -3852,6 +4184,7 @@ initializer_constant_valid_p (tree value, tree endtype) } break; + case POINTER_PLUS_EXPR: case PLUS_EXPR: if (! INTEGRAL_TYPE_P (endtype) || TYPE_PRECISION (endtype) >= POINTER_SIZE) @@ -3860,7 +4193,7 @@ initializer_constant_valid_p (tree value, tree endtype) endtype); tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1), endtype); - /* If either term is absolute, use the other terms relocation. */ + /* If either term is absolute, use the other term's relocation. */ if (valid0 == null_pointer_node) return valid1; if (valid1 == null_pointer_node) @@ -3906,8 +4239,7 @@ initializer_constant_valid_p (tree value, tree endtype) (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory that the narrower operation is cheaper. */ - while (TREE_CODE (op0) == NOP_EXPR - || TREE_CODE (op0) == CONVERT_EXPR + while (CONVERT_EXPR_P (op0) || TREE_CODE (op0) == NON_LVALUE_EXPR) { tree inner = TREE_OPERAND (op0, 0); @@ -3919,8 +4251,7 @@ initializer_constant_valid_p (tree value, tree endtype) op0 = inner; } - while (TREE_CODE (op1) == NOP_EXPR - || TREE_CODE (op1) == CONVERT_EXPR + while (CONVERT_EXPR_P (op1) || TREE_CODE (op1) == NON_LVALUE_EXPR) { tree inner = TREE_OPERAND (op1, 0); @@ -3987,11 +4318,6 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) enum tree_code code; unsigned HOST_WIDE_INT thissize; - /* Some front-ends use constants other than the standard language-independent - varieties, but which may still be output directly. Give the front-end a - chance to convert EXP to a language-independent representation. */ - exp = lang_hooks.expand_constant (exp); - if (size == 0 || flag_syntax_only) return; @@ -4026,7 +4352,7 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) /* Eliminate any conversions since we'll be outputting the underlying constant. */ - while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR + while (CONVERT_EXPR_P (exp) || TREE_CODE (exp) == NON_LVALUE_EXPR || TREE_CODE (exp) == VIEW_CONVERT_EXPR) { @@ -4039,18 +4365,15 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) if (type_size > op_size && TREE_CODE (exp) != VIEW_CONVERT_EXPR && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE) - internal_error ("no-op convert from %wd to %wd bytes in initializer", - op_size, type_size); - - exp = TREE_OPERAND (exp, 0); + /* Keep the conversion. */ + break; + else + exp = TREE_OPERAND (exp, 0); } code = TREE_CODE (TREE_TYPE (exp)); thissize = int_size_in_bytes (TREE_TYPE (exp)); - /* Give the front end another chance to expand constants. */ - exp = lang_hooks.expand_constant (exp); - /* Allow a constructor with no elements for any data type. This means to fill the space with zeros. */ if (TREE_CODE (exp) == CONSTRUCTOR @@ -4082,10 +4405,11 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) case POINTER_TYPE: case REFERENCE_TYPE: case OFFSET_TYPE: + case FIXED_POINT_TYPE: if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_INITIALIZER), MIN (size, thissize), align, 0)) - error ("initializer for integer value is too complicated"); + error ("initializer for integer/fixed-point value is too complicated"); break; case REAL_TYPE: @@ -4128,8 +4452,12 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) link = TREE_VECTOR_CST_ELTS (exp); output_constant (TREE_VALUE (link), elt_size, align); + thissize = elt_size; while ((link = TREE_CHAIN (link)) != NULL) - output_constant (TREE_VALUE (link), elt_size, nalign); + { + output_constant (TREE_VALUE (link), elt_size, nalign); + thissize += elt_size; + } break; } default: @@ -4555,7 +4883,7 @@ merge_weak (tree newdecl, tree olddecl) /* 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 caught in + 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)) @@ -4673,7 +5001,7 @@ weak_finish (void) else if (! TREE_SYMBOL_REFERENCED (target)) { /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not - defined, otherwise we and weak_finish_1 would use a + defined, otherwise we and weak_finish_1 would use different macros. */ # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target)); @@ -4737,11 +5065,11 @@ weak_finish (void) static void globalize_decl (tree decl) { - const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) if (DECL_WEAK (decl)) { + const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); tree *p, t; #ifdef ASM_WEAKEN_DECL @@ -4773,12 +5101,9 @@ globalize_decl (tree decl) return; } -#elif defined(ASM_MAKE_LABEL_LINKONCE) - if (DECL_ONE_ONLY (decl)) - ASM_MAKE_LABEL_LINKONCE (asm_out_file, name); #endif - targetm.asm_out.globalize_label (asm_out_file, name); + targetm.asm_out.globalize_decl_name (asm_out_file, decl); } /* We have to be able to tell cgraph about the needed-ness of the target @@ -4804,17 +5129,17 @@ static tree find_decl_and_mark_needed (tree decl, tree target) { struct cgraph_node *fnode = NULL; - struct cgraph_varpool_node *vnode = NULL; + struct varpool_node *vnode = NULL; if (TREE_CODE (decl) == FUNCTION_DECL) { fnode = cgraph_node_for_asm (target); if (fnode == NULL) - vnode = cgraph_varpool_node_for_asm (target); + vnode = varpool_node_for_asm (target); } else { - vnode = cgraph_varpool_node_for_asm (target); + vnode = varpool_node_for_asm (target); if (vnode == NULL) fnode = cgraph_node_for_asm (target); } @@ -4832,7 +5157,7 @@ find_decl_and_mark_needed (tree decl, tree target) } else if (vnode) { - cgraph_varpool_mark_needed_node (vnode); + varpool_mark_needed_node (vnode); return vnode->decl; } else @@ -4856,6 +5181,14 @@ do_assemble_alias (tree decl, tree target) { 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); @@ -4873,6 +5206,14 @@ do_assemble_alias (tree decl, tree target) 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. */ @@ -5025,10 +5366,10 @@ assemble_alias (tree decl, tree target) if (TREE_CODE (decl) == FUNCTION_DECL) cgraph_node (decl)->alias = true; else - cgraph_varpool_node (decl)->alias = true; + varpool_node (decl)->alias = true; /* If the target has already been emitted, we don't have to queue the - alias. This saves a tad o memory. */ + alias. This saves a tad of memory. */ target_decl = find_decl_and_mark_needed (decl, target); if (target_decl && TREE_ASM_WRITTEN (target_decl)) do_assemble_alias (decl, target); @@ -5067,13 +5408,18 @@ default_assemble_visibility (tree decl, int vis) /* A helper function to call assemble_visibility when needed for a decl. */ -static void +int maybe_assemble_visibility (tree decl) { enum symbol_visibility vis = DECL_VISIBILITY (decl); if (vis != VISIBILITY_DEFAULT) - targetm.asm_out.visibility (decl, vis); + { + targetm.asm_out.visibility (decl, vis); + return 1; + } + else + return 0; } /* Returns 1 if the target configuration supports defining public symbols @@ -5191,7 +5537,7 @@ init_varasm_once (void) } enum tls_model -decl_default_tls_model (tree decl) +decl_default_tls_model (const_tree decl) { enum tls_model kind; bool is_local; @@ -5227,23 +5573,16 @@ decl_default_tls_model (tree decl) unsigned int default_section_type_flags (tree decl, const char *name, int reloc) { - return default_section_type_flags_1 (decl, name, reloc, flag_pic); -} - -unsigned int -default_section_type_flags_1 (tree decl, const char *name, int reloc, - int shlib) -{ unsigned int flags; if (decl && TREE_CODE (decl) == FUNCTION_DECL) flags = SECTION_CODE; - else if (decl && decl_readonly_section_1 (decl, reloc, shlib)) + else if (decl && decl_readonly_section (decl, reloc)) flags = 0; else if (current_function_decl && cfun - && cfun->unlikely_text_section_name - && strcmp (name, cfun->unlikely_text_section_name) == 0) + && 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) @@ -5438,7 +5777,7 @@ default_select_section (tree decl, int reloc, } enum section_category -categorize_decl_for_section (tree decl, int reloc, int shlib) +categorize_decl_for_section (const_tree decl, int reloc) { enum section_category ret; @@ -5459,17 +5798,17 @@ categorize_decl_for_section (tree decl, int reloc, int shlib) || TREE_SIDE_EFFECTS (decl) || ! TREE_CONSTANT (DECL_INITIAL (decl))) { - if (shlib && (reloc & 2)) - ret = SECCAT_DATA_REL; - else if (shlib && reloc) - ret = SECCAT_DATA_REL_LOCAL; + /* Here the reloc_rw_mask is not testing whether the section should + be read-only or not, but whether the dynamic link will have to + do something. If so, we wish to segregate the data in order to + minimize cache misses inside the dynamic linker. */ + if (reloc & targetm.asm_out.reloc_rw_mask ()) + ret = reloc == 1 ? SECCAT_DATA_REL_LOCAL : SECCAT_DATA_REL; else ret = SECCAT_DATA; } - else if (shlib && (reloc & 2)) - ret = SECCAT_DATA_REL_RO; - else if (shlib && reloc) - ret = SECCAT_DATA_REL_RO_LOCAL; + else if (reloc & targetm.asm_out.reloc_rw_mask ()) + ret = reloc == 1 ? SECCAT_DATA_REL_RO_LOCAL : SECCAT_DATA_REL_RO; else if (reloc || flag_merge_constants < 2) /* C and C++ don't allow different variables to share the same location. -fmerge-all-constants allows even that (at the @@ -5482,7 +5821,7 @@ categorize_decl_for_section (tree decl, int reloc, int shlib) } else if (TREE_CODE (decl) == CONSTRUCTOR) { - if ((shlib && reloc) + if ((reloc & targetm.asm_out.reloc_rw_mask ()) || TREE_SIDE_EFFECTS (decl) || ! TREE_CONSTANT (decl)) ret = SECCAT_DATA; @@ -5493,13 +5832,26 @@ categorize_decl_for_section (tree decl, int reloc, int shlib) ret = SECCAT_RODATA; /* There are no read-only thread-local sections. */ - if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) + if (TREE_CODE (decl) == VAR_DECL && DECL_TLS_MODEL (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. */ - if (ret == SECCAT_BSS - || (flag_zero_initialized_in_bss - && initializer_zerop (DECL_INITIAL (decl)))) + else if (ret == SECCAT_BSS + || (flag_zero_initialized_in_bss + && initializer_zerop (DECL_INITIAL (decl)))) ret = SECCAT_TBSS; else ret = SECCAT_TDATA; @@ -5520,15 +5872,9 @@ categorize_decl_for_section (tree decl, int reloc, int shlib) } bool -decl_readonly_section (tree decl, int reloc) -{ - return decl_readonly_section_1 (decl, reloc, flag_pic); -} - -bool -decl_readonly_section_1 (tree decl, int reloc, int shlib) +decl_readonly_section (const_tree decl, int reloc) { - switch (categorize_decl_for_section (decl, reloc, shlib)) + switch (categorize_decl_for_section (decl, reloc)) { case SECCAT_RODATA: case SECCAT_RODATA_MERGE_STR: @@ -5549,15 +5895,8 @@ section * default_elf_select_section (tree decl, int reloc, unsigned HOST_WIDE_INT align) { - return default_elf_select_section_1 (decl, reloc, align, flag_pic); -} - -section * -default_elf_select_section_1 (tree decl, int reloc, - unsigned HOST_WIDE_INT align, int shlib) -{ const char *sname; - switch (categorize_decl_for_section (decl, reloc, shlib)) + switch (categorize_decl_for_section (decl, reloc)) { case SECCAT_TEXT: /* We're not supposed to be called on FUNCTION_DECLs. */ @@ -5604,6 +5943,12 @@ default_elf_select_section_1 (tree decl, int reloc, 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 (); } @@ -5619,77 +5964,119 @@ default_elf_select_section_1 (tree decl, int reloc, void default_unique_section (tree decl, int reloc) { - default_unique_section_1 (decl, reloc, flag_pic); -} - -void -default_unique_section_1 (tree decl, int reloc, int shlib) -{ /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */ bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP; - const char *prefix, *name; - size_t nlen, plen; + const char *prefix, *name, *linkonce; char *string; - switch (categorize_decl_for_section (decl, reloc, shlib)) + switch (categorize_decl_for_section (decl, reloc)) { case SECCAT_TEXT: - prefix = one_only ? ".gnu.linkonce.t." : ".text."; + prefix = one_only ? ".t" : ".text"; break; case SECCAT_RODATA: case SECCAT_RODATA_MERGE_STR: case SECCAT_RODATA_MERGE_STR_INIT: case SECCAT_RODATA_MERGE_CONST: - prefix = one_only ? ".gnu.linkonce.r." : ".rodata."; + prefix = one_only ? ".r" : ".rodata"; break; case SECCAT_SRODATA: - prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2."; + prefix = one_only ? ".s2" : ".sdata2"; break; case SECCAT_DATA: - prefix = one_only ? ".gnu.linkonce.d." : ".data."; + prefix = one_only ? ".d" : ".data"; break; case SECCAT_DATA_REL: - prefix = one_only ? ".gnu.linkonce.d.rel." : ".data.rel."; + prefix = one_only ? ".d.rel" : ".data.rel"; break; case SECCAT_DATA_REL_LOCAL: - prefix = one_only ? ".gnu.linkonce.d.rel.local." : ".data.rel.local."; + prefix = one_only ? ".d.rel.local" : ".data.rel.local"; break; case SECCAT_DATA_REL_RO: - prefix = one_only ? ".gnu.linkonce.d.rel.ro." : ".data.rel.ro."; + prefix = one_only ? ".d.rel.ro" : ".data.rel.ro"; break; case SECCAT_DATA_REL_RO_LOCAL: - prefix = one_only ? ".gnu.linkonce.d.rel.ro.local." - : ".data.rel.ro.local."; + prefix = one_only ? ".d.rel.ro.local" : ".data.rel.ro.local"; break; case SECCAT_SDATA: - prefix = one_only ? ".gnu.linkonce.s." : ".sdata."; + prefix = one_only ? ".s" : ".sdata"; break; case SECCAT_BSS: - prefix = one_only ? ".gnu.linkonce.b." : ".bss."; + prefix = one_only ? ".b" : ".bss"; break; case SECCAT_SBSS: - prefix = one_only ? ".gnu.linkonce.sb." : ".sbss."; + prefix = one_only ? ".sb" : ".sbss"; break; case SECCAT_TDATA: - prefix = one_only ? ".gnu.linkonce.td." : ".tdata."; + prefix = one_only ? ".td" : ".tdata"; break; case SECCAT_TBSS: - prefix = one_only ? ".gnu.linkonce.tb." : ".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 (); } - plen = strlen (prefix); name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); name = targetm.strip_name_encoding (name); - nlen = strlen (name); - string = alloca (nlen + plen + 1); - memcpy (string, prefix, plen); - memcpy (string + plen, name, nlen + 1); + /* 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); +} + +/* Like compute_reloc_for_constant, except for an RTX. The return value + is a mask for which bit 1 indicates a global relocation, and bit 0 + indicates a local relocation. */ + +static int +compute_reloc_for_rtx_1 (rtx *xp, void *data) +{ + int *preloc = data; + rtx x = *xp; + + switch (GET_CODE (x)) + { + case SYMBOL_REF: + *preloc |= SYMBOL_REF_LOCAL_P (x) ? 1 : 2; + break; + case LABEL_REF: + *preloc |= 1; + break; + default: + break; + } + + return 0; +} + +static int +compute_reloc_for_rtx (rtx x) +{ + int reloc; + + switch (GET_CODE (x)) + { + case CONST: + case SYMBOL_REF: + case LABEL_REF: + reloc = 0; + for_each_rtx (&x, compute_reloc_for_rtx_1, &reloc); + return reloc; - DECL_SECTION_NAME (decl) = build_string (nlen + plen, string); + default: + return 0; + } } section * @@ -5697,40 +6084,27 @@ default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x, unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED) { - if (flag_pic) - switch (GET_CODE (x)) - { - case CONST: - case SYMBOL_REF: - case LABEL_REF: - return data_section; - - default: - break; - } - - return readonly_data_section; + if (compute_reloc_for_rtx (x) & targetm.asm_out.reloc_rw_mask ()) + return data_section; + else + return readonly_data_section; } section * default_elf_select_rtx_section (enum machine_mode mode, rtx x, unsigned HOST_WIDE_INT align) { - /* ??? Handle small data here somehow. */ + int reloc = compute_reloc_for_rtx (x); - if (flag_pic) - switch (GET_CODE (x)) - { - case CONST: - case SYMBOL_REF: - return get_named_section (NULL, ".data.rel.ro", 3); + /* ??? Handle small data here somehow. */ - case LABEL_REF: + if (reloc & targetm.asm_out.reloc_rw_mask ()) + { + if (reloc == 1) return get_named_section (NULL, ".data.rel.ro.local", 1); - - default: - break; - } + else + return get_named_section (NULL, ".data.rel.ro", 3); + } return mergeable_constant_section (mode, align, 0); } @@ -5755,7 +6129,8 @@ default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED) 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)) + if (targetm.have_tls && 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; @@ -5786,7 +6161,7 @@ default_asm_output_anchor (rtx symbol) { char buffer[100]; - sprintf (buffer, ". + " HOST_WIDE_INT_PRINT_DEC, + sprintf (buffer, "*. + " HOST_WIDE_INT_PRINT_DEC, SYMBOL_REF_BLOCK_OFFSET (symbol)); ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer); } @@ -5795,7 +6170,7 @@ default_asm_output_anchor (rtx symbol) /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */ bool -default_use_anchors_for_symbol_p (rtx symbol) +default_use_anchors_for_symbol_p (const_rtx symbol) { section *sect; tree decl; @@ -5834,13 +6209,13 @@ default_use_anchors_for_symbol_p (rtx symbol) wrt cross-module name binding. */ bool -default_binds_local_p (tree exp) +default_binds_local_p (const_tree exp) { return default_binds_local_p_1 (exp, flag_shlib); } bool -default_binds_local_p_1 (tree exp, int shlib) +default_binds_local_p_1 (const_tree exp, int shlib) { bool local_p; @@ -5871,9 +6246,10 @@ default_binds_local_p_1 (tree exp, int shlib) else if (DECL_WEAK (exp)) local_p = false; /* If PIC, then assume that any global name can be overridden by - symbols resolved from other modules. */ + symbols resolved from other modules, unless we are compiling with + -fwhole-program, which assumes that names are local. */ else if (shlib) - local_p = false; + local_p = flag_whole_program; /* Uninitialized COMMON variable may be unified with symbols resolved from other modules. */ else if (DECL_COMMON (exp) @@ -5909,6 +6285,14 @@ default_globalize_label (FILE * stream, const char *name) } #endif /* GLOBAL_ASM_OP */ +/* Default function to output code that will globalize a declaration. */ +void +default_globalize_decl_name (FILE * stream, tree decl) +{ + const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); + targetm.asm_out.globalize_label (stream, name); +} + /* Default function to output a label for unwind information. The default is to do nothing. A target that needs nonlocal labels for unwind information must provide its own function to do this. */ @@ -5996,10 +6380,10 @@ switch_to_section (section *new_section) { case SECTION_NAMED: if (cfun - && !cfun->unlikely_text_section_name + && !crtl->subsections.unlikely_text_section_name && strcmp (new_section->named.name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0) - cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; + 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, @@ -6222,4 +6606,120 @@ output_object_blocks (void) htab_traverse (object_block_htab, output_object_block_htab, NULL); } +/* This function provides a possible implementation of the + TARGET_ASM_RECORD_GCC_SWITCHES target hook for ELF targets. When triggered + by -frecord-gcc-switches it creates a new mergeable, string section in the + assembler output file called TARGET_ASM_RECORD_GCC_SWITCHES_SECTION which + contains the switches in ASCII format. + + FIXME: This code does not correctly handle double quote characters + that appear inside strings, (it strips them rather than preserving them). + FIXME: ASM_OUTPUT_ASCII, as defined in config/elfos.h will not emit NUL + characters - instead it treats them as sub-string separators. Since + we want to emit NUL strings terminators into the object file we have to use + ASM_OUTPUT_SKIP. */ + +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; + } + break; + + case SWITCH_TYPE_DESCRIPTIVE: + if (name == NULL) + { + /* 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 + { + section * sec; + + sec = get_section (targetm.asm_out.record_gcc_switches_section, + SECTION_DEBUG + | SECTION_MERGE + | SECTION_STRINGS + | (SECTION_ENTSIZE & 1), + NULL); + switch_to_section (sec); + started = true; + } + } + + default: + break; + } + + /* The return value is currently ignored by the caller, but must be 0. + For -fverbose-asm the return value would be the number of characters + emitted into the assembler file. */ + return 0; +} + +/* Emit text to declare externally defined symbols. It is needed to + properly support non-default visibility. */ +void +default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED, + tree decl, + const char *name ATTRIBUTE_UNUSED) +{ + /* We output the name if and only if TREE_SYMBOL_REFERENCED is + set in order to avoid putting out names that are never really + used. */ + if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) + && targetm.binds_local_p (decl)) + maybe_assemble_visibility (decl); +} + #include "gt-varasm.h"