CbC/CbC_gcc: gcc/cp/method.c comparison

comparison gcc/cp/method.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Handle the hair of processing (but not expanding) inline functions.
 Also manage function and variable name overloading.
-Copyright (C) 1987-2017 Free Software Foundation, Inc.
+Copyright (C) 1987-2018 Free Software Foundation, Inc.
 Contributed by Michael Tiemann (tiemann@cygnus.com)
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "stringpool.h"
 #include "cgraph.h"
 #include "varasm.h"
 #include "toplev.h"
 #include "common/common-target.h"
-/* Various flags to control the mangling process.  */
-enum mangling_flags
-{
-/* No flags.  */
-mf_none = 0,
-/* The thing we are presently mangling is part of a template type,
-rather than a fully instantiated type.  Therefore, we may see
-complex expressions where we would normally expect to see a
-simple integer constant.  */
-mf_maybe_uninstantiated = 1,
-/* When mangling a numeric value, use the form `_XX_' (instead of
-just `XX') if the value has more than one digit.  */
-mf_use_underscores_around_value = 2
-};
 static void do_build_copy_assign (tree);
 static void do_build_copy_constructor (tree);
 static tree make_alias_for_thunk (tree);
 {
 tree alias = build_decl (DECL_SOURCE_LOCATION (target),
 			   TREE_CODE (target), newid, TREE_TYPE (target));
 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
 cxx_dup_lang_specific_decl (alias);
-DECL_CONTEXT (alias) = NULL;
+DECL_CONTEXT (alias) = DECL_CONTEXT (target);
 TREE_READONLY (alias) = TREE_READONLY (target);
 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
 TREE_PUBLIC (alias) = 0;
 DECL_INTERFACE_KNOWN (alias) = 1;
 if (DECL_LANG_SPECIFIC (alias))
 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
 funcn = cgraph_node::get (function);
 gcc_checking_assert (funcn);
 thunk_node = funcn->create_thunk (thunk_fndecl, function,
 				    this_adjusting, fixed_offset, virtual_value,
-				    virtual_offset, alias);
+				    0, virtual_offset, alias);
 if (DECL_ONE_ONLY (function))
 thunk_node->add_to_same_comdat_group (funcn);
 pop_from_top_level ();
 }
 {
 tree exp = convert_from_reference (parm);
 tree type = TREE_TYPE (parm);
 if (DECL_PACK_P (parm))
 type = PACK_EXPANSION_PATTERN (type);
-if (TREE_CODE (type) != REFERENCE_TYPE)
+if (!TYPE_REF_P (type))
 type = cp_build_reference_type (type, /*rval=*/true);
 warning_sentinel w (warn_useless_cast);
 exp = build_static_cast (type, exp, tf_warning_or_error);
 if (DECL_PACK_P (parm))
 exp = make_pack_expansion (exp);
 	  /* Compute the type of "init->field".  If the copy-constructor
 	     parameter is, for example, "const S&", and the type of
 	     the field is "T", then the type will usually be "const
 	     T".  (There are no cv-qualified variants of reference
 	     types.)  */
-	  if (TREE_CODE (expr_type) != REFERENCE_TYPE)
+	  if (!TYPE_REF_P (expr_type))
 	    {
 	      int quals = cvquals;
 	      if (DECL_MUTABLE_P (field))
 		quals &= ~TYPE_QUAL_CONST;
 	      quals |= cp_type_quals (expr_type);
 	      expr_type = cp_build_qualified_type (expr_type, quals);
 	    }
 	  init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
-	  if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
+	  if (move_p && !TYPE_REF_P (expr_type)
 	      /* 'move' breaks bit-fields, and has no effect for scalars.  */
 	      && !scalarish_type_p (expr_type))
 	    init = move (init);
 	  init = build_tree_list (NULL_TREE, init);
 	    converted_parm = move (converted_parm);
 	  /* Call the base class assignment operator.  */
 	  parmvec = make_tree_vector_single (converted_parm);
 	  finish_expr_stmt
 	    (build_special_member_call (current_class_ref,
-					cp_assignment_operator_id (NOP_EXPR),
+					assign_op_identifier,
 					&parmvec,
 					base_binfo,
 					flags,
 tf_warning_or_error));
 	  release_tree_vector (parmvec);
 	    {
 	      error ("non-static const member %q#D, can%'t use default "
 		     "assignment operator", field);
 	      continue;
 	    }
-	  else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
+	  else if (TYPE_REF_P (expr_type))
 	    {
 	      error ("non-static reference member %q#D, can%'t use "
 		     "default assignment operator", field);
 	      continue;
 	    }
 	  if (DECL_MUTABLE_P (field))
 	    quals &= ~TYPE_QUAL_CONST;
 	  expr_type = cp_build_qualified_type (expr_type, quals);
 	  init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
-	  if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
+	  if (move_p && !TYPE_REF_P (expr_type)
 	      /* 'move' breaks bit-fields, and has no effect for scalars.  */
 	      && !scalarish_type_p (expr_type))
 	    init = move (init);
 	  if (DECL_NAME (field))
 input_location = DECL_SOURCE_LOCATION (fndecl);
 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
 stmt = begin_function_body ();
-if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
+if (DECL_ASSIGNMENT_OPERATOR_P (fndecl)
+&& DECL_OVERLOADED_OPERATOR_IS (fndecl, NOP_EXPR))
 {
 do_build_copy_assign (fndecl);
 need_body = false;
 }
 else if (DECL_CONSTRUCTOR_P (fndecl))
 pop_function_context ();
 pop_deferring_access_checks ();
 if (error_count != errorcount || warning_count != warningcount + werrorcount)
-inform (input_location, "synthesized method %qD first required here ",
+inform (input_location, "synthesized method %qD first required here",
 	    fndecl);
 }
 /* Build a reference to type TYPE with cv-quals QUALS, which is an
 rvalue if RVALUE is true.  */
 REFTYPE.  */
 static tree
 build_stub_object (tree reftype)
 {
-if (TREE_CODE (reftype) != REFERENCE_TYPE)
+if (!TYPE_REF_P (reftype))
 reftype = cp_build_reference_type (reftype, /*rval*/true);
 tree stub = build1 (CONVERT_EXPR, reftype, integer_one_node);
 return convert_from_reference (stub);
 }
 get_copy_assign (tree type)
 {
 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
 	       ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
 tree argtype = build_stub_type (type, quals, false);
-tree fn = locate_fn_flags (type, cp_assignment_operator_id (NOP_EXPR), argtype,
+tree fn = locate_fn_flags (type, assign_op_identifier, argtype,
 			     LOOKUP_NORMAL, tf_warning_or_error);
 if (fn == error_mark_node)
 return NULL_TREE;
 return fn;
 }
 static tree
 constructible_expr (tree to, tree from)
 {
 tree expr;
+cp_unevaluated cp_uneval_guard;
 if (CLASS_TYPE_P (to))
 {
 tree ctype = to;
 vec<tree, va_gc> *args = NULL;
-cp_unevaluated cp_uneval_guard;
+if (!TYPE_REF_P (to))
-if (TREE_CODE (to) != REFERENCE_TYPE)
 	to = cp_build_reference_type (to, /*rval*/false);
 tree ob = build_stub_object (to);
 for (; from; from = TREE_CHAIN (from))
 	vec_safe_push (args, build_stub_object (TREE_VALUE (from)));
 expr = build_special_member_call (ob, complete_ctor_identifier, &args,
 is_trivially_xible (enum tree_code code, tree to, tree from)
 {
 tree expr;
 expr = is_xible_helper (code, to, from, /*trivial*/true);
-if (expr == error_mark_node)
+if (expr == NULL_TREE || expr == error_mark_node)
 return false;
 tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
 return !nt;
 }
 {
 *constexpr_p = false;
 if (diag)
 	{
 	  inform (DECL_SOURCE_LOCATION (fn),
-		  "defaulted constructor calls non-constexpr %qD", fn);
+		  "defaulted constructor calls non-%<constexpr%> %qD", fn);
 	  explain_invalid_constexpr_fn (fn);
 	}
 }
 }
 if (TREE_CODE (field) != FIELD_DECL
 	  || DECL_ARTIFICIAL (field))
 	continue;
+/* Variant members only affect deletedness.  In particular, they don't
+	 affect the exception-specification of a user-provided destructor,
+	 which we're figuring out via get_defaulted_eh_spec.  So if we aren't
+	 asking if this is deleted, don't even look up the function; we don't
+	 want an error about a deleted function we aren't actually calling.  */
+if (sfk == sfk_destructor && deleted_p == NULL
+	  && TREE_CODE (DECL_CONTEXT (field)) == UNION_TYPE)
+	break;
 mem_type = strip_array_types (TREE_TYPE (field));
 if (assign_p)
 	{
 	  bool bad = true;
 	  if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
 	    {
 	      if (diag)
 		error ("non-static const member %q#D, can%'t use default "
 		       "assignment operator", field);
 	    }
-	  else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
+	  else if (TYPE_REF_P (mem_type))
 	    {
 	      if (diag)
 		error ("non-static reference member %q#D, can%'t use "
 		       "default assignment operator", field);
 	    }
 		  inform (DECL_SOURCE_LOCATION (field),
 			  "%q#D should be initialized", field);
 		}
 	      bad = true;
 	    }
-	  else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
+	  else if (TYPE_REF_P (mem_type))
 	    {
 	      if (diag)
 		{
 		  error ("uninitialized reference member in %q#T",
 			 current_class_type);
 	    }
 	}
 else if (sfk == sfk_copy_constructor)
 	{
 	  /* 12.8p11b5 */
-	  if (TREE_CODE (mem_type) == REFERENCE_TYPE
+	  if (TYPE_REF_P (mem_type)
 	      && TYPE_REF_IS_RVALUE (mem_type))
 	    {
 	      if (diag)
 		error ("copying non-static data member %q#D of rvalue "
 		       "reference type", field);
 if (deleted_p)
 {
 /* "The closure type associated with a lambda-expression has a deleted
 	 default constructor and a deleted copy assignment operator."
-This is diagnosed in maybe_explain_implicit_delete.  */
+	 This is diagnosed in maybe_explain_implicit_delete.
+	 In C++2a, only lambda-expressions with lambda-captures have those
+	 deleted.  */
 if (LAMBDA_TYPE_P (ctype)
-	  && (sfk == sfk_constructor
+	  && (sfk == sfk_constructor || sfk == sfk_copy_assignment)
-	      || sfk == sfk_copy_assignment))
+	  && (cxx_dialect < cxx2a
+	      || LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (ctype))
+	      || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE
+				(CLASSTYPE_LAMBDA_EXPR (ctype)) != CPLD_NONE))
 	{
 	  *deleted_p = true;
 	  return;
 	}
 switch (sfk)
 {
 case sfk_move_assignment:
 case sfk_copy_assignment:
 assign_p = true;
-fnname = cp_assignment_operator_id (NOP_EXPR);
+fnname = assign_op_identifier;
 break;
 case sfk_destructor:
 check_vdtor = true;
 /* The synthesized method will call base dtors, but check complete
 if (check_vdtor && type_has_virtual_destructor (BINFO_TYPE (base_binfo)))
 	{
 	  /* Unlike for base ctor/op=/dtor, for operator delete it's fine
 	     to have a null fn (no class-specific op delete).  */
-	  fn = locate_fn_flags (ctype, cp_operator_id (DELETE_EXPR),
+	  fn = locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
 				ptr_type_node, flags, tf_none);
 	  if (fn && fn == error_mark_node)
 	    {
 	      if (complain & tf_error)
-		locate_fn_flags (ctype, cp_operator_id (DELETE_EXPR),
+		locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
 				 ptr_type_node, flags, complain);
 	      if (deleted_p)
 		*deleted_p = true;
 	    }
 	  check_vdtor = false;
 	    {
 	      inform (DECL_SOURCE_LOCATION (decl),
 		      "%q#D is implicitly deleted because the default "
 		      "definition would be ill-formed:", decl);
 	      synthesized_method_walk (ctype, sfk, const_p,
-				       NULL, NULL, NULL, NULL, true,
+				       NULL, NULL, &deleted_p, NULL, true,
 				       &inh, parms);
 	    }
 	  else if (!comp_except_specs
 		   (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
 		    raises, ce_normal))
 {
 if (kind == sfk_copy_assignment
 	  || kind == sfk_move_assignment)
 	{
 	  return_type = build_reference_type (type);
-	  name = cp_assignment_operator_id (NOP_EXPR);
+	  name = assign_op_identifier;
 	}
 else
 	name = ctor_identifier;
 if (kind == sfk_inheriting_constructor)
 if (kind != sfk_inheriting_constructor)
 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
 if (!IDENTIFIER_CDTOR_P (name))
 /* Assignment operator.  */
-SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
+DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) = OVL_OP_NOP_EXPR;
 else if (IDENTIFIER_CTOR_P (name))
 DECL_CXX_CONSTRUCTOR_P (fn) = true;
 else
 DECL_CXX_DESTRUCTOR_P (fn) = true;
 {
 error ("defaulted declaration %q+D does not match the "
 	     "expected signature", fn);
 inform (DECL_SOURCE_LOCATION (fn),
 	      "expected signature: %qD", implicit_fn);
-return;
 }
 if (DECL_DELETED_FN (implicit_fn))
 {
 DECL_DELETED_FN (fn) = 1;
 && DECL_DECLARED_CONSTEXPR_P (fn))
 {
 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
 	{
 	  error ("explicitly defaulted function %q+D cannot be declared "
-		 "as constexpr because the implicit declaration is not "
+		 "as %<constexpr%> because the implicit declaration is not "
-		 "constexpr:", fn);
+		 "%<constexpr%>:", fn);
 	  explain_implicit_non_constexpr (fn);
 	}
 DECL_DECLARED_CONSTEXPR_P (fn) = false;
 }
 }
 	kind = sfk_move_constructor;
 }
 else if (DECL_DESTRUCTOR_P (fn))
 kind = sfk_destructor;
 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
-	   && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
+	   && DECL_OVERLOADED_OPERATOR_IS (fn, NOP_EXPR))
 {
 if (copy_fn_p (fn))
 	kind = sfk_copy_assignment;
 else if (move_fn_p (fn))
 	kind = sfk_move_assignment;
 /* [class.copy]/8 If the class definition declares a move constructor or
 move assignment operator, the implicitly declared copy constructor is
 defined as deleted.... */
 if ((sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
-&& classtype_has_move_assign_or_move_ctor_p (type, true))
+&& cxx_dialect >= cxx11)
-DECL_DELETED_FN (fn) = true;
+{
+if (classtype_has_move_assign_or_move_ctor_p (type, true))
+	DECL_DELETED_FN (fn) = true;
+else if (classtype_has_user_copy_or_dtor (type))
+	/* The implicit definition of a copy constructor as defaulted is
+	   deprecated if the class has a user-declared copy assignment operator
+	   or a user-declared destructor. The implicit definition of a copy
+	   assignment operator as defaulted is deprecated if the class has a
+	   user-declared copy constructor or a user-declared destructor (15.4,
+	   15.8).  */
+	TREE_DEPRECATED (fn) = true;
+}
 /* Destructors and assignment operators may be virtual.  */
 if (sfk == sfk_destructor
 || sfk == sfk_move_assignment
 || sfk == sfk_copy_assignment)
 check_for_override (fn, type);
 /* Add it to the class  */
 bool added = add_method (type, fn, false);
-gcc_assert (added);
+gcc_assert (added || errorcount);
 /* Add it to TYPE_FIELDS.  */
 if (sfk == sfk_destructor
 && DECL_VIRTUAL_P (fn))
 /* The ABI requires that a virtual destructor go at the end of the
 }
 /* Propagate TYPE_FIELDS.  */
 fixup_type_variants (type);
 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
-if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
+if (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn))
-|| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
 /* Create appropriate clones.  */
 clone_function_decl (fn, /*update_methods=*/true);
 return fn;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/method.c @ 131:84e7813d76e9