Merge trunk r263669.

From-SVN: r263670

gcc/c-family/c-ada-spec.c

@@ -631,20 +631,24 @@ static const char *current_source_file;
 location_t
 decl_sloc (const_tree decl, bool last)
 {
-  tree field;
-
   /* Compare the declaration of struct-like types based on the sloc of their
      last field (if LAST is true), so that more nested types collate before
      less nested ones.  */
   if (TREE_CODE (decl) == TYPE_DECL
       && !DECL_ORIGINAL_TYPE (decl)
-      && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))
-      && (field = TYPE_FIELDS (TREE_TYPE (decl))))
+      && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
     {
-      if (last)
+      tree field = TYPE_FIELDS (TREE_TYPE (decl));
+
+      /* Skip any builtin fields we added.  */
+      while (field && DECL_IS_BUILTIN (field))
+	field = DECL_CHAIN (field);
+
+      if (field && last)
 	while (DECL_CHAIN (field))
 	  field = DECL_CHAIN (field);
-      return DECL_SOURCE_LOCATION (field);
+      if (field)
+	DECL_SOURCE_LOCATION (field);
     }
 
   return DECL_SOURCE_LOCATION (decl);

gcc/c-family/c-ppoutput.c

@@ -20,7 +20,7 @@
 #include "system.h"
 #include "coretypes.h"
 #include "c-common.h"		/* For flags.  */
-#include "../libcpp/internal.h"
+#include "../libcpp/internal.h" /* EW! */
 #include "c-pragma.h"		/* For parse_in.  */
 #include "file-prefix-map.h"    /* remap_macro_filename()  */
 

gcc/cp/class.c

@@ -1007,8 +1007,8 @@ add_method (tree type, tree method, bool via_using)
 
   gcc_assert (!DECL_EXTERN_C_P (method));
 
-  tree *slot = find_member_slot (type, DECL_NAME (method));
-  tree current_fns = slot ? *slot : NULL_TREE;
+  tree *slot = get_member_slot (type, DECL_NAME (method));
+  tree current_fns = *slot;
 
   /* Check to see if we've already got this method.  */
   for (ovl_iterator iter (current_fns); iter; ++iter)
@@ -1157,10 +1157,10 @@ add_method (tree type, tree method, bool via_using)
 
   if (!COMPLETE_TYPE_P (type) && !DECL_CONV_FN_P (method)
       && !push_class_level_binding (DECL_NAME (method), current_fns))
-    return false;
-
-  if (!slot)
-    slot = add_member_slot (type, DECL_NAME (method));
+    {
+      unget_member_slot (type, slot);
+      return false;
+    }
 
   /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc.  */
   grok_special_member_properties (method);

gcc/cp/name-lookup.c

@@ -1107,6 +1107,8 @@ extract_conversion_operator (tree fns, tree type)
       if (same_type_p (DECL_CONV_FN_TYPE (*iter), type))
 	convs = lookup_add (*iter, convs);
 
+      // FIXME: really want some way to say 'no templates'
+      // FIXME: Plus ordering the overload to put templates last
       if (TREE_CODE (*iter) == TEMPLATE_DECL)
 	tpls = lookup_add (*iter, tpls);
     }
@@ -1117,15 +1119,27 @@ extract_conversion_operator (tree fns, tree type)
   return convs;
 }
 
-/* Binary search of (ordered) MEMBER_VEC for NAME.  */
+/* Binary search of MEMBER_VEC for NAME.  Returns >= slot index if it
+   is present.  Returns -1-slot index of where to insert it if it is
+   not present.  */
 
-static tree
-member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
+static int
+get_member_vec_index (vec<tree, va_gc> *member_vec, tree name)
 {
-  for (unsigned lo = 0, hi = member_vec->length (); lo < hi;)
+  unsigned lo = 0;
+  unsigned hi = member_vec->length ();
+
+  while (lo != hi)
     {
       unsigned mid = (lo + hi) / 2;
       tree binding = (*member_vec)[mid];
+
+      /* We can get a NULL binding during insertion of a new method
+	 name, because the identifier_binding machinery performs a
+	 lookup.  If we find such a NULL slot, that's the thing we were
+	 looking for, so we might as well bail out immediately.  */
+      if (!binding)
+	break;
       tree binding_name = OVL_NAME (binding);
 
       if (binding_name > name)
@@ -1133,23 +1147,20 @@ member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
       else if (binding_name < name)
 	lo = mid + 1;
       else
-	return binding;
+	return mid;
     }
 
-  return NULL_TREE;
+  return -1 - int (lo);
 }
 
-/* Linear search of (unordered) MEMBER_VEC for NAME.  */
+/* Binary search of (ordered) MEMBER_VEC for NAME.  */
 
 static tree
-member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
+member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
 {
-  for (int ix = member_vec->length (); ix--;)
-    if (tree binding = (*member_vec)[ix])
-      if (OVL_NAME (binding) == name)
-	return binding;
+  int ix = get_member_vec_index (member_vec, name);
 
-  return NULL_TREE;
+  return ix >= 0 ? (*member_vec)[ix] : NULL_TREE;
 }
 
 /* Linear search of (partially ordered) fields of KLASS for NAME.  */
