CbC/CbC_gcc: gcc/cp/cp-gimplify.c comparison

comparison gcc/cp/cp-gimplify.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
 /* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.
-Copyright (C) 2002-2017 Free Software Foundation, Inc.
+Copyright (C) 2002-2018 Free Software Foundation, Inc.
 Contributed by Jason Merrill <jason@redhat.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "predict.h"
 #include "stor-layout.h"
 #include "tree-iterator.h"
 #include "gimplify.h"
 #include "c-family/c-ubsan.h"
-#include "cilk.h"
-#include "cp-cilkplus.h"
 #include "stringpool.h"
 #include "attribs.h"
 #include "asan.h"
 /* Forward declarations.  */
 if (cond && TREE_CODE (cond) != INTEGER_CST)
 {
 /* If COND is constant, don't bother building an exit.  If it's false,
 	 we won't build a loop.  If it's true, any exits are in the body.  */
-location_t cloc = EXPR_LOC_OR_LOC (cond, start_locus);
+location_t cloc = cp_expr_loc_or_loc (cond, start_locus);
 exit = build1_loc (cloc, GOTO_EXPR, void_type_node,
 			 get_bc_label (bc_break));
 exit = fold_build3_loc (cloc, COND_EXPR, void_type_node, cond,
 			      build_empty_stmt (cloc), exit);
 }
 cp_walk_tree (&body, cp_genericize_r, data, NULL);
 cp_walk_tree (&cond, cp_genericize_r, data, NULL);
 cp_walk_tree (&type, cp_genericize_r, data, NULL);
 *walk_subtrees = 0;
