OSDN Git Service

2010-04-26 Richard Guenther <rguenther@suse.de>
authorrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 26 Apr 2010 09:13:00 +0000 (09:13 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 04:49:27 +0000 (13:49 +0900)
PR lto/42425
* tree.c (free_lang_data_in_type): Do not free TYPE_CONTEXT
if emitting debug information and it is either a function
or a namespace decl.

* g++.dg/lto/20100423-2_0.C: New testcase.

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

gcc/ChangeLog
gcc/testsuite/ChangeLog
gcc/tree.c

index 3b4ed3c..54ad269 100644 (file)
@@ -1,3 +1,10 @@
+2010-04-26  Richard Guenther  <rguenther@suse.de>
+
+       PR lto/42425
+       * tree.c (free_lang_data_in_type): Do not free TYPE_CONTEXT
+       if emitting debug information and it is either a function
+       or a namespace decl.
+
 2010-04-26  Ira Rosen  <irar@il.ibm.com>
 
        * tree-vectorizer.h (struct _stmt_vec_info): Add new field to 
index badf910..e041658 100644 (file)
@@ -1,3 +1,8 @@
+2010-04-26  Richard Guenther  <rguenther@suse.de>
+
+       PR lto/42425
+       * g++.dg/lto/20100423-2_0.C: New testcase.
+
 2010-04-26  Ira Rosen  <irar@il.ibm.com>
 
        * gcc.dg/vect/bb-slp-23.c: New test.
index cc4a2d6..8eeecff 100644 (file)
@@ -35,6 +35,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "tm.h"
 #include "flags.h"
 #include "tree.h"
+#include "real.h"
 #include "tm_p.h"
 #include "function.h"
 #include "obstack.h"
@@ -50,11 +51,10 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-flow.h"
 #include "params.h"
 #include "pointer-set.h"
+#include "fixed-value.h"
 #include "tree-pass.h"
 #include "langhooks-def.h"
 #include "diagnostic.h"
-#include "tree-diagnostic.h"
-#include "tree-pretty-print.h"
 #include "cgraph.h"
 #include "timevar.h"
 #include "except.h"
@@ -1041,6 +1041,14 @@ build_int_cst (tree type, HOST_WIDE_INT low)
   return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
 }
 
+/* Create an INT_CST node with a LOW value zero extended.  */
+
+tree
+build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
+{
+  return build_int_cst_wide (type, low, 0);
+}
+
 /* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
    if it is negative.  This function is similar to build_int_cst, but
    the extra bits outside of the type precision are cleared.  Constants
@@ -1063,37 +1071,15 @@ build_int_cst_type (tree type, HOST_WIDE_INT low)
   return build_int_cst_wide (type, low1, hi);
 }
 
-/* Constructs tree in type TYPE from with value given by CST.  Signedness
-   of CST is assumed to be the same as the signedness of TYPE.  */
+/* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
+   and sign extended according to the value range of TYPE.  */
 
 tree
