OSDN Git Service

* tree.h: Declare make_decl_rtl_for_debug.
authoraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 18 Mar 2010 20:41:40 +0000 (20:41 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 00:29:25 +0000 (09:29 +0900)
* varasm.c (make_decl_rtl_for_debug): New.
* dwarf2out.c (rtl_for_decl_location): Call it.
* cfgexpand.c (expand_debug_expr): Call it.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@157551 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/varasm.c

index 527a9c3..018d94c 100644 (file)
@@ -1,3 +1,10 @@
+2010-03-18  Aldy Hernandez  <aldyh@redhat.com>
+
+       * tree.h: Declare make_decl_rtl_for_debug.
+       * varasm.c (make_decl_rtl_for_debug): New.
+       * dwarf2out.c (rtl_for_decl_location): Call it.
+       * cfgexpand.c (expand_debug_expr): Call it.
+
 2010-03-18  Jakub Jelinek  <jakub@redhat.com>
 
        PR bootstrap/43399
index ef02994..31007b8 100644 (file)
@@ -38,6 +38,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "expr.h"
 #include "hard-reg-set.h"
 #include "regs.h"
+#include "real.h"
 #include "output.h"
 #include "toplev.h"
 #include "hashtab.h"
@@ -169,9 +170,11 @@ 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;
@@ -364,7 +367,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 = IDENTIFIER_HASH_VALUE (name);
+  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;
@@ -402,8 +405,6 @@ 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);
@@ -1355,14 +1356,6 @@ 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
@@ -1442,19 +1435,16 @@ 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
-      && DECL_COMMON (decl))
-    DECL_COMMON (decl) = 0;
+  gcc_assert (!(TREE_CODE (decl) == VAR_DECL
+             && DECL_SECTION_NAME (decl) != NULL_TREE
+             && DECL_INITIAL (decl) == NULL_TREE
+             && DECL_COMMON (decl))
+             || !DECL_COMMON (decl));
 
   /* Variables can't be both common and weak.  */
-  if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
-    DECL_COMMON (decl) = 0;
+  gcc_assert (TREE_CODE (decl) != VAR_DECL
+             || !DECL_WEAK (decl)
+             || !DECL_COMMON (decl));
 
   if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
     x = create_block_symbol (name, get_block_for_decl (decl), -1);
@@ -1494,7 +1484,7 @@ make_decl_rtl (tree decl)
 rtx
 make_decl_rtl_for_debug (tree decl)
 {
-  unsigned int save_aliasing_flag, save_mudflap_flag;
+  unsigned int save_aliasing_flag;
   rtx rtl;
 
   if (DECL_RTL_SET_P (decl))
@@ -1505,12 +1495,9 @@ make_decl_rtl_for_debug (tree decl)
      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.  */
+     new set.  */
   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
@@ -1518,7 +1505,6 @@ make_decl_rtl_for_debug (tree decl)
   SET_DECL_RTL (decl, NULL);
 
   flag_strict_aliasing = save_aliasing_flag;
-  flag_mudflap = save_mudflap_flag;
 
   return rtl;
 }
@@ -2207,6 +2193,8 @@ 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))
     {
@@ -2217,19 +2205,6 @@ 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);
@@ -2810,6 +2785,7 @@ 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);
@@ -2821,11 +2797,6 @@ 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;
     }
@@ -2866,6 +2837,7 @@ 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.  */
@@ -2917,18 +2889,6 @@ 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;
@@ -3057,27 +3017,6 @@ 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;
@@ -3138,34 +3077,11 @@ 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);
-
-       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;
+       return (value1.offset == value2.offset
+               && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
       }
 
     case PLUS_EXPR:
@@ -3226,10 +3142,6 @@ 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);
@@ -3254,14 +3166,31 @@ copy_constant (tree 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, unsigned int align)
+get_constant_section (tree exp)
 {
-  return targetm.asm_out.select_section (exp,
-                                        compute_reloc_for_constant (exp),
-                                        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 the size of constant EXP in bytes.  */
@@ -3287,11 +3216,11 @@ get_constant_size (tree exp)
 static struct constant_descriptor_tree *
 build_constant_desc (tree exp)
 {
-  struct constant_descriptor_tree *desc;
-  rtx symbol, rtl;
+  rtx symbol;
+  rtx rtl;
   char label[256];
   int labelno;
-  tree decl;
+  struct constant_descriptor_tree *desc;
 
   desc = GGC_NEW (struct constant_descriptor_tree);
   desc->value = copy_constant (exp);
@@ -3304,41 +3233,17 @@ build_constant_desc (tree exp)
   labelno = const_labelno++;
   ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
 
-  /* 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.  */
+  /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
   if (use_object_blocks_p ())
     {
-      section *sect = get_constant_section (exp, DECL_ALIGN (decl));
+      section *sect = get_constant_section (exp);
       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, decl);
+  SET_SYMBOL_REF_DECL (symbol, desc->value);
   TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
 
   rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
@@ -3355,6 +3260,7 @@ 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;
@@ -3461,8 +3367,7 @@ assemble_constant_contents (tree exp, const char *label, unsigned int align)
 static void
 output_constant_def_contents (rtx symbol)
 {
-  tree decl = SYMBOL_REF_DECL (symbol);
-  tree exp = DECL_INITIAL (decl);
+  tree exp = SYMBOL_REF_DECL (symbol);
   unsigned int align;
 
   /* Make sure any other constants whose addresses appear in EXP
@@ -3479,8 +3384,8 @@ output_constant_def_contents (rtx symbol)
     place_block_symbol (symbol);
   else
     {
-      align = DECL_ALIGN (decl);
-      switch_to_section (get_constant_section (exp, align));
+      switch_to_section (get_constant_section (exp));
+      align = get_constant_alignment (exp);
       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);
@@ -3505,37 +3410,6 @@ 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;
-}
 \f
 /* Used in the hash tables to avoid outputting the same constant
    twice.  Unlike 'struct constant_descriptor_tree', RTX constants
@@ -4005,8 +3879,8 @@ mark_constant (rtx *current_rtx, void *data ATTRIBUTE_UNUSED)
     }
   else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
     {
-      tree decl = SYMBOL_REF_DECL (x);
-      if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl)))
+      tree exp = SYMBOL_REF_DECL (x);
+      if (!TREE_ASM_WRITTEN (exp))
        {
          n_deferred_constants--;
          output_constant_def_contents (x);
@@ -5651,7 +5525,6 @@ 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
@@ -5923,10 +5796,8 @@ assemble_alias (tree decl, tree target)
    the visibility type VIS, which must not be VISIBILITY_DEFAULT.  */
 
 void
-default_assemble_visibility (tree decl ATTRIBUTE_UNUSED, 
-                            int vis ATTRIBUTE_UNUSED)
+default_assemble_visibility (tree decl, int vis)
 {
-#ifdef HAVE_GAS_HIDDEN
   static const char * const visibility_types[] = {
     NULL, "protected", "hidden", "internal"
   };
@@ -5936,6 +5807,7 @@ default_assemble_visibility (tree decl ATTRIBUTE_UNUSED,
   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");
@@ -6191,10 +6063,6 @@ 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)
@@ -6225,7 +6093,7 @@ default_elf_asm_named_section (const char *name, unsigned int flags,
   if (flags & SECTION_STRINGS)
     *f++ = 'S';
   if (flags & SECTION_TLS)
-    *f++ = TLS_SECTION_ASM_FLAG;
+    *f++ = 'T';
   if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
     *f++ = 'G';
   *f = '\0';
@@ -6969,8 +6837,8 @@ place_block_symbol (rtx symbol)
   else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
     {
       decl = SYMBOL_REF_DECL (symbol);
-      alignment = DECL_ALIGN (decl);
-      size = get_constant_size (DECL_INITIAL (decl));
+      alignment = get_constant_alignment (decl);
+      size = get_constant_size (decl);
     }
   else
     {
@@ -7116,9 +6984,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_INITIAL (decl), XSTR (symbol, 0),
-                                     DECL_ALIGN (decl));
-         offset += get_constant_size (DECL_INITIAL (decl));
+         assemble_constant_contents (decl, XSTR (symbol, 0),
+                                     get_constant_alignment (decl));
+         offset += get_constant_size (decl);
        }
       else
        {
@@ -7263,31 +7131,4 @@ 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"