-*stmt_p = build3_loc (stmt_locus, SWITCH_EXPR, type, cond, body, NULL_TREE);
+if (TREE_USED (break_block))
-finish_bc_block (stmt_p, bc_break, break_block);
+SWITCH_BREAK_LABEL_P (break_block) = 1;
+finish_bc_block (&body, bc_break, break_block);
+*stmt_p = build2_loc (stmt_locus, SWITCH_EXPR, type, cond, body);
+SWITCH_ALL_CASES_P (*stmt_p) = SWITCH_STMT_ALL_CASES_P (stmt);
+gcc_checking_assert (!SWITCH_STMT_NO_BREAK_P (stmt)
+		       || !TREE_USED (break_block));
 }
 /* Genericize a CONTINUE_STMT node *STMT_P.  */
 static void
 int
 cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 {
 int saved_stmts_are_full_exprs_p = 0;
-location_t loc = EXPR_LOC_OR_LOC (*expr_p, input_location);
+location_t loc = cp_expr_loc_or_loc (*expr_p, input_location);
 enum tree_code code = TREE_CODE (*expr_p);
 enum gimplify_status ret;
 if (STATEMENT_CODE_P (code))
 {
 /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
 	 LHS of an assignment might also be involved in the RHS, as in bug
 	 25979.  */
 case INIT_EXPR:
-if (fn_contains_cilk_spawn_p (cfun))
-	{
-	  if (cilk_cp_detect_spawn_and_unwrap (expr_p))
-	    return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
-	  if (seen_error () && contains_cilk_spawn_stmt (*expr_p))
-	    return GS_ERROR;
-	}
 cp_gimplify_init_expr (expr_p);
 if (TREE_CODE (*expr_p) != INIT_EXPR)
 	return GS_OK;
 /* Fall through.  */
 case MODIFY_EXPR:
 modify_expr_case:
 {
-	if (fn_contains_cilk_spawn_p (cfun)
-	    && cilk_cp_detect_spawn_and_unwrap (expr_p)
-	    && !seen_error ())
-	  return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 	/* If the back end isn't clever enough to know that the lhs and rhs
 	   types are the same, add an explicit conversion.  */
 	tree op0 = TREE_OPERAND (*expr_p, 0);
 	tree op1 = TREE_OPERAND (*expr_p, 1);
 					    : arg;
 	ret = GS_OK;
 }
 break;
-case CILK_SPAWN_STMT:
-gcc_assert(fn_contains_cilk_spawn_p (cfun)
-		 && cilk_cp_detect_spawn_and_unwrap (expr_p));
-if (!seen_error ())
-return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
-return GS_ERROR;
 case CALL_EXPR:
-if (fn_contains_cilk_spawn_p (cfun)
-	  && cilk_cp_detect_spawn_and_unwrap (expr_p)
-	  && !seen_error ())
-return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
 ret = GS_OK;
 if (!CALL_EXPR_FN (*expr_p))
 	/* Internal function call.  */;
 else if (CALL_EXPR_REVERSE_ARGS (*expr_p))
 	{
 else if (flag_strong_eval_order
 	       && !CALL_EXPR_OPERATOR_SYNTAX (*expr_p))
 	{
 	  /* If flag_strong_eval_order, evaluate the object argument first.  */
 	  tree fntype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
-	  if (POINTER_TYPE_P (fntype))
+	  if (INDIRECT_TYPE_P (fntype))
 	    fntype = TREE_TYPE (fntype);
 	  if (TREE_CODE (fntype) == METHOD_TYPE)
 	    {
 	      enum gimplify_status t
 		= gimplify_arg (&CALL_EXPR_ARG (*expr_p, 0), pre_p, loc);
 	      if (t == GS_ERROR)
 		ret = GS_ERROR;
 	    }
 	}
+if (ret != GS_ERROR)
+	{
+	  tree decl = cp_get_callee_fndecl_nofold (*expr_p);
+	  if (decl
+	      && fndecl_built_in_p (decl, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
+				  BUILT_IN_FRONTEND))
+	    *expr_p = boolean_false_node;
+	}
 break;
 case RETURN_EXPR:
 if (TREE_OPERAND (*expr_p, 0)
 	  && (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == INIT_EXPR
 omp_var_to_track (tree decl)
 {
 tree type = TREE_TYPE (decl);
 if (is_invisiref_parm (decl))
 type = TREE_TYPE (type);
-else if (TREE_CODE (type) == REFERENCE_TYPE)
+else if (TYPE_REF_P (type))
 type = TREE_TYPE (type);
 while (TREE_CODE (type) == ARRAY_TYPE)
 type = TREE_TYPE (type);
 if (type == error_mark_node || !CLASS_TYPE_P (type))
 return false;
 		 dtor are instantiated, because during gimplification
 		 it will be already too late.  */
 	      tree type = TREE_TYPE (decl);
 	      if (is_invisiref_parm (decl))
 		type = TREE_TYPE (type);
-	      else if (TREE_CODE (type) == REFERENCE_TYPE)
+	      else if (TYPE_REF_P (type))
 		type = TREE_TYPE (type);
 	      while (TREE_CODE (type) == ARRAY_TYPE)
 		type = TREE_TYPE (type);
 	      get_copy_ctor (type, tf_none);
 	      get_dtor (type, tf_none);
 return NULL;
 }
 code = TREE_CODE (stmt);
 if (code == OMP_FOR || code == OMP_SIMD || code == OMP_DISTRIBUTE
-|| code == OMP_TASKLOOP || code == CILK_FOR || code == CILK_SIMD
+|| code == OMP_TASKLOOP || code == OACC_LOOP)
-|| code == OACC_LOOP)
 {
 tree x;
 int i, n;
 cp_walk_tree (&OMP_FOR_BODY (stmt), cp_fold_r, data, NULL);
 	  || TREE_CODE (stmt) == PARM_DECL
 	  || TREE_CODE (stmt) == RESULT_DECL)
 && omp_var_to_track (stmt))
 omp_cxx_notice_variable (wtd->omp_ctx, stmt);
+/* Don't dereference parms in a thunk, pass the references through. */
+if ((TREE_CODE (stmt) == CALL_EXPR && CALL_FROM_THUNK_P (stmt))
+|| (TREE_CODE (stmt) == AGGR_INIT_EXPR && AGGR_INIT_FROM_THUNK_P (stmt)))
+{
+*walk_subtrees = 0;
+return NULL;
+}
 /* Dereference invisible reference parms.  */
 if (wtd->handle_invisiref_parm_p && is_invisiref_parm (stmt))
 {
 *stmt_p = convert_from_reference (stmt);
 p_set->add (*stmt_p);
 in.uid = DECL_UID (stmt);
 h = cp_function_chain->extern_decl_map->find_with_hash (&in, in.uid);
 if (h)
 	{
 	  *stmt_p = h->to;
+	  TREE_USED (h->to) |= TREE_USED (stmt);
 	  *walk_subtrees = 0;
 	  return NULL;
 	}
 }
 if (TREE_CODE (stmt) == INTEGER_CST
-&& TREE_CODE (TREE_TYPE (stmt)) == REFERENCE_TYPE
+&& TYPE_REF_P (TREE_TYPE (stmt))
 && (flag_sanitize & (SANITIZE_NULL | SANITIZE_ALIGNMENT))
 && !wtd->no_sanitize_p)
 {
 ubsan_maybe_instrument_reference (stmt_p);
 if (*stmt_p != stmt)
 	      if ((block = BIND_EXPR_BLOCK (wtd->bind_expr_stack[i])))
 		break;
 	  }
 	if (block)
 	  {
-	    tree using_directive;
+	    tree decl = TREE_OPERAND (stmt, 0);
-	    gcc_assert (TREE_OPERAND (stmt, 0));
+	    gcc_assert (decl);
-	    using_directive = make_node (IMPORTED_DECL);
+	    if (undeduced_auto_decl (decl))
-	    TREE_TYPE (using_directive) = void_type_node;
+	      /* Omit from the GENERIC, the back-end can't handle it.  */;
+	    else
-	    IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
+	      {
-	      = TREE_OPERAND (stmt, 0);
+		tree using_directive = make_node (IMPORTED_DECL);
-	    DECL_CHAIN (using_directive) = BLOCK_VARS (block);
+		TREE_TYPE (using_directive) = void_type_node;
-	    BLOCK_VARS (block) = using_directive;
+		IMPORTED_DECL_ASSOCIATED_DECL (using_directive) = decl;
+		DECL_CHAIN (using_directive) = BLOCK_VARS (block);
+		BLOCK_VARS (block) = using_directive;
+	      }
 	  }
 	/* The USING_STMT won't appear in GENERIC.  */
 	*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
 	*walk_subtrees = 0;
 }
 	location_t loc = location_of (stmt);
 	if (TREE_NO_WARNING (stmt))
 	  /* Never mind.  */;
 	else if (wtd->try_block)
 	  {
-	    if (TREE_CODE (wtd->try_block) == MUST_NOT_THROW_EXPR
+	    if (TREE_CODE (wtd->try_block) == MUST_NOT_THROW_EXPR)
-		&& warning_at (loc, OPT_Wterminate,
+	      {
-			       "throw will always call terminate()")
+		auto_diagnostic_group d;
-		&& cxx_dialect >= cxx11
+		if (warning_at (loc, OPT_Wterminate,
-		&& DECL_DESTRUCTOR_P (current_function_decl))
+				"throw will always call terminate()")
-	      inform (loc, "in C++11 destructors default to noexcept");
+		    && cxx_dialect >= cxx11
+		    && DECL_DESTRUCTOR_P (current_function_decl))
+		  inform (loc, "in C++11 destructors default to noexcept");
+	      }
 	  }
 	else
 	  {
 	    if (warn_cxx11_compat && cxx_dialect < cxx11
 		&& DECL_DESTRUCTOR_P (current_function_decl)
 break;
 case OMP_FOR:
 case OMP_SIMD:
 case OMP_DISTRIBUTE:
+case OACC_LOOP:
 genericize_omp_for_stmt (stmt_p, walk_subtrees, data);
 break;
 case PTRMEM_CST:
 /* By the time we get here we're handing off to the back end, so we don't
 break;
 case NOP_EXPR:
 if (!wtd->no_sanitize_p
 	  && sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT)
-	  && TREE_CODE (TREE_TYPE (stmt)) == REFERENCE_TYPE)
+	  && TYPE_REF_P (TREE_TYPE (stmt)))
 	ubsan_maybe_instrument_reference (stmt_p);
 break;
 case CALL_EXPR:
 if (!wtd->no_sanitize_p
 				| SANITIZE_ALIGNMENT | SANITIZE_VPTR)))
 	{
 	  tree fn = CALL_EXPR_FN (stmt);
 	  if (fn != NULL_TREE
 	      && !error_operand_p (fn)
-	      && POINTER_TYPE_P (TREE_TYPE (fn))
+	      && INDIRECT_TYPE_P (TREE_TYPE (fn))
 	      && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) == METHOD_TYPE)
 	    {
 	      bool is_ctor
 		= TREE_CODE (fn) == ADDR_EXPR
 		  && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
 	      if (sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT))
 		ubsan_maybe_instrument_member_call (stmt, is_ctor);
 	      if (sanitize_flags_p (SANITIZE_VPTR) && !is_ctor)
 		cp_ubsan_maybe_instrument_member_call (stmt);
 	    }
-	}
+	  else if (fn == NULL_TREE
+		   && CALL_EXPR_IFN (stmt) == IFN_UBSAN_NULL
+		   && TREE_CODE (CALL_EXPR_ARG (stmt, 0)) == INTEGER_CST
+		   && TYPE_REF_P (TREE_TYPE (CALL_EXPR_ARG (stmt, 0))))
+	    *walk_subtrees = 0;
+	}
+/* Fall through.  */
+case AGGR_INIT_EXPR:
+/* For calls to a multi-versioned function, overload resolution
+	 returns the function with the highest target priority, that is,
+	 the version that will checked for dispatching first.  If this
+	 version is inlinable, a direct call to this version can be made
+	 otherwise the call should go through the dispatcher.  */
+{
+	tree fn = cp_get_callee_fndecl_nofold (stmt);
+	if (fn && DECL_FUNCTION_VERSIONED (fn)
+	    && (current_function_decl == NULL
+		|| !targetm.target_option.can_inline_p (current_function_decl,
+							fn)))
+	  if (tree dis = get_function_version_dispatcher (fn))
+	    {
+	      mark_versions_used (dis);
+	      dis = build_address (dis);
+	      if (TREE_CODE (stmt) == CALL_EXPR)
+		CALL_EXPR_FN (stmt) = dis;
+	      else
+		AGGR_INIT_EXPR_FN (stmt) = dis;
+	    }
+}
+break;
+case TARGET_EXPR:
+if (TARGET_EXPR_INITIAL (stmt)
+	  && TREE_CODE (TARGET_EXPR_INITIAL (stmt)) == CONSTRUCTOR
+	  && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (TARGET_EXPR_INITIAL (stmt)))
+	TARGET_EXPR_NO_ELIDE (stmt) = 1;
 break;
 default:
 if (IS_TYPE_OR_DECL_P (stmt))
 	*walk_subtrees = 0;
 cp_ubsan_instrument_member_accesses (t_p);
 }
 /* If a function that should end with a return in non-void
 function doesn't obviously end with return, add ubsan
-instrumentation code to verify it at runtime.  */
+instrumentation code to verify it at runtime.  If -fsanitize=return
+is not enabled, instrument __builtin_unreachable.  */
 static void
-cp_ubsan_maybe_instrument_return (tree fndecl)
+cp_maybe_instrument_return (tree fndecl)
 {
 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl)))
 || DECL_CONSTRUCTOR_P (fndecl)
 || DECL_DESTRUCTOR_P (fndecl)
 || !targetm.warn_func_return (fndecl))
 return;