@@ -1167,7 +1178,6 @@ fields_linear_search (tree klass, tree name, bool want_type)
 	  if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
 	    return temp;
 	}
-
       if (DECL_NAME (decl) != name)
 	continue;
       
@@ -1250,7 +1260,7 @@ get_class_binding_direct (tree klass, tree name, int type_or_fns)
   else
     {
       if (member_vec && type_or_fns <= 0)
-	val = member_vec_linear_search (member_vec, lookup);
+	val = member_vec_binary_search (member_vec, lookup);
 
       if (type_or_fns < 0)
 	/* Don't bother looking for field.  We don't want it.  */;
@@ -1302,7 +1312,7 @@ get_class_binding (tree klass, tree name, int type_or_fns)
 	  if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
 	    lazily_declare_fn (sfk_destructor, klass);
 	}
-      else if (name == assign_op_identifier)
+      else if (IDENTIFIER_ASSIGN_OP_P (name) && name == assign_op_identifier)
 	{
 	  if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
 	    lazily_declare_fn (sfk_copy_assignment, klass);
@@ -1315,22 +1325,19 @@ get_class_binding (tree klass, tree name, int type_or_fns)
 }
 
 /* Find the slot containing overloads called 'NAME'.  If there is no
-   such slot and the class is complete, create an empty one, at the
-   correct point in the sorted member vector.  Otherwise return NULL.
-   Deals with conv_op marker handling.  */
+   such slot, create an empty one.  KLASS might be complete at this
+   point.  Deals with conv_op marker handling.  */
 
 tree *
-find_member_slot (tree klass, tree name)
+get_member_slot (tree klass, tree name)
 {
-  bool complete_p = COMPLETE_TYPE_P (klass);
-
   vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
   if (!member_vec)
     {
       vec_alloc (member_vec, 8);
       CLASSTYPE_MEMBER_VEC (klass) = member_vec;
-      if (complete_p)
-	{
+      if (COMPLETE_TYPE_P (klass))
+  	{
 	  /* If the class is complete but had no member_vec, we need
 	     to add the TYPE_FIELDS into it.  We're also most likely
 	     to be adding ctors & dtors, so ask for 6 spare slots (the
@@ -1343,70 +1350,50 @@ find_member_slot (tree klass, tree name)
   if (IDENTIFIER_CONV_OP_P (name))
     name = conv_op_identifier;
 
-  unsigned ix, length = member_vec->length ();
-  for (ix = 0; ix < length; ix++)
+  int ix = get_member_vec_index (member_vec, name);
+  if (ix < 0)
     {
-      tree *slot = &(*member_vec)[ix];
-      tree fn_name = OVL_NAME (*slot);
-
-      if (fn_name == name)
-	{
-	  /* If we found an existing slot, it must be a function set.
-	     Even with insertion after completion, because those only
-	     happen with artificial fns that have unspellable names.
-	     This means we do not have to deal with the stat hack
-	     either.  */
-	  gcc_checking_assert (OVL_P (*slot));
-	  if (name == conv_op_identifier)
-	    {
-	      gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
-	      /* Skip the conv-op marker. */
-	      slot = &OVL_CHAIN (*slot);
-	    }
-	  return slot;
-	}
-
-      if (complete_p && fn_name > name)
-	break;
-    }
-
-  /* No slot found, add one if the class is complete.  */
-  if (complete_p)
-    {
-      /* Do exact allocation, as we don't expect to add many.  */
-      gcc_assert (name != conv_op_identifier);
-      vec_safe_reserve_exact (member_vec, 1);
+      /* No slot found.  Create one at -1-IX.  We know in this case
+         that our caller will succeed in adding the function.  */
+      ix = -1 - ix;
+      /* Do exact allocation, when complete, as we don't expect to add many.  */
+      vec_safe_reserve (member_vec, 1, COMPLETE_TYPE_P (klass));
       CLASSTYPE_MEMBER_VEC (klass) = member_vec;
       member_vec->quick_insert (ix, NULL_TREE);
-      return &(*member_vec)[ix];
     }
 
-  return NULL;
-}
+  tree *slot = &(*member_vec)[ix];
 
-/* KLASS is an incomplete class to which we're adding a method NAME.
-   Add a slot and deal with conv_op marker handling.  */
-
-tree *
-add_member_slot (tree klass, tree name)
-{
-  gcc_assert (!COMPLETE_TYPE_P (klass));
-
-  vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
-  vec_safe_push (member_vec, NULL_TREE);
-  CLASSTYPE_MEMBER_VEC (klass) = member_vec;
-
-  tree *slot = &member_vec->last ();
-  if (IDENTIFIER_CONV_OP_P (name))
+  /* If we found an existing slot, it must be a function set.
+     Even with insertion after completion, because those only
+     happen with artificial fns that have unspellable names.
+     This means we do not have to deal with the stat hack
+     either.  */
+  gcc_checking_assert (!*slot || OVL_P (*slot));
+  if (name == conv_op_identifier)
     {
-      /* Install the marker prefix.  */
-      *slot = ovl_make (conv_op_marker, NULL_TREE);
+      /* Check or install the conv-op marker.  */
+      if (*slot)
+	gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
+      else
+	*slot =  ovl_make (conv_op_marker, NULL_TREE);
+      /* Skip the conv-op marker. */
       slot = &OVL_CHAIN (*slot);
     }
 
   return slot;
 }
 
+void
+unget_member_slot (tree klass, tree *slot)
+{
+  vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
+  gcc_checking_assert (!*slot && member_vec);
+
+  int ix = slot - &(*member_vec)[0];
+  member_vec->ordered_remove (ix);
+}
+
 /* Comparison function to compare two MEMBER_VEC entries by name.
    Because we can have duplicates during insertion of TYPE_FIELDS, we
    do extra checking so deduping doesn't have to deal with so many

gcc/cp/name-lookup.h

@@ -305,8 +305,8 @@ extern tree lookup_arg_dependent (tree, tree, vec<tree, va_gc> *);
 extern tree search_anon_aggr (tree, tree, bool = false);
 extern tree get_class_binding_direct (tree, tree, int type_or_fns = -1);
 extern tree get_class_binding (tree, tree, int type_or_fns = -1);
-extern tree *find_member_slot (tree klass, tree name);
-extern tree *add_member_slot (tree klass, tree name);
+extern tree *get_member_slot (tree klass, tree name);
+extern void unget_member_slot (tree klass, tree *slot);
 extern void resort_type_member_vec (void *, void *,
 				    gt_pointer_operator, void *);
 extern void set_class_bindings (tree, unsigned extra = 0);

libcpp/include/cpplib.h

@@ -611,7 +611,8 @@ struct cpp_callbacks
   time_t (*get_source_date_epoch) (cpp_reader *);
 
   /* Callback for providing suggestions for misspelled directives.  */
-  const char *(*get_suggestion) (cpp_reader *, const char *, const char *const *);
+  const char *(*get_suggestion) (cpp_reader *, const char *,
+				 const char *const *);
 
   /* Callback for when a comment is encountered, giving the location
      of the opening slash, a pointer to the content (which is not
@@ -816,7 +817,10 @@ struct GTY(()) cpp_hashnode {
   ENUM_BITFIELD(node_type) type : 2;	/* CPP node type.  */
   unsigned int flags : 8;		/* CPP flags.  */
 
-  /* 6 bits spare (plus another 32 on 64-bit hosts).  */
+  /* 6 bits spare (plus another 32 on 64-bit hosts).  We could shrink
+     this by making ht_identifier hold an offset to a trailing string
+     value.  That would require FE's expose their IDENTIFIER_NODE size
+     to us.  */
 
   union _cpp_hashnode_value GTY ((desc ("%1.type"))) value;
 };

