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

comparison gcc/cp/rtti.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* RunTime Type Identification
-Copyright (C) 1995-2018 Free Software Foundation, Inc.
+Copyright (C) 1995-2020 Free Software Foundation, Inc.
 Mostly written by Jason Merrill (jason@cygnus.com).
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 and are generated as needed. */
 static GTY (()) vec<tinfo_s, va_gc> *tinfo_descs;
 static tree ifnonnull (tree, tree, tsubst_flags_t);
 static tree tinfo_name (tree, bool);
-static tree build_dynamic_cast_1 (tree, tree, tsubst_flags_t);
+static tree build_dynamic_cast_1 (location_t, tree, tree, tsubst_flags_t);
 static tree throw_bad_cast (void);
 static tree throw_bad_typeid (void);
 static tree get_tinfo_ptr (tree);
 static bool typeid_ok_p (void);
 static int qualifier_flags (tree);
 void
 init_rtti_processing (void)
 {
 tree type_info_type;
-push_namespace (std_identifier);
+push_nested_namespace (std_node);
 type_info_type = xref_tag (class_type, get_identifier ("type_info"),
 			     /*tag_scope=*/ts_current, false);
-pop_namespace ();
+pop_nested_namespace (std_node);
 const_type_info_type_node
 = cp_build_qualified_type (type_info_type, TYPE_QUAL_CONST);
 type_info_ptr_type = build_pointer_type (const_type_info_type_node);
 vec_alloc (unemitted_tinfo_decls, 124);
 			 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
 offset = build_vtbl_ref (cp_build_fold_indirect_ref (exp),
 index);
-type = cp_build_qualified_type (ptr_type_node,
+cp_build_qualified_type (ptr_type_node,
-				  cp_type_quals (TREE_TYPE (exp)));
+			   cp_type_quals (TREE_TYPE (exp)));
 return fold_build_pointer_plus (exp, offset);
 }
 /* Get a bad_cast node for the program to throw...
 if (error_operand_p (exp))
 return error_mark_node;
 exp = resolve_nondeduced_context (exp, complain);
-/* peel back references, so they match.  */
+/* Peel back references, so they match.  */
 type = non_reference (unlowered_expr_type (exp));
 /* Peel off cv qualifiers.  */
-type = TYPE_MAIN_VARIANT (type);
+type = cv_unqualified (type);
 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics.  */
 if (CLASS_TYPE_P (type) || type == unknown_type_node
 || type == init_list_type_node)
 type = complete_type_or_maybe_complain (type, exp, complain);
 t = build_vtbl_ref (exp, index);
 t = convert (type_info_ptr_type, t);
 }
 else
 /* Otherwise return the type_info for the static type of the expr.  */
-t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
+t = get_tinfo_ptr (type);
 return cp_build_fold_indirect_ref (t);
 }
 static bool
 typeid_ok_p (void)
 {
 if (! flag_rtti)
 {
-error ("cannot use %<typeid%> with -fno-rtti");
+error ("cannot use %<typeid%> with %<-fno-rtti%>");
 return false;
 }
 if (!COMPLETE_TYPE_P (const_type_info_type_node))
 {
 return error_mark_node;
 if (processing_template_decl)
 return build_min (TYPEID_EXPR, const_type_info_type_node, exp);
-/* FIXME when integrating with c_fully_fold, mark
-resolves_to_fixed_type_p case as a non-constant expression.  */
 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
 && ! resolves_to_fixed_type_p (exp, &nonnull)
 && ! nonnull)
 {
 /* So we need to look into the vtable of the type of exp.
 if (TREE_CODE (type) == FUNCTION_TYPE
 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
 	  || type_memfn_rqual (type) != REF_QUAL_NONE))
 {
 if (complain & tf_error)
-	error ("typeid of qualified function type %qT", type);
+	error ("%<typeid%> of qualified function type %qT", type);
 return error_mark_node;
 }
 /* The top-level cv-qualifiers of the lvalue expression or the type-id
 that is the operand of typeid are always ignored.  */
-type = TYPE_MAIN_VARIANT (type);
+type = cv_unqualified (type);
 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics.  */
 if (CLASS_TYPE_P (type) || type == unknown_type_node
 || type == init_list_type_node)
 type = complete_type_or_maybe_complain (type, NULL_TREE, complain);
 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
 paper.  */
 static tree
-build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
+build_dynamic_cast_1 (location_t loc, tree type, tree expr,
+		      tsubst_flags_t complain)
 {
 enum tree_code tc = TREE_CODE (type);
 tree exprtype;
 tree dcast_fn;
 tree old_expr = expr;
 convert statically.  */
 {
 tree binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
 			      ba_check, NULL, complain);
 if (binfo)
-return build_static_cast (type, expr, complain);
+return build_static_cast (loc, type, expr, complain);
 }
 /* Apply trivial conversion T -> T& for dereferenced ptrs.  */
 if (tc == REFERENCE_TYPE)
 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
 	      if (VAR_P (old_expr)
 		  && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
 		{
 		  tree expr = throw_bad_cast ();
 if (complain & tf_warning)
-warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
+	            warning_at (loc, 0,
-old_expr, type);
+				"%<dynamic_cast<%#T>(%#D)%> can never succeed",
+				type, old_expr);
 		  /* Bash it to the expected type.  */
 		  TREE_TYPE (expr) = type;
 		  return expr;
 		}
 	    }
 	      tree op = TREE_OPERAND (expr, 0);
 	      if (VAR_P (op)
 		  && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
 		{
 if (complain & tf_warning)
-warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
+	            warning_at (loc, 0,
-op, type);
+				"%<dynamic_cast<%#T>(%#D)%> can never succeed",
+				type, op);
 		  retval = build_int_cst (type, 0);
 		  return retval;
 		}
 	    }
 	  /* Use of dynamic_cast when -fno-rtti is prohibited.  */
 	  if (!flag_rtti)
 	    {
 if (complain & tf_error)
-error ("%<dynamic_cast%> not permitted with -fno-rtti");
+		error_at (loc,
+			  "%<dynamic_cast%> not permitted with %<-fno-rtti%>");
 	      return error_mark_node;
 	    }
 	  target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 	  static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
 					       ECF_LEAF | ECF_PURE | ECF_NOTHROW);
 	      pop_abi_namespace ();
 	      dynamic_cast_node = dcast_fn;
 	    }
 	  result = build_cxx_call (dcast_fn, 4, elems, complain);
