CbC/CbC_gcc: gcc/gimple.c comparison

comparison gcc/gimple.c @ 131:84e7813d76e9

gcc-8.2

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

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Gimple IR support functions.
-Copyright (C) 2007-2017 Free Software Foundation, Inc.
+Copyright (C) 2007-2018 Free Software Foundation, Inc.
 Contributed by Aldy Hernandez <aldyh@redhat.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 };
 #undef DEFGSCODE
 /* Gimple stats.  */
-int gimple_alloc_counts[(int) gimple_alloc_kind_all];
+uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
-int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
+uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
 /* Keep in sync with gimple.h:enum gimple_alloc_kind.  */
 static const char * const gimple_alloc_kind_names[] = {
 "assignments",
 "phi nodes",
 gcall *
 gimple_build_call_from_tree (tree t, tree fnptrtype)
 {
 unsigned i, nargs;
 gcall *call;
-tree fndecl = get_callee_fndecl (t);
 gcc_assert (TREE_CODE (t) == CALL_EXPR);
 nargs = call_expr_nargs (t);
-call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
+tree fndecl = NULL_TREE;
+if (CALL_EXPR_FN (t) == NULL_TREE)
+call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
+else
+{
+fndecl = get_callee_fndecl (t);
+call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
+}
 for (i = 0; i < nargs; i++)
 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
 gimple_set_block (call, TREE_BLOCK (t));
+gimple_set_location (call, EXPR_LOCATION (t));
 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL.  */
 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
 gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
 if (fndecl
-&& DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+&& fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
 else
 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
 gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
 gimple_set_no_warning (call, TREE_NO_WARNING (t));
-gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
 if (fnptrtype)
 {
 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
 gimple_debug_source_bind_set_var (p, var);
 gimple_debug_source_bind_set_value (p, value);
 if (stmt)
 gimple_set_location (p, gimple_location (stmt));
+return p;
+}
+/* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
+LOCATION.  */
+gdebug *
+gimple_build_debug_begin_stmt (tree block, location_t location
+				    MEM_STAT_DECL)
+{
+gdebug *p
+= as_a <gdebug *> (
+gimple_build_with_ops_stat (GIMPLE_DEBUG,
+				    (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
+				    PASS_MEM_STAT));
+gimple_set_location (p, location);
+gimple_set_block (p, block);
+cfun->debug_marker_count++;
+return p;
+}
+/* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
+LOCATION.  The BLOCK links to the inlined function.  */
+gdebug *
+gimple_build_debug_inline_entry (tree block, location_t location
+				      MEM_STAT_DECL)
+{
+gdebug *p
+= as_a <gdebug *> (
+gimple_build_with_ops_stat (GIMPLE_DEBUG,
+				    (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, 0
+				    PASS_MEM_STAT));
+gimple_set_location (p, location);
+gimple_set_block (p, block);
+cfun->debug_marker_count++;
 return p;
 }
 case '.':
 default:
 return 0;
 }
+}
+/* Return true if call STMT is known to return a non-zero result.  */
+bool
+gimple_call_nonnull_result_p (gcall *call)
+{
+tree fndecl = gimple_call_fndecl (call);
+if (!fndecl)
+return false;
+if (flag_delete_null_pointer_checks && !flag_check_new
+&& DECL_IS_OPERATOR_NEW (fndecl)
+&& !TREE_NOTHROW (fndecl))
+return true;
+/* References are always non-NULL.  */
+if (flag_delete_null_pointer_checks
+&& TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
+return true;
+if (flag_delete_null_pointer_checks
+&& lookup_attribute ("returns_nonnull",
+			   TYPE_ATTRIBUTES (gimple_call_fntype (call))))
+return true;
+return gimple_alloca_call_p (call);
+}
+/* If CALL returns a non-null result in an argument, return that arg.  */
+tree
+gimple_call_nonnull_arg (gcall *call)
+{
+tree fndecl = gimple_call_fndecl (call);
+if (!fndecl)
+return NULL_TREE;
+unsigned rf = gimple_call_return_flags (call);
+if (rf & ERF_RETURNS_ARG)
+{
+unsigned argnum = rf & ERF_RETURN_ARG_MASK;
+if (argnum < gimple_call_num_args (call))
+	{
+	  tree arg = gimple_call_arg (call, argnum);
+	  if (SSA_VAR_P (arg)
+	      && infer_nonnull_range_by_attribute (call, arg))
+	    return arg;
+	}
+}
+return NULL_TREE;
 }
 /* Return true if GS is a copy assignment.  */
 /* SSA operands need to be updated.  */
 gimple_set_modified (copy, true);
 }
+if (gimple_debug_nonbind_marker_p (stmt))
+cfun->debug_marker_count++;
 return copy;
 }
 /* Return true if statement S has side-effects.  We consider a
 /* Print debugging information for gimple stmts generated.  */
 void
 dump_gimple_statistics (void)
 {
-int i, total_tuples = 0, total_bytes = 0;
+int i;
+uint64_t total_tuples = 0, total_bytes = 0;
 if (! GATHER_STATISTICS)
 {
-fprintf (stderr, "No gimple statistics\n");
+fprintf (stderr, "No GIMPLE statistics\n");
 return;
 }
 fprintf (stderr, "\nGIMPLE statements\n");
 fprintf (stderr, "Kind                   Stmts      Bytes\n");
 fprintf (stderr, "---------------------------------------\n");
 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
 {
-fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
+fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n",
-	  gimple_alloc_counts[i], gimple_alloc_sizes[i]);
+	       gimple_alloc_kind_names[i], gimple_alloc_counts[i],
+	       gimple_alloc_sizes[i]);
 total_tuples += gimple_alloc_counts[i];
 total_bytes += gimple_alloc_sizes[i];
 }
 fprintf (stderr, "---------------------------------------\n");
-fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
+fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n", "Total",
+	   total_tuples, total_bytes);
 fprintf (stderr, "---------------------------------------\n");
 }
 /* Return the number of operands needed on the RHS of a GIMPLE
 || (SYM) == DOT_PROD_EXPR						    \
 || (SYM) == SAD_EXPR						    \
 || (SYM) == REALIGN_LOAD_EXPR					    \
 || (SYM) == VEC_COND_EXPR						    \
 || (SYM) == VEC_PERM_EXPR                                             \
-|| (SYM) == BIT_INSERT_EXPR					    \
+|| (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS			    \
-|| (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS			    \
 : ((SYM) == CONSTRUCTOR						    \
 || (SYM) == OBJ_TYPE_REF						    \
 || (SYM) == ASSERT_EXPR						    \
 || (SYM) == ADDR_EXPR						    \
 || (SYM) == WITH_SIZE_EXPR					    \
 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
 {
 tree fndecl;
 if (is_gimple_call (stmt)
 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
-&& DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+&& fndecl_built_in_p (fndecl, code))
-&& DECL_FUNCTION_CODE (fndecl) == code)
 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
 return false;
 }
 /* If CALL is a call to a combined_fn (i.e. an internal function or
 if (gimple_call_internal_p (call))
 	return as_combined_fn (gimple_call_internal_fn (call));
 tree fndecl = gimple_call_fndecl (stmt);
 if (fndecl
-	  && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+	  && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
 	  && gimple_builtin_call_types_compatible_p (stmt, fndecl))
 	return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
 }
 return CFN_LAST;
 }
 static void
 verify_gimple_pp (const char *expected, gimple *stmt)
 {
 pretty_printer pp;
-pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, 0 /* flags */);
+pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
 ASSERT_STREQ (expected, pp_formatted_text (&pp));
 }
 /* Build a GIMPLE_ASSIGN equivalent to
 tmp = 5;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.c @ 131:84e7813d76e9