+if (!sanitize_flags_p (SANITIZE_RETURN, fndecl)
+/* Don't add __builtin_unreachable () if not optimizing, it will not
+	 improve any optimizations in that case, just break UB code.
+	 Don't add it if -fsanitize=unreachable -fno-sanitize=return either,
+	 UBSan covers this with ubsan_instrument_return above where sufficient
+	 information is provided, while the __builtin_unreachable () below
+	 if return sanitization is disabled will just result in hard to
+	 understand runtime error without location.  */
+&& (!optimize
+	  || sanitize_flags_p (SANITIZE_UNREACHABLE, fndecl)))
+return;
 tree t = DECL_SAVED_TREE (fndecl);
 while (t)
 {
 switch (TREE_CODE (t))
 	{
 	case BIND_EXPR:
 	  t = BIND_EXPR_BODY (t);
 	  continue;
 	case TRY_FINALLY_EXPR:
+	case CLEANUP_POINT_EXPR:
 	  t = TREE_OPERAND (t, 0);
 	  continue;
 	case STATEMENT_LIST:
 	  {
 	    tree_stmt_iterator i = tsi_last (t);
+	    while (!tsi_end_p (i))
+	      {
+		tree p = tsi_stmt (i);
+		if (TREE_CODE (p) != DEBUG_BEGIN_STMT)
+		  break;
+		tsi_prev (&i);
+	      }
 	    if (!tsi_end_p (i))
 	      {
 		t = tsi_stmt (i);
 		continue;
 	      }
 if (t == NULL_TREE)
 return;
 tree *p = &DECL_SAVED_TREE (fndecl);
 if (TREE_CODE (*p) == BIND_EXPR)
 p = &BIND_EXPR_BODY (*p);
-t = ubsan_instrument_return (DECL_SOURCE_LOCATION (fndecl));
+location_t loc = DECL_SOURCE_LOCATION (fndecl);
+if (sanitize_flags_p (SANITIZE_RETURN, fndecl))
+t = ubsan_instrument_return (loc);
+else
+{
+tree fndecl = builtin_decl_explicit (BUILT_IN_UNREACHABLE);
+t = build_call_expr_loc (BUILTINS_LOCATION, fndecl, 0);
+}
 append_to_statement_list (t, p);
 }
 void
 cp_genericize (tree fndecl)
 save_bc_label[bc_break] = bc_label[bc_break];
 save_bc_label[bc_continue] = bc_label[bc_continue];
 bc_label[bc_break] = NULL_TREE;
 bc_label[bc_continue] = NULL_TREE;
-/* Expand all the array notations here.  */
-if (flag_cilkplus
-&& contains_array_notation_expr (DECL_SAVED_TREE (fndecl)))
-DECL_SAVED_TREE (fndecl)
-= expand_array_notation_exprs (DECL_SAVED_TREE (fndecl));
 /* We do want to see every occurrence of the parms, so we can't just use
 walk_tree's hash functionality.  */
 cp_genericize_tree (&DECL_SAVED_TREE (fndecl), true);
-if (sanitize_flags_p (SANITIZE_RETURN)
+cp_maybe_instrument_return (fndecl);
-&& current_function_decl != NULL_TREE)
-cp_ubsan_maybe_instrument_return (fndecl);
 /* Do everything else.  */
 c_genericize (fndecl);
 gcc_assert (bc_label[bc_break] == NULL);
 defparm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
 if (arg2)
 defparm = TREE_CHAIN (defparm);
+bool is_method = TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE;
 if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
 {
 tree inner_type = TREE_TYPE (arg1);
 tree start1, end1, p1;
 tree start2 = NULL, p2 = NULL;
 	argarray[i++] = p2;
 /* Handle default arguments.  */
 for (parm = defparm; parm && parm != void_list_node;
 	   parm = TREE_CHAIN (parm), i++)
 	argarray[i] = convert_default_arg (TREE_VALUE (parm),
-					   TREE_PURPOSE (parm), fn, i,
+					   TREE_PURPOSE (parm), fn,
-					   tf_warning_or_error);
+					   i - is_method, tf_warning_or_error);
 t = build_call_a (fn, i, argarray);
 t = fold_convert (void_type_node, t);
 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
 append_to_statement_list (t, &ret);
 	argarray[i++] = build_fold_addr_expr_loc (input_location, arg2);
 /* Handle default arguments.  */
 for (parm = defparm; parm && parm != void_list_node;
 	   parm = TREE_CHAIN (parm), i++)
 	argarray[i] = convert_default_arg (TREE_VALUE (parm),
-					   TREE_PURPOSE (parm),
+					   TREE_PURPOSE (parm), fn,
-					   fn, i, tf_warning_or_error);
+					   i - is_method, tf_warning_or_error);
 t = build_call_a (fn, i, argarray);
 t = fold_convert (void_type_node, t);
 return fold_build_cleanup_point_expr (TREE_TYPE (t), t);
 }
 }
 than the DECL itself.  */
 bool
 cxx_omp_privatize_by_reference (const_tree decl)
 {
-return (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
+return (TYPE_REF_P (TREE_TYPE (decl))
 	  || is_invisiref_parm (decl));
 }
 /* Return true if DECL is const qualified var having no mutable member.  */
 bool
 cxx_omp_const_qual_no_mutable (tree decl)
 {
 tree type = TREE_TYPE (decl);
-if (TREE_CODE (type) == REFERENCE_TYPE)
+if (TYPE_REF_P (type))
 {
 if (!is_invisiref_parm (decl))
 	return false;
 type = TREE_TYPE (type);
 }
 /* True if OpenMP sharing attribute of DECL is predetermined.  */
 enum omp_clause_default_kind
-cxx_omp_predetermined_sharing (tree decl)
+cxx_omp_predetermined_sharing_1 (tree decl)
 {
 /* Static data members are predetermined shared.  */
 if (TREE_STATIC (decl))
 {
 tree ctx = CP_DECL_CONTEXT (decl);
 }
 /* Const qualified vars having no mutable member are predetermined
 shared.  */
 if (cxx_omp_const_qual_no_mutable (decl))
+return OMP_CLAUSE_DEFAULT_SHARED;
+return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
+}
+/* Likewise, but also include the artificial vars.  We don't want to
+disallow the artificial vars being mentioned in explicit clauses,
+as we use artificial vars e.g. for loop constructs with random
+access iterators other than pointers, but during gimplification
+we want to treat them as predetermined.  */
+enum omp_clause_default_kind
+cxx_omp_predetermined_sharing (tree decl)
+{
+enum omp_clause_default_kind ret = cxx_omp_predetermined_sharing_1 (decl);
+if (ret != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
+return ret;
+/* Predetermine artificial variables holding integral values, those
+are usually result of gimplify_one_sizepos or SAVE_EXPR
+gimplification.  */
+if (VAR_P (decl)
+&& DECL_ARTIFICIAL (decl)
+&& INTEGRAL_TYPE_P (TREE_TYPE (decl))
+&& !(DECL_LANG_SPECIFIC (decl)
+	   && DECL_OMP_PRIVATIZED_MEMBER (decl)))
 return OMP_CLAUSE_DEFAULT_SHARED;
 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 }
 decl = OMP_CLAUSE_DECL (c);
 decl = require_complete_type (decl);
 inner_type = TREE_TYPE (decl);
 if (decl == error_mark_node)
 make_shared = true;
-else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
+else if (TYPE_REF_P (TREE_TYPE (decl)))
 inner_type = TREE_TYPE (inner_type);
 /* We're interested in the base element, not arrays.  */
 while (TREE_CODE (inner_type) == ARRAY_TYPE)
 inner_type = TREE_TYPE (inner_type);
 {
 while (true)
 {
 x = cp_fold (x);
 if (rval && DECL_P (x)
-	  && TREE_CODE (TREE_TYPE (x)) != REFERENCE_TYPE)
+	  && !TYPE_REF_P (TREE_TYPE (x)))
 	{
 	  tree v = decl_constant_value (x);
 	  if (v != x && v != error_mark_node)
 	    {
 	      x = v;
 if (processing_template_decl)
 return x;
 /* FIXME cp_fold ought to be a superset of maybe_constant_value so we don't
 have to call both.  */
 if (cxx_dialect >= cxx11)
-x = maybe_constant_value (x);
+{
+x = maybe_constant_value (x);
+/* Sometimes we are given a CONSTRUCTOR but the call above wraps it into
+	 a TARGET_EXPR; undo that here.  */
+if (TREE_CODE (x) == TARGET_EXPR)
+	x = TARGET_EXPR_INITIAL (x);
+else if (TREE_CODE (x) == VIEW_CONVERT_EXPR
+	       && TREE_CODE (TREE_OPERAND (x, 0)) == CONSTRUCTOR
+	       && TREE_TYPE (TREE_OPERAND (x, 0)) == TREE_TYPE (x))
+	x = TREE_OPERAND (x, 0);
+}
 return cp_fold_rvalue (x);
 }
 /* c-common interface to cp_fold.  If IN_INIT, this is in a static initializer
 and certain changes are made to the folding done.  Or should be (FIXME).  We
 never touch maybe_const, as it is only used for the C front-end
 C_MAYBE_CONST_EXPR.  */
 tree
-c_fully_fold (tree x, bool /*in_init*/, bool */*maybe_const*/)
+c_fully_fold (tree x, bool /*in_init*/, bool */*maybe_const*/, bool lval)
 {
-/* c_fully_fold is only used on rvalues, and we need to fold CONST_DECL to
+return cp_fold_maybe_rvalue (x, !lval);
-INTEGER_CST.  */
-return cp_fold_rvalue (x);
 }
 static GTY((deletable)) hash_map<tree, tree> *fold_cache;
 /* Dispose of the whole FOLD_CACHE.  */
 fold_cache->empty ();
 }
 /*  This function tries to fold an expression X.
 To avoid combinatorial explosion, folding results are kept in fold_cache.
-If we are processing a template or X is invalid, we don't fold at all.
+If X is invalid, we don't fold at all.
 For performance reasons we don't cache expressions representing a
 declaration or constant.
 Function returns X or its folded variant.  */
 static tree
 bool rval_ops = true;
 if (!x || x == error_mark_node)
 return x;
-if (processing_template_decl
+if (EXPR_P (x) && (!TREE_TYPE (x) || TREE_TYPE (x) == error_mark_node))
-|| (EXPR_P (x) && (!TREE_TYPE (x) || TREE_TYPE (x) == error_mark_node)))
 return x;
 /* Don't bother to cache DECLs or constants.  */
 if (DECL_P (x) || CONSTANT_CLASS_P (x))
 return x;
 case CONVERT_EXPR:
 case NOP_EXPR:
 case NON_LVALUE_EXPR:
 if (VOID_TYPE_P (TREE_TYPE (x)))
-	return x;
+	{
+	  /* This is just to make sure we don't end up with casts to
+	     void from error_mark_node.  If we just return x, then
+	     cp_fold_r might fold the operand into error_mark_node and
+	     leave the conversion in the IR.  STRIP_USELESS_TYPE_CONVERSION
+	     during gimplification doesn't like such casts.
+	     Don't create a new tree if op0 != TREE_OPERAND (x, 0), the
+	     folding of the operand should be in the caches and if in cp_fold_r
+	     it will modify it in place.  */
+	  op0 = cp_fold (TREE_OPERAND (x, 0));
+	  if (op0 == error_mark_node)
+	    x = error_mark_node;
+	  break;
+	}
 loc = EXPR_LOCATION (x);
 op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), rval_ops);
 if (code == CONVERT_EXPR
 	  return cp_fold (p);
 	}
 goto unary;
 case ADDR_EXPR:
+loc = EXPR_LOCATION (x);
+op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), false);
+/* Cope with user tricks that amount to offsetof.  */
+if (op0 != error_mark_node
+	  && TREE_CODE (TREE_TYPE (op0)) != FUNCTION_TYPE
+	  && TREE_CODE (TREE_TYPE (op0)) != METHOD_TYPE)
+	{
+	  tree val = get_base_address (op0);
+	  if (val
+	      && INDIRECT_REF_P (val)
+	      && COMPLETE_TYPE_P (TREE_TYPE (val))
+	      && TREE_CONSTANT (TREE_OPERAND (val, 0)))
+	    {
+	      val = TREE_OPERAND (val, 0);
+	      STRIP_NOPS (val);
+	      if (TREE_CODE (val) == INTEGER_CST)
+		return fold_offsetof (op0, TREE_TYPE (x));
+	    }
+	}
+goto finish_unary;
 case REALPART_EXPR:
 case IMAGPART_EXPR:
 rval_ops = false;
 /* FALLTHRU */
 case CONJ_EXPR:
 case FIX_TRUNC_EXPR:
 case FLOAT_EXPR:
 case NEGATE_EXPR:
 case ABS_EXPR:
+case ABSU_EXPR:
 case BIT_NOT_EXPR:
 case TRUTH_NOT_EXPR:
 case FIXED_CONVERT_EXPR:
 unary:
 loc = EXPR_LOCATION (x);
 op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), rval_ops);
+finish_unary:
 if (op0 != TREE_OPERAND (x, 0))
 	{
 	  if (op0 == error_mark_node)
 	    x = error_mark_node;
 	  else
 case MODIFY_EXPR:
 rval_ops = false;
 /* FALLTHRU */
 case POINTER_PLUS_EXPR:
 case PLUS_EXPR:
+case POINTER_DIFF_EXPR:
 case MINUS_EXPR:
 case MULT_EXPR:
 case TRUNC_DIV_EXPR:
 case CEIL_DIV_EXPR:
 case FLOOR_DIV_EXPR:
 	    x = fold_build2_loc (loc, code, TREE_TYPE (x), op0, op1);
 	}
 else
 	x = fold (x);
-if (TREE_NO_WARNING (org_x)
+/* This is only needed for -Wnonnull-compare and only if
-	  && warn_nonnull_compare
+	 TREE_NO_WARNING (org_x), but to avoid that option affecting code
-	  && COMPARISON_CLASS_P (org_x))
+	 generation, we do it always.  */
+if (COMPARISON_CLASS_P (org_x))
 	{
 	  if (x == error_mark_node || TREE_CODE (x) == INTEGER_CST)
 	    ;
 	  else if (COMPARISON_CLASS_P (x))
-	    TREE_NO_WARNING (x) = 1;
+	    {
+	      if (TREE_NO_WARNING (org_x) && warn_nonnull_compare)
+		TREE_NO_WARNING (x) = 1;
+	    }
 	  /* Otherwise give up on optimizing these, let GIMPLE folders
 	     optimize those later on.  */
 	  else if (op0 != TREE_OPERAND (org_x, 0)
 		   || op1 != TREE_OPERAND (org_x, 1))
 	    {
 	      x = build2_loc (loc, code, TREE_TYPE (org_x), op0, op1);
-	      TREE_NO_WARNING (x) = 1;
+	      if (TREE_NO_WARNING (org_x) && warn_nonnull_compare)
+		TREE_NO_WARNING (x) = 1;
 	    }
 	  else
 	    x = org_x;
 	}
 break;
 case VEC_COND_EXPR:
 case COND_EXPR:
-/* Don't bother folding a void condition, since it can't produce a
-	 constant value.  Also, some statement-level uses of COND_EXPR leave
-	 one of the branches NULL, so folding would crash.  */
-if (VOID_TYPE_P (TREE_TYPE (x)))
-	return x;
 loc = EXPR_LOCATION (x);
 op0 = cp_fold_rvalue (TREE_OPERAND (x, 0));
 op1 = cp_fold (TREE_OPERAND (x, 1));
 op2 = cp_fold (TREE_OPERAND (x, 2));
 	  warning_sentinel s (warn_int_in_bool_context);
 	  if (!VOID_TYPE_P (TREE_TYPE (op1)))
 	    op1 = cp_truthvalue_conversion (op1);
 	  if (!VOID_TYPE_P (TREE_TYPE (op2)))
 	    op2 = cp_truthvalue_conversion (op2);
+	}
+else if (VOID_TYPE_P (TREE_TYPE (x)))
+	{
+	  if (TREE_CODE (op0) == INTEGER_CST)
+	    {
+	      /* If the condition is constant, fold can fold away
+		 the COND_EXPR.  If some statement-level uses of COND_EXPR
+		 have one of the branches NULL, avoid folding crash.  */
+	      if (!op1)
+		op1 = build_empty_stmt (loc);
+	      if (!op2)
+		op2 = build_empty_stmt (loc);
+	    }
+	  else
+	    {
+	      /* Otherwise, don't bother folding a void condition, since
+		 it can't produce a constant value.  */
+	      if (op0 != TREE_OPERAND (x, 0)
+		  || op1 != TREE_OPERAND (x, 1)
+		  || op2 != TREE_OPERAND (x, 2))
+		x = build3_loc (loc, code, TREE_TYPE (x), op0, op1, op2);
+	      break;
+	    }
 	}
 if (op0 != TREE_OPERAND (x, 0)
 	  || op1 != TREE_OPERAND (x, 1)
 	  || op2 != TREE_OPERAND (x, 2))
 	x = fold (x);
 /* A COND_EXPR might have incompatible types in branches if one or both
 	 arms are bitfields.  If folding exposed such a branch, fix it up.  */
 if (TREE_CODE (x) != code
+	  && x != error_mark_node
 	  && !useless_type_conversion_p (TREE_TYPE (org_x), TREE_TYPE (x)))
 	x = fold_convert (TREE_TYPE (org_x), x);
 break;
 	tree callee = get_callee_fndecl (x);
 	/* Some built-in function calls will be evaluated at compile-time in
 	   fold ().  Set optimize to 1 when folding __builtin_constant_p inside
 	   a constexpr function so that fold_builtin_1 doesn't fold it to 0.  */