+	  SET_EXPR_LOCATION (result, loc);
 	  if (tc == REFERENCE_TYPE)
 	    {
 	      tree bad = throw_bad_cast ();
 	      tree neq;
 	      result = save_expr (result);
-	      neq = cp_truthvalue_conversion (result);
+	      neq = cp_truthvalue_conversion (result, complain);
 	      return cp_convert (type,
 				 build3 (COND_EXPR, TREE_TYPE (result),
 					 neq, result, bad), complain);
 	    }
 else
 errstr = _("source type is not polymorphic");
 fail:
 if (complain & tf_error)
-error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
+error_at (loc, "cannot %<dynamic_cast%> %qE (of type %q#T) "
-old_expr, TREE_TYPE (old_expr), type, errstr);
+	      "to type %q#T (%s)",
+	      old_expr, TREE_TYPE (old_expr), type, errstr);
 return error_mark_node;
 }
 tree
-build_dynamic_cast (tree type, tree expr, tsubst_flags_t complain)
+build_dynamic_cast (location_t loc, tree type, tree expr,
+		    tsubst_flags_t complain)
 {
 tree r;
 if (type == error_mark_node || expr == error_mark_node)
 return error_mark_node;
 if (processing_template_decl)
 {
 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
 TREE_SIDE_EFFECTS (expr) = 1;
-return convert_from_reference (expr);
+r = convert_from_reference (expr);
-}
+protected_set_expr_location (r, loc);
+return r;
-r = convert_from_reference (build_dynamic_cast_1 (type, expr, complain));
+}
+r = convert_from_reference (build_dynamic_cast_1 (loc, type, expr,
+						    complain));
 if (r != error_mark_node)
-maybe_warn_about_useless_cast (type, expr, complain);
+maybe_warn_about_useless_cast (loc, type, expr, complain);
+protected_set_expr_location (r, loc);
 return r;
 }
 /* Return the runtime bit mask encoding the qualifiers of TYPE.  */
 {
 flags |= 0x20;
 to = tx_unsafe_fn_variant (to);
 }
 if (flag_noexcept_type
-&& (TREE_CODE (to) == FUNCTION_TYPE
+&& FUNC_OR_METHOD_TYPE_P (to)
-	  || TREE_CODE (to) == METHOD_TYPE)
 && TYPE_NOTHROW_P (to))
 {
 flags |= 0x40;
 to = build_exception_variant (to, NULL_TREE);
 }
 /* Create the pseudo type.  */
 tree pseudo_type = make_class_type (RECORD_TYPE);
 /* Pass the fields chained in reverse.  */
 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
+xref_basetypes (pseudo_type, /*bases=*/NULL_TREE);
 res->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
 res->name = get_identifier (real_name);
 /* Pretend this is public so determine_visibility doesn't give vtables
 set before we actually start to walk the array.  */
 static tree *const fundamentals[] =
 {
 &void_type_node,
 &boolean_type_node,
-&wchar_type_node, &char16_type_node, &char32_type_node,
+&wchar_type_node, &char8_type_node, &char16_type_node, &char32_type_node,
 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
 &short_integer_type_node, &short_unsigned_type_node,
 &integer_type_node, &unsigned_type_node,
 &long_integer_type_node, &long_unsigned_type_node,
 &long_long_integer_type_node, &long_long_unsigned_type_node,
 };
 int ix;
 /* Look for a defined class.  */
 tree bltn_type = lookup_qualified_name
-(abi_node, get_identifier ("__fundamental_type_info"), true, false, false);
+(abi_node, "__fundamental_type_info", true, false);
 if (TREE_CODE (bltn_type) != TYPE_DECL)
 return;
 bltn_type = TREE_TYPE (bltn_type);
 if (!COMPLETE_TYPE_P (bltn_type))

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/rtti.c @ 145:1830386684a0