X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fvarasm.c;h=701847c45db389621c6bb9b61e7a9b6a018b3009;hp=310647e7e2b43e57cf065965a1468d95e058f97b;hb=83e170dfd44c597e8432d9cbb798819a4bfbb287;hpb=13ceb2c06e90bf49cc692e3d8a1844509b33483d diff --git a/gcc/varasm.c b/gcc/varasm.c index 310647e7e2b..701847c45db 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -170,11 +170,9 @@ bool in_cold_section_p; 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; @@ -367,7 +365,7 @@ emutls_decl (tree 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.hash = IDENTIFIER_HASH_VALUE (name); in.base.from = decl; loc = htab_find_slot_with_hash (emutls_htab, &in, in.hash, INSERT); h = (struct tree_map *) *loc; @@ -405,6 +403,8 @@ emutls_decl (tree decl) int foo() { return i; } __thread int i = 1; in which I goes from external to locally defined and initialized. */ + DECL_DLLIMPORT_P (to) = DECL_DLLIMPORT_P (decl); + DECL_ATTRIBUTES (to) = targetm.merge_decl_attributes (decl, to); TREE_STATIC (to) = TREE_STATIC (decl); TREE_USED (to) = TREE_USED (decl); @@ -1174,12 +1174,13 @@ get_variable_section (tree decl, bool prefer_noswitch_p) if (TREE_TYPE (decl) != error_mark_node) as = TYPE_ADDR_SPACE (TREE_TYPE (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. */ - if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL - && ADDR_SPACE_GENERIC_P (as)) + 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 @@ -1355,6 +1356,14 @@ make_decl_rtl (tree decl) 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 @@ -1434,6 +1443,10 @@ make_decl_rtl (tree decl) /* 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 @@ -1474,6 +1487,42 @@ make_decl_rtl (tree 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; +} /* Output a string of literal assembler code for an `asm' keyword used between functions. */ @@ -2159,8 +2208,6 @@ assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, if (flag_syntax_only) return; - app_disable (); - if (! dont_output_data && ! host_integerp (DECL_SIZE_UNIT (decl), 1)) { @@ -2171,6 +2218,19 @@ assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, 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); @@ -2751,7 +2811,6 @@ decode_addr_const (tree exp, struct addr_const *value) { 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); @@ -2763,6 +2822,11 @@ decode_addr_const (tree exp, struct addr_const *value) * tree_low_cst (TREE_OPERAND (target, 1), 0)); target = TREE_OPERAND (target, 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; } @@ -2803,7 +2867,6 @@ decode_addr_const (tree exp, struct addr_const *value) 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. */ @@ -2855,6 +2918,18 @@ const_hash_1 (const tree exp) 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; @@ -2983,6 +3058,27 @@ compare_constant (const tree t1, const tree t2) 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; @@ -3043,11 +3139,34 @@ compare_constant (const tree t1, const tree t2) 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: @@ -3108,6 +3227,10 @@ copy_constant (tree exp) 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); @@ -3132,31 +3255,14 @@ copy_constant (tree exp) } } -/* 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. */ @@ -3182,11 +3288,11 @@ get_constant_size (tree exp) 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->value = copy_constant (exp); @@ -3199,17 +3305,41 @@ build_constant_desc (tree exp) 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); @@ -3226,7 +3356,6 @@ build_constant_desc (tree exp) 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; @@ -3333,7 +3462,8 @@ assemble_constant_contents (tree exp, const char *label, unsigned int 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 @@ -3350,8 +3480,8 @@ output_constant_def_contents (rtx symbol) 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); @@ -3376,6 +3506,37 @@ lookup_constant_def (tree exp) 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); + + 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; +} /* Used in the hash tables to avoid outputting the same constant twice. Unlike 'struct constant_descriptor_tree', RTX constants @@ -3845,8 +4006,8 @@ mark_constant (rtx *current_rtx, void *data ATTRIBUTE_UNUSED) } 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); @@ -5491,6 +5652,7 @@ find_decl_and_mark_needed (tree decl, tree target) else if (vnode) { varpool_mark_needed_node (vnode); + vnode->force_output = 1; return vnode->decl; } else @@ -5507,6 +5669,10 @@ do_assemble_alias (tree decl, tree target) 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; @@ -5724,10 +5890,6 @@ assemble_alias (tree decl, tree target) # endif #endif } - - /* 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; /* A quirk of the initial implementation of aliases required that the user @@ -5762,8 +5924,10 @@ assemble_alias (tree decl, tree target) 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" }; @@ -5773,7 +5937,6 @@ default_assemble_visibility (tree decl, int vis) 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"); @@ -6029,6 +6192,10 @@ default_no_named_section (const char *name ATTRIBUTE_UNUSED, 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) @@ -6059,7 +6226,7 @@ default_elf_asm_named_section (const char *name, unsigned int flags, 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'; @@ -6803,8 +6970,8 @@ place_block_symbol (rtx symbol) 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 { @@ -6950,9 +7117,9 @@ output_object_block (struct object_block *block) 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 { @@ -7097,4 +7264,31 @@ default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED, maybe_assemble_visibility (decl); } +/* 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; +} + #include "gt-varasm.h"