CbC/CbC_gcc: gcc/var-tracking.c comparison

comparison gcc/var-tracking.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
 /* Variable tracking routines for the GNU compiler.
-Copyright (C) 2002-2018 Free Software Foundation, Inc.
+Copyright (C) 2002-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by
 #include "reload.h"
 #include "calls.h"
 #include "tree-dfa.h"
 #include "tree-ssa.h"
 #include "cselib.h"
-#include "params.h"
 #include "tree-pretty-print.h"
 #include "rtl-iter.h"
 #include "fibonacci_heap.h"
 #include "print-rtl.h"
+#include "function-abi.h"
 typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
 typedef fibonacci_node <long, basic_block_def> bb_heap_node_t;
 /* var-tracking.c assumes that tree code with the same value as VALUE rtx code
 or -1 if the replacement shouldn't be done.  */
 static poly_int64 hard_frame_pointer_adjustment = -1;
 /* Data for adjust_mems callback.  */
-struct adjust_mem_data
+class adjust_mem_data
 {
+public:
 bool store;
 machine_mode mem_mode;
 HOST_WIDE_INT stack_adjust;
 auto_vec<rtx> side_effects;
 };
 /* Helper function for adjusting used MEMs.  */
 static rtx
 adjust_mems (rtx loc, const_rtx old_rtx, void *data)
 {
-struct adjust_mem_data *amd = (struct adjust_mem_data *) data;
+class adjust_mem_data *amd = (class adjust_mem_data *) data;
 rtx mem, addr = loc, tem;
 machine_mode mem_mode_save;
 bool store_save;
 scalar_int_mode tem_mode, tem_subreg_mode;
 poly_int64 size;
 adjust_mem_data amd;
 amd.mem_mode = VOIDmode;
 amd.stack_adjust = -VTI (bb)->out.stack_adjust;
 amd.store = true;
-note_stores (PATTERN (insn), adjust_mem_stores, &amd);
+note_stores (insn, adjust_mem_stores, &amd);
 amd.store = false;
 if (GET_CODE (PATTERN (insn)) == PARALLEL
 && asm_noperands (PATTERN (insn)) > 0
 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
 static void
 dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
 {
 unsigned int r;
 hard_reg_set_iterator hrsi;
-HARD_REG_SET invalidated_regs;
+HARD_REG_SET callee_clobbers
-get_call_reg_set_usage (call_insn, &invalidated_regs,
+= insn_callee_abi (call_insn).full_reg_clobbers ();
-			  regs_invalidated_by_call);
+EXECUTE_IF_SET_IN_HARD_REG_SET (callee_clobbers, 0, r, hrsi)
-EXECUTE_IF_SET_IN_HARD_REG_SET (invalidated_regs, 0, r, hrsi)
 var_regno_delete (set, r);
 if (MAY_HAVE_DEBUG_BIND_INSNS)
 {
 set->traversed_vars = set->vars;
 /* We use this to keep too-complex expressions from being emitted as
 location notes, and then to debug information.  Users can trade
 compile time for ridiculously complex expressions, although they're
 seldom useful, and they may often have to be discarded as not
 representable anyway.  */
-#define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
+#define EXPR_USE_DEPTH (param_max_vartrack_expr_depth)
 /* Attempt to reverse the EXPR operation in the debug info and record
 it in the cselib table.  Say for reg1 = reg2 + 6 even when reg2 is
 no longer live we can express its value as VAL - 6.  */
 for (l = v->locs, count = 0; l; l = l->next, count++)
 if (CONSTANT_P (l->loc)
 	&& (GET_CODE (l->loc) != CONST || !references_value_p (l->loc, 0)))
 return;
 /* Avoid creating too large locs lists.  */
-else if (count == PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE))
+else if (count == param_max_vartrack_reverse_op_size)
 return;
 switch (GET_CODE (src))
 {
 case NOT:
 #ifndef PCC_STATIC_STRUCT_RETURN
 	      if (aggregate_value_p (TREE_TYPE (type), type)
 		  && targetm.calls.struct_value_rtx (type, 0) == 0)
 		{
 		  tree struct_addr = build_pointer_type (TREE_TYPE (type));
-		  machine_mode mode = TYPE_MODE (struct_addr);
+		  function_arg_info arg (struct_addr, /*named=*/true);
 		  rtx reg;
 		  INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
 					nargs + 1);
-		  reg = targetm.calls.function_arg (args_so_far, mode,
+		  reg = targetm.calls.function_arg (args_so_far, arg);
-						    struct_addr, true);
+		  targetm.calls.function_arg_advance (args_so_far, arg);
-		  targetm.calls.function_arg_advance (args_so_far, mode,
-						      struct_addr, true);
 		  if (reg == NULL_RTX)
 		    {
 		      for (; link; link = XEXP (link, 1))
 			if (GET_CODE (XEXP (link, 0)) == USE
 			    && MEM_P (XEXP (XEXP (link, 0), 0)))
 #endif
 		INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
 				      nargs);
 	      if (obj_type_ref && TYPE_ARG_TYPES (type) != void_list_node)
 		{
-		  machine_mode mode;
 		  t = TYPE_ARG_TYPES (type);
-		  mode = TYPE_MODE (TREE_VALUE (t));
+		  function_arg_info arg (TREE_VALUE (t), /*named=*/true);
-		  this_arg = targetm.calls.function_arg (args_so_far, mode,
+		  this_arg = targetm.calls.function_arg (args_so_far, arg);
-							 TREE_VALUE (t), true);
 		  if (this_arg && !REG_P (this_arg))
 		    this_arg = NULL_RTX;
 		  else if (this_arg == NULL_RTX)
 		    {
 		      for (; link; link = XEXP (link, 1))
 	    rtx mem = x;
 	    cselib_val *val;
 	    if (!frame_pointer_needed)
 	      {
-		struct adjust_mem_data amd;
+		class adjust_mem_data amd;
 		amd.mem_mode = VOIDmode;
 		amd.stack_adjust = -VTI (bb)->out.stack_adjust;
 		amd.store = true;
 		mem = simplify_replace_fn_rtx (mem, NULL_RTX, adjust_mems,
 					       &amd);
 	    call_arguments
 	      = gen_rtx_EXPR_LIST (VOIDmode, item, call_arguments);
 	  }
 	if (t && t != void_list_node)
 	  {
-	    tree argtype = TREE_VALUE (t);
-	    machine_mode mode = TYPE_MODE (argtype);
 	    rtx reg;
-	    if (pass_by_reference (&args_so_far_v, mode, argtype, true))
+	    function_arg_info arg (TREE_VALUE (t), /*named=*/true);
-	      {
+	    apply_pass_by_reference_rules (&args_so_far_v, arg);
-		argtype = build_pointer_type (argtype);
+	    reg = targetm.calls.function_arg (args_so_far, arg);
-		mode = TYPE_MODE (argtype);
+	    if (TREE_CODE (arg.type) == REFERENCE_TYPE
-	      }
+		&& INTEGRAL_TYPE_P (TREE_TYPE (arg.type))
-	    reg = targetm.calls.function_arg (args_so_far, mode,
-					      argtype, true);
-	    if (TREE_CODE (argtype) == REFERENCE_TYPE
-		&& INTEGRAL_TYPE_P (TREE_TYPE (argtype))
 		&& reg
 		&& REG_P (reg)
-		&& GET_MODE (reg) == mode
+		&& GET_MODE (reg) == arg.mode
-		&& (GET_MODE_CLASS (mode) == MODE_INT
+		&& (GET_MODE_CLASS (arg.mode) == MODE_INT
-		    || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
+		    || GET_MODE_CLASS (arg.mode) == MODE_PARTIAL_INT)
 		&& REG_P (x)
 		&& REGNO (x) == REGNO (reg)
-		&& GET_MODE (x) == mode
+		&& GET_MODE (x) == arg.mode
 		&& item)
 	      {
 		machine_mode indmode
-		  = TYPE_MODE (TREE_TYPE (argtype));
+		  = TYPE_MODE (TREE_TYPE (arg.type));
 		rtx mem = gen_rtx_MEM (indmode, x);
 		cselib_val *val = cselib_lookup (mem, indmode, 0, VOIDmode);
 		if (val && cselib_preserved_value_p (val))
 		  {
 		    item = gen_rtx_CONCAT (indmode, mem, val->val_rtx);
 			    }
 			  break;
 			}
 		  }
 	      }
-	    targetm.calls.function_arg_advance (args_so_far, mode,
+	    targetm.calls.function_arg_advance (args_so_far, arg);
-						argtype, true);
 	    t = TREE_CHAIN (t);
 	  }
 }
 /* Add debug arguments.  */
 n1 = VTI (bb)->mos.length ();
 /* This will record NEXT_INSN (insn), such that we can
 insert notes before it without worrying about any
 notes that MO_USEs might emit after the insn.  */
 cui.store_p = true;
-note_stores (PATTERN (insn), add_stores, &cui);
+note_stores (insn, add_stores, &cui);
 n2 = VTI (bb)->mos.length () - 1;
 mos = VTI (bb)->mos.address ();
 /* Order the MO_VAL_USEs first (note_stores does nothing
 on DEBUG_INSNs, so there are no MO_VAL_LOCs from this
 edge e;
 int *bb_order;
 int *rc_order;
 int i;
 int htabsz = 0;
-int htabmax = PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE);
+int htabmax = param_max_vartrack_size;
 bool success = true;
 timevar_push (TV_VAR_TRACKING_DATAFLOW);
 /* Compute reverse completion order of depth first search of the CFG
 so that the data-flow runs faster.  */
 	      if (htabmax && htabsz > htabmax)
 		{
 		  if (MAY_HAVE_DEBUG_BIND_INSNS)
 		    inform (DECL_SOURCE_LOCATION (cfun->decl),
 			    "variable tracking size limit exceeded with "
-			    "-fvar-tracking-assignments, retrying without");
+			    "%<-fvar-tracking-assignments%>, retrying without");
 		  else
 		    inform (DECL_SOURCE_LOCATION (cfun->decl),
 			    "variable tracking size limit exceeded");
 		  success = false;
 		  break;
 /* Print the information about variables from hash table VARS to dump file.  */
 static void
 dump_vars (variable_table_type *vars)
 {
-if (vars->elements () > 0)
+if (!vars->is_empty ())
 {
 fprintf (dump_file, "Variables:\n");
 vars->traverse <void *, dump_var_tracking_slot> (NULL);
 }
 }
 }
 /* Structure for passing some other parameters to function
 vt_expand_loc_callback.  */
-struct expand_loc_callback_data
+class expand_loc_callback_data
 {
+public:
 /* The variables and values active at this point.  */
 variable_table_type *vars;
 /* Stack of values and debug_exprs under expansion, and their
 children.  */
 static inline rtx
 vt_expand_var_loc_chain (variable *var, bitmap regs, void *data,
 			 bool *pendrecp)
 {
-struct expand_loc_callback_data *elcd
+class expand_loc_callback_data *elcd
-= (struct expand_loc_callback_data *) data;
+= (class expand_loc_callback_data *) data;
 location_chain *loc, *next;
 rtx result = NULL;
 int first_child, result_first_child, last_child;
 bool pending_recursion;
 rtx loc_from = NULL;
 static rtx
 vt_expand_loc_callback (rtx x, bitmap regs,
 			int max_depth ATTRIBUTE_UNUSED,
 			void *data)
 {
-struct expand_loc_callback_data *elcd
+class expand_loc_callback_data *elcd
-= (struct expand_loc_callback_data *) data;
+= (class expand_loc_callback_data *) data;
 decl_or_value dv;
 variable *var;
 rtx result, subreg;
 bool pending_recursion = false;
 bool from_empty = false;
 				    GET_MODE (SUBREG_REG (x)),
 				    SUBREG_BYTE (x));
 /* Invalid SUBREGs are ok in debug info.  ??? We could try
 	 alternate expansions for the VALUE as well.  */
-if (!result)
+if (!result && GET_MODE (subreg) != VOIDmode)
 	result = gen_rtx_raw_SUBREG (GET_MODE (x), subreg, SUBREG_BYTE (x));
 return result;
 case DEBUG_EXPR:
 equivalences in VARS, updating their CUR_LOCs in the process.  */
 static rtx
 vt_expand_loc (rtx loc, variable_table_type *vars)
 {
-struct expand_loc_callback_data data;
+class expand_loc_callback_data data;
 rtx result;
 if (!MAY_HAVE_DEBUG_BIND_INSNS)
 return loc;
 in VARS, updating their CUR_LOCs in the process.  */
 static rtx
 vt_expand_1pvar (variable *var, variable_table_type *vars)
 {
-struct expand_loc_callback_data data;
+class expand_loc_callback_data data;
 rtx loc;
 gcc_checking_assert (var->onepart && var->n_var_parts == 1);
 if (!dv_changed_p (var->dv))
 			shared_hash *vars)
 {
 emit_note_data data;
 variable_table_type *htab = shared_hash_htab (vars);
-if (!changed_variables->elements ())
+if (changed_variables->is_empty ())
 return;
 if (MAY_HAVE_DEBUG_BIND_INSNS)
 process_changed_values (htab);
 vt_emit_notes (void)
 {
 basic_block bb;
 dataflow_set cur;
-gcc_assert (!changed_variables->elements ());
+gcc_assert (changed_variables->is_empty ());
 /* Free memory occupied by the out hash tables, as they aren't used
 anymore.  */
 FOR_EACH_BB_FN (bb, cfun)
 dataflow_set_clear (&VTI (bb)->out);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/var-tracking.c @ 145:1830386684a0