-	if (callee && DECL_BUILT_IN (callee) && !optimize
+	if (callee && fndecl_built_in_p (callee) && !optimize
 	    && DECL_IS_BUILTIN_CONSTANT_P (callee)
 	    && current_function_decl
 	    && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
 	  nw = 1;
+	/* Defer folding __builtin_is_constant_evaluated.  */
+	if (callee
+	    && fndecl_built_in_p (callee, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
+				BUILT_IN_FRONTEND))
+	  break;
 	x = copy_node (x);
 	m = call_expr_nargs (x);
 	for (i = 0; i < m; i++)
 		  nelts = elts->copy ();
 		(*nelts)[i].value = op;
 	      }
 	  }
 	if (nelts)
-	  x = build_constructor (TREE_TYPE (x), nelts);
+	  {
+	    x = build_constructor (TREE_TYPE (x), nelts);
+	    CONSTRUCTOR_PLACEHOLDER_BOUNDARY (x)
+	      = CONSTRUCTOR_PLACEHOLDER_BOUNDARY (org_x);
+	  }
+	if (VECTOR_TYPE_P (TREE_TYPE (x)))
+	  x = fold (x);
 	break;
 }
 case TREE_VEC:
 {
 	bool changed = false;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/cp-gimplify.c @ 131:84e7813d76e9