libcpp/include/line-map.h

@@ -61,22 +61,16 @@ inline int compare (linenum_type lhs, linenum_type rhs)
   return 0;
 }
 
-/* Reason for creating a new line map with linemap_add.  LC_ENTER is
-   when including a new file, e.g. a #include directive in C.
-   LC_LEAVE is when reaching a file's end.  LC_RENAME is when a file
-   name or line number changes for neither of the above reasons
-   (e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME
-   but a filename of "" is not specially interpreted as standard
-   input. LC_ENTER_MACRO is when a macro expansion is about to start.  */
+/* Reason for creating a new line map with linemap_add.  */
 enum lc_reason
 {
-  LC_ENTER = 0,
-  LC_LEAVE,
-  LC_RENAME,
-  LC_RENAME_VERBATIM,
-  LC_ENTER_MACRO,
+  LC_ENTER = 0,		/* Begin #include.  */
+  LC_LEAVE,		/* Return to including file.  */
+  LC_RENAME,		/* Other reason for name change.  */
+  LC_RENAME_VERBATIM,	/* Likewise, but "" != stdin.  */
+  LC_ENTER_MACRO,	/* Begin macro expansion.  */
   /* FIXME: add support for stringize and paste.  */
-  LC_HWM /* High Water Mark.  */
+  LC_HWM
 };
 
 /* The typedef "source_location" is a key within the location database,
@@ -777,8 +771,7 @@ struct GTY(()) line_maps {
      may require allocating a new line_map.  */
   unsigned int max_column_hint;
 
-  /* If non-null, the allocator to use when resizing 'maps'.  If null,
-     xrealloc is used.  */
+  /* The allocator to use when resizing 'maps', defaults to xrealloc.  */
   line_map_realloc reallocator;
 
   /* The allocators' function used to know the actual size it

libcpp/traditional.c

@@ -851,6 +851,7 @@ push_replacement_text (cpp_reader *pfile, cpp_hashnode *node)
   else
     {
       cpp_macro *macro = node->value.macro;
+      gcc_assert (macro->kind == cmk_traditional);
       macro->used = 1;
       text = macro->exp.text;
       len = macro->count;