-double_int_to_tree (tree type, double_int cst)
+build_int_cst_wide_type (tree type,
+                        unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
 {
-  /* Size types *are* sign extended.  */
-  bool sign_extended_type = (!TYPE_UNSIGNED (type)
-                            || (TREE_CODE (type) == INTEGER_TYPE
-                                && TYPE_IS_SIZETYPE (type)));
-
-  cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
-
-  return build_int_cst_wide (type, cst.low, cst.high);
-}
-
-/* Returns true if CST fits into range of TYPE.  Signedness of CST is assumed
-   to be the same as the signedness of TYPE.  */
-
-bool
-double_int_fits_to_tree_p (const_tree type, double_int cst)
-{
-  /* Size types *are* sign extended.  */
-  bool sign_extended_type = (!TYPE_UNSIGNED (type)
-                            || (TREE_CODE (type) == INTEGER_TYPE
-                                && TYPE_IS_SIZETYPE (type)));
-
-  double_int ext
-    = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
-
-  return double_int_equal_p (cst, ext);
+  fit_double_type (low, high, &low, &high, type);
+  return build_int_cst_wide (type, low, high);
 }
 
 /* These are the hash table functions for the hash table of INTEGER_CST
@@ -1322,22 +1308,8 @@ tree
 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
 {
   tree c = make_node (CONSTRUCTOR);
-  unsigned int i;
-  constructor_elt *elt;
-  bool constant_p = true;
-
   TREE_TYPE (c) = type;
   CONSTRUCTOR_ELTS (c) = vals;
-
-  for (i = 0; VEC_iterate (constructor_elt, vals, i, elt); i++)
-    if (!TREE_CONSTANT (elt->value))
-      {
-       constant_p = false;
-       break;
-      }
-
-  TREE_CONSTANT (c) = constant_p;
-
   return c;
 }
 
@@ -1348,13 +1320,16 @@ build_constructor_single (tree type, tree index, tree value)
 {
   VEC(constructor_elt,gc) *v;
   constructor_elt *elt;
+  tree t;
 
   v = VEC_alloc (constructor_elt, gc, 1);
   elt = VEC_quick_push (constructor_elt, v, NULL);
   elt->index = index;
   elt->value = value;
 
-  return build_constructor (type, v);
+  t = build_constructor (type, v);
+  TREE_CONSTANT (t) = TREE_CONSTANT (value);
+  return t;
 }
 
 
@@ -1363,17 +1338,27 @@ build_constructor_single (tree type, tree index, tree value)
 tree
 build_constructor_from_list (tree type, tree vals)
 {
-  tree t;
+  tree t, val;
   VEC(constructor_elt,gc) *v = NULL;
+  bool constant_p = true;
 
   if (vals)
     {
       v = VEC_alloc (constructor_elt, gc, list_length (vals));
       for (t = vals; t; t = TREE_CHAIN (t))
-       CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
+       {
+         constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
+         val = TREE_VALUE (t);
+         elt->index = TREE_PURPOSE (t);
+         elt->value = val;
+         if (!TREE_CONSTANT (val))
+           constant_p = false;
+       }
     }
 
-  return build_constructor (type, v);
+  t = build_constructor (type, v);
+  TREE_CONSTANT (t) = constant_p;
+  return t;
 }
 
 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
@@ -2114,6 +2099,25 @@ tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
   return node;
 }
 
+/* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
+
+tree
+ctor_to_list (tree ctor)
+{
+  tree list = NULL_TREE;
+  tree *p = &list;
+  unsigned ix;
+  tree purpose, val;
+
+  FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
+    {
+      *p = build_tree_list (purpose, val);
+      p = &TREE_CHAIN (*p);
+    }
+
+  return list;
+}
+
 /* Return the values of the elements of a CONSTRUCTOR as a vector of
    trees.  */
 
@@ -4146,26 +4150,6 @@ build_type_attribute_variant (tree ttype, tree attribute)
 }
 
 
-/* Reset the expression *EXPR_P, a size or position.
-
-   ??? We could reset all non-constant sizes or positions.  But it's cheap
-   enough to not do so and refrain from adding workarounds to dwarf2out.c.
-
-   We need to reset self-referential sizes or positions because they cannot
-   be gimplified and thus can contain a CALL_EXPR after the gimplification
-   is finished, which will run afoul of LTO streaming.  And they need to be
-   reset to something essentially dummy but not constant, so as to preserve
-   the properties of the object they are attached to.  */
-
-static inline void
-free_lang_data_in_one_sizepos (tree *expr_p)
-{
-  tree expr = *expr_p;
-  if (CONTAINS_PLACEHOLDER_P (expr))
-    *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
-}
-
-
 /* Reset all the fields in a binfo node BINFO.  We only keep
    BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
 
@@ -4272,19 +4256,8 @@ free_lang_data_in_type (tree type)
       /* For non-aggregate types, clear out the language slot (which
         overloads TYPE_BINFO).  */
       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
-
-      if (INTEGRAL_TYPE_P (type)
-         || SCALAR_FLOAT_TYPE_P (type)
-         || FIXED_POINT_TYPE_P (type))
-       {
-         free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
-         free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
-       }
     }
 
-  free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
-  free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
-
   if (debug_info_level < DINFO_LEVEL_TERSE
       || (TYPE_CONTEXT (type)
          && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
@@ -4420,10 +4393,9 @@ free_lang_data_in_decl (tree decl)
        }
    }
 
-  free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
-  free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
-  if (TREE_CODE (decl) == FIELD_DECL)
-    free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
+ /* ???  We could free non-constant DECL_SIZE, DECL_SIZE_UNIT
+    and DECL_FIELD_OFFSET.  But it's cheap enough to not do
+    that and refrain from adding workarounds to dwarf2out.c  */
 
  /* DECL_FCONTEXT is only used for debug info generation.  */
  if (TREE_CODE (decl) == FIELD_DECL
@@ -4637,10 +4609,6 @@ find_decls_types_r (tree *tp, int *ws, void *data)
          fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
        }
 
-      if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
-         && DECL_HAS_VALUE_EXPR_P (t))
-       fld_worklist_push (DECL_VALUE_EXPR (t), fld);
-
       if (TREE_CODE (t) != FIELD_DECL)
        fld_worklist_push (TREE_CHAIN (t), fld);
       *ws = 0;
@@ -4702,15 +4670,6 @@ find_decls_types_r (tree *tp, int *ws, void *data)
       fld_worklist_push (TREE_CHAIN (t), fld);
       *ws = 0;
     }
-  else if (TREE_CODE (t) == BLOCK)
-    {
-      tree tem;
-      for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
-       fld_worklist_push (tem, fld);
-      for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
-       fld_worklist_push (tem, fld);
-      fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
-    }
 
   fld_worklist_push (TREE_TYPE (t), fld);
 
@@ -5019,9 +4978,10 @@ free_lang_data (void)
   lang_hooks.dwarf_name = lhd_dwarf_name;
   lang_hooks.decl_printable_name = gimple_decl_printable_name;
   lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
+  lang_hooks.fold_obj_type_ref = gimple_fold_obj_type_ref;
 
   /* Reset diagnostic machinery.  */
-  diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
+  diagnostic_starter (global_dc) = default_diagnostic_starter;
   diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
   diagnostic_format_decoder (global_dc) = default_tree_printer;
 
@@ -6607,12 +6567,11 @@ iterative_hash_expr (const_tree t, hashval_t val)
       return iterative_hash_expr (TREE_IMAGPART (t), val);
     case VECTOR_CST:
       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
+
     case SSA_NAME:
-      /* We can just compare by pointer.  */
+      /* we can just compare by pointer.  */
       return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
-    case PLACEHOLDER_EXPR:
-      /* The node itself doesn't matter.  */
-      return val;
+
     case TREE_LIST:
       /* A list of expressions, for a CALL_EXPR or as the elements of a
         VECTOR_CST.  */
@@ -7290,7 +7249,7 @@ build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
 
    Arguments from DECL_ARGUMENTS list can't be removed now, since they are
-   linked by TREE_CHAIN directly.  The caller is responsible for eliminating
+   linked by TREE_CHAIN directly.  It is caller responsibility to eliminate
    them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
 
 tree
@@ -7312,8 +7271,8 @@ build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
 }
 
 /* Build a function type.  The RETURN_TYPE is the type returned by the
-   function.  If VAARGS is set, no void_type_node is appended to the
-   the list.  ARGP must be always be terminated be a NULL_TREE.  */
+   function. If VAARGS is set, no void_type_node is appended to the
+   the list. ARGP muse be alway be terminated be a NULL_TREE.  */
 
 static tree
 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
@@ -7329,7 +7288,7 @@ build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
       last = args;
       if (args != NULL_TREE)
        args = nreverse (args);
-      gcc_assert (last != void_list_node);
+      gcc_assert (args != NULL_TREE && last != void_list_node);
     }
   else if (args == NULL_TREE)
     args = void_list_node;
@@ -7977,8 +7936,7 @@ bool
 auto_var_in_fn_p (const_tree var, const_tree fn)
 {
   return (DECL_P (var) && DECL_CONTEXT (var) == fn
-         && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
-               || TREE_CODE (var) == PARM_DECL)
+         && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
               && ! TREE_STATIC (var))
              || TREE_CODE (var) == LABEL_DECL
              || TREE_CODE (var) == RESULT_DECL));
@@ -9082,13 +9040,10 @@ build_common_builtin_nodes (void)
       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
       ftype = build_function_type (ptr_type_node, tmp);
       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
-                           "alloca", ECF_MALLOC | ECF_NOTHROW);
+                           "alloca",
+                           ECF_MALLOC | (flag_stack_check ? 0 : ECF_NOTHROW));
     }
 
-  /* If we're checking the stack, `alloca' can throw.  */
-  if (flag_stack_check)
-    TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0;
-
   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
@@ -9397,19 +9352,6 @@ initializer_zerop (const_tree init)
        return true;
       }
 
-    case STRING_CST:
-      {
-       int i;
-
-       /* We need to loop through all elements to handle cases like
-          "\0" and "\0foobar".  */
-       for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
-         if (TREE_STRING_POINTER (init)[i] != '\0')
-           return false;
-
-       return true;
-      }
-
     default:
       return false;
     }
@@ -10375,6 +10317,22 @@ tree_block (tree t)
   return NULL;
 }
 
+/* Build and return a TREE_LIST of arguments in the CALL_EXPR exp.
+   FIXME: don't use this function.  It exists for compatibility with
+   the old representation of CALL_EXPRs where a list was used to hold the
+   arguments.  Places that currently extract the arglist from a CALL_EXPR
+   ought to be rewritten to use the CALL_EXPR itself.  */
+tree
+call_expr_arglist (tree exp)
+{
+  tree arglist = NULL_TREE;
+  int i;
+  for (i = call_expr_nargs (exp) - 1; i >= 0; i--)
+    arglist = tree_cons (NULL_TREE, CALL_EXPR_ARG (exp, i), arglist);
+  return arglist;
+}
+
+
 /* Create a nameless artificial label and put it in the current
    function context.  The label has a location of LOC.  Returns the
    newly created label.  */
@@ -10778,60 +10736,4 @@ lhd_gcc_personality (void)
   return gcc_eh_personality_decl;
 }
 
-/* Try to find a base info of BINFO that would have its field decl at offset
-   OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
-   found, return, otherwise return NULL_TREE.  */
-
-tree
-get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
-{
-  tree type;
-
-  if (offset == 0)
-    return binfo;
-
-  type = TREE_TYPE (binfo);
-  while (offset > 0)
-    {
-      tree base_binfo, found_binfo;
-      HOST_WIDE_INT pos, size;
-      tree fld;
-      int i;
-
-      if (TREE_CODE (type) != RECORD_TYPE)
-       return NULL_TREE;
-
-      for (fld = TYPE_FIELDS (type); fld; fld = TREE_CHAIN (fld))
-       {
-         if (TREE_CODE (fld) != FIELD_DECL)
-           continue;
-
-         pos = int_bit_position (fld);
-         size = tree_low_cst (DECL_SIZE (fld), 1);
-         if (pos <= offset && (pos + size) > offset)
-           break;
-       }
-      if (!fld)
-       return NULL_TREE;
-
-      found_binfo = NULL_TREE;
-      for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
-       if (TREE_TYPE (base_binfo) == TREE_TYPE (fld))
-         {
-           found_binfo = base_binfo;
-           break;
-         }
-
-      if (!found_binfo)
-       return NULL_TREE;
-
-      type = TREE_TYPE (fld);
-      binfo = found_binfo;
-      offset -= pos;
-    }
-  if (type != expected_type)
-    return NULL_TREE;
-  return binfo;
-}
-
 #include "gt-tree.h"