CbC/CbC_gcc: gcc/calls.c comparison

comparison gcc/calls.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	1b10fe6932e1 04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "expr.h"
 #include "optabs.h"
 #include "libfuncs.h"
 #include "function.h"
 #include "regs.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "output.h"
 #include "tm_p.h"
 #include "timevar.h"
 #include "sbitmap.h"
 #include "langhooks.h"
 /* Location on the stack at which parameter should be stored.  The store
 has already been done if STACK == VALUE.  */
 rtx stack;
 /* Location on the stack of the start of this argument slot.  This can
 differ from STACK if this arg pads downward.  This location is known
-to be aligned to FUNCTION_ARG_BOUNDARY.  */
+to be aligned to TARGET_FUNCTION_ARG_BOUNDARY.  */
 rtx stack_slot;
 /* Place that this stack area has been saved, if needed.  */
 rtx save_area;
 /* If an argument's alignment does not permit direct copying into registers,
 copy in smaller-sized pieces into pseudos.  These are stored in a
 /* Generate instructions to call function FUNEXP,
 and optionally pop the results.
 The CALL_INSN is the first insn generated.
 FNDECL is the declaration node of the function.  This is given to the
-macro RETURN_POPS_ARGS to determine whether this function pops its own args.
+hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
+its own args.
-FUNTYPE is the data type of the function.  This is given to the macro
-RETURN_POPS_ARGS to determine whether this function pops its own args.
+FUNTYPE is the data type of the function.  This is given to the hook
-We used to allow an identifier for library functions, but that doesn't
+TARGET_RETURN_POPS_ARGS to determine whether this function pops its
-work when the return type is an aggregate type and the calling convention
+own args.  We used to allow an identifier for library functions, but
-says that the pointer to this aggregate is to be popped by the callee.
+that doesn't work when the return type is an aggregate type and the
+calling convention says that the pointer to this aggregate is to be
+popped by the callee.
 STACK_SIZE is the number of bytes of arguments on the stack,
 ROUNDED_STACK_SIZE is that number rounded up to
 PREFERRED_STACK_BOUNDARY; zero if the size is variable.  This is
 both to put into the call insn and to generate explicit popping
 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
 It is zero if this call doesn't want a structure value.
 NEXT_ARG_REG is the rtx that results from executing
-FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
+targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
 just after all the args have had their registers assigned.
 This could be whatever you like, but normally it is the first
 arg-register beyond those used for args in this call,
 or 0 if all the arg-registers are used in this call.
 It is passed on to `gen_call' so you can put this info in the call insn.
 	     CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED)
 {
 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
 rtx call_insn;
 int already_popped = 0;
-HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
+HOST_WIDE_INT n_popped
+= targetm.calls.return_pops_args (fndecl, funtype, stack_size);
 #ifdef CALL_POPS_ARGS
 n_popped += CALL_POPS_ARGS (* args_so_far);
 #endif
 /* The function exp may have the `returns_twice' attribute.  */
 if (DECL_IS_RETURNS_TWICE (exp))
 	flags |= ECF_RETURNS_TWICE;
 /* Process the pure and const attributes.  */
-if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
+if (TREE_READONLY (exp))
 	flags |= ECF_CONST;
 if (DECL_PURE_P (exp))
 	flags |= ECF_PURE;
 if (DECL_LOOPING_CONST_OR_PURE_P (exp))
 	flags |= ECF_LOOPING_CONST_OR_PURE;
 if (DECL_IS_NOVOPS (exp))
 	flags |= ECF_NOVOPS;
+if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
+	flags |= ECF_LEAF;
 if (TREE_NOTHROW (exp))
 	flags |= ECF_NOTHROW;
 flags = special_function_p (exp, flags);
 }
-else if (TYPE_P (exp) && TYPE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
+else if (TYPE_P (exp) && TYPE_READONLY (exp))
 flags |= ECF_CONST;
 if (TREE_THIS_VOLATILE (exp))
-flags |= ECF_NORETURN;
+{
+flags |= ECF_NORETURN;
+if (flags & (ECF_CONST|ECF_PURE))
+	flags |= ECF_LOOPING_CONST_OR_PURE;
+}
 return flags;
 }
 /* Detect flags from a CALL_EXPR.  */
 	    rtx reg = gen_reg_rtx (word_mode);
 	    rtx word = operand_subword_force (args[i].value, j, BLKmode);
 	    int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
 	    args[i].aligned_regs[j] = reg;
-	    word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
+	    word = extract_bit_field (word, bitsize, 0, 1, false, NULL_RTX,
 				      word_mode, word_mode);
 	    /* There is no need to restrict this code to loading items
 	       in TYPE_ALIGN sized hunks.  The bitfield instructions can
 	       load up entire word sized registers efficiently.
 		     for it.  */
 		  rtx size_rtx = expr_size (args[i].tree_value);
 		  if (*old_stack_level == 0)
 		    {
-		      emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX);
+		      emit_stack_save (SAVE_BLOCK, old_stack_level);
 		      *old_pending_adj = pending_stack_adjust;
 		      pending_stack_adjust = 0;
 		    }
-		  copy = gen_rtx_MEM (BLKmode,
+		  /* We can pass TRUE as the 4th argument because we just
-				      allocate_dynamic_stack_space
+		     saved the stack pointer and will restore it right after
-				      (size_rtx, NULL_RTX, TYPE_ALIGN (type)));
+		     the call.  */
+		  copy = allocate_dynamic_stack_space (size_rtx,
+						       TYPE_ALIGN (type),
+						       TYPE_ALIGN (type),
+						       true);
+		  copy = gen_rtx_MEM (BLKmode, copy);
 		  set_mem_attributes (copy, type, 1);
 		}
 	      else
 		copy = assign_temp (type, 0, 1, 0);
 				    fndecl ? TREE_TYPE (fndecl) : fntype, 0);
 args[i].unsignedp = unsignedp;
 args[i].mode = mode;
-args[i].reg = FUNCTION_ARG (*args_so_far, mode, type,
+args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
-				  argpos < n_named_args);
+						argpos < n_named_args);
-#ifdef FUNCTION_INCOMING_ARG
 /* If this is a sibling call and the machine has register windows, the
 	 register window has to be unwinded before calling the routine, so
 	 arguments have to go into the incoming registers.  */
-args[i].tail_call_reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type,
+if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
-						     argpos < n_named_args);
+	args[i].tail_call_reg
-#else
+	  = targetm.calls.function_incoming_arg (args_so_far, mode, type,
-args[i].tail_call_reg = args[i].reg;
+						 argpos < n_named_args);
-#endif
+else
+	args[i].tail_call_reg = args[i].reg;
 if (args[i].reg)
 	args[i].partial
 	  = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
 					     argpos < n_named_args);
 	ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
 /* Increment ARGS_SO_FAR, which has info about which arg-registers
 	 have been used, etc.  */
-FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type,
+targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
-			    argpos < n_named_args);
+					  type, argpos < n_named_args);
 }
 }
 /* Update ARGS_SIZE to contain the total size for the argument block.
 Return the original constant component of the argument block's size.
 	  else if (partial == 0 || args[i].pass_on_stack)
 	    {
 	      rtx mem = validize_mem (args[i].value);
-	      /* Check for overlap with already clobbered argument area.  */
+	      /* Check for overlap with already clobbered argument area,
+	         providing that this has non-zero size.  */
 	      if (is_sibcall
-		  && mem_overlaps_already_clobbered_arg_p (XEXP (args[i].value, 0),
+		  && (size == 0
-							   size))
+		      || mem_overlaps_already_clobbered_arg_p
+					   (XEXP (args[i].value, 0), size)))
 		*sibcall_failure = 1;
 	      /* Handle a BLKmode that needs shifting.  */
 	      if (nregs == 1 && size < UNITS_PER_WORD
 #ifdef BLOCK_REG_PADDING
 {
 rtx new_rtx;
 if (REG_P (x)
 && HARD_REGISTER_P (x)
-&& CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (x))))
+&& targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
 {
 /* Make sure that we generate a REG rather than a CONCAT.
 	 Moves into CONCATs can need nontrivial instructions,
 	 and the whole point of this function is to avoid
 	 using the hard register directly in such a situation.  */
 	 stack allocated by our caller.  */
 || args_size.constant > (crtl->args.size
 			       - crtl->args.pretend_args_size)
 /* If the callee pops its own arguments, then it must pop exactly
 	 the same number of arguments as the current function.  */
-|| (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
+|| (targetm.calls.return_pops_args (fndecl, funtype, args_size.constant)
-	  != RETURN_POPS_ARGS (current_function_decl,
+	  != targetm.calls.return_pops_args (current_function_decl,
-			       TREE_TYPE (current_function_decl),
+					     TREE_TYPE (current_function_decl),
-			       crtl->args.size))
+					     crtl->args.size))
 || !lang_hooks.decls.ok_for_sibcall (fndecl))
 try_tail_call = 0;
 /* Check if caller and callee disagree in promotion of function
 return value.  */
 	 make space for all args right now.  */
 else if (adjusted_args_size.var != 0)
 	{
 	  if (old_stack_level == 0)
 	    {
-	      emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
+	      emit_stack_save (SAVE_BLOCK, &old_stack_level);
 	      old_stack_pointer_delta = stack_pointer_delta;
 	      old_pending_adj = pending_stack_adjust;
 	      pending_stack_adjust = 0;
 	      /* stack_arg_under_construction says whether a stack arg is
 		 being constructed at the old stack level.  Pushing the stack
 		 gets a clean outgoing argument block.  */
 	      old_stack_arg_under_construction = stack_arg_under_construction;
 	      stack_arg_under_construction = 0;
 	    }
 	  argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
+	  if (flag_stack_usage)
+	    current_function_has_unbounded_dynamic_stack_size = 1;
 	}
 else
 	{
 	  /* Note that we must go through the motions of allocating an argument
 	     block even if the size is zero because we may be storing args
 			   + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
 			   					      : TREE_TYPE (fndecl))) ? 0
 			      : reg_parm_stack_space));
 	      if (old_stack_level == 0)
 		{
-		  emit_stack_save (SAVE_BLOCK, &old_stack_level,
+		  emit_stack_save (SAVE_BLOCK, &old_stack_level);
-				   NULL_RTX);
 		  old_stack_pointer_delta = stack_pointer_delta;
 		  old_pending_adj = pending_stack_adjust;
 		  pending_stack_adjust = 0;
 		  /* stack_arg_under_construction says whether a stack
 		     arg is being constructed at the old stack level.
 		    free (stack_usage_map_buf);
 		  stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
 		  stack_usage_map = stack_usage_map_buf;
 		  highest_outgoing_arg_in_use = 0;
 		}
-	      allocate_dynamic_stack_space (push_size, NULL_RTX,
+	      /* We can pass TRUE as the 4th argument because we just
-					    BITS_PER_UNIT);
+		 saved the stack pointer and will restore it right after
+		 the call.  */
+	      allocate_dynamic_stack_space (push_size, 0,
+					    BIGGEST_ALIGNMENT, true);
 	    }
 	  /* If argument evaluation might modify the stack pointer,
 	     copy the address of the argument list to a register.  */
 	  for (i = 0; i < num_actuals; i++)
 	}
 /* Now that the stack is properly aligned, pops can't safely
 	 be deferred during the evaluation of the arguments.  */
 NO_DEFER_POP;
+/* Record the maximum pushed stack space size.  We need to delay
+	 doing it this far to take into account the optimization done
+	 by combine_pending_stack_adjustment_and_call.  */
+if (flag_stack_usage
+	  && !ACCUMULATE_OUTGOING_ARGS
+	  && pass
+	  && adjusted_args_size.var == 0)
+	{
+	  int pushed = adjusted_args_size.constant + pending_stack_adjust;
+	  if (pushed > current_function_pushed_stack_size)
+	    current_function_pushed_stack_size = pushed;
+	}
 funexp = rtx_for_function_call (fndecl, addr);
 /* Figure out the register where the value, if any, will come back.  */
 valreg = 0;
 if (TYPE_MODE (rettype) != VOIDmode
 	 later safely search backwards to find the CALL_INSN.  */
 before_call = get_last_insn ();
 /* Set up next argument register.  For sibling calls on machines
 	 with register windows this should be the incoming register.  */
-#ifdef FUNCTION_INCOMING_ARG
 if (pass == 0)
-	next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
+	next_arg_reg = targetm.calls.function_incoming_arg (&args_so_far,
-					      void_type_node, 1);
+							    VOIDmode,
+							    void_type_node,
+							    true);
 else
-#endif
+	next_arg_reg = targetm.calls.function_arg (&args_so_far,
-	next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
+						   VOIDmode, void_type_node,
-				     void_type_node, 1);
+						   true);
 /* All arguments and registers used for the call must be set up by
 	 now!  */
 /* Stack must be properly aligned now.  */
 /* If size of args is variable or this was a constructor call for a stack
 	 argument, restore saved stack-pointer value.  */
 if (old_stack_level)
 	{
-	  emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
+	  emit_stack_restore (SAVE_BLOCK, old_stack_level);
 	  stack_pointer_delta = old_stack_pointer_delta;
 	  pending_stack_adjust = old_pending_adj;
 	  old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
 	  stack_arg_under_construction = old_stack_arg_under_construction;
 	  highest_outgoing_arg_in_use = initial_highest_arg_in_use;
 argvec[count].value = addr;
 argvec[count].mode = Pmode;
 argvec[count].partial = 0;
-argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
+argvec[count].reg = targetm.calls.function_arg (&args_so_far,
+						      Pmode, NULL_TREE, true);
 gcc_assert (targetm.calls.arg_partial_bytes (&args_so_far, Pmode,
 						   NULL_TREE, 1) == 0);
 locate_and_pad_parm (Pmode, NULL_TREE,
 #ifdef STACK_PARMS_IN_REG_PARM_AREA
 if (argvec[count].reg == 0 || argvec[count].partial != 0
 	  || reg_parm_stack_space > 0)
 	args_size.constant += argvec[count].locate.size.constant;
-FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
+targetm.calls.function_arg_advance (&args_so_far, Pmode, (tree) 0, true);
 count++;
 }
 for (; count < nargs; count++)
 	}
 argvec[count].value = val;
 argvec[count].mode = mode;
-argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
+argvec[count].reg = targetm.calls.function_arg (&args_so_far, mode,
+						      NULL_TREE, true);
 argvec[count].partial
 	= targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL_TREE, 1);
 locate_and_pad_parm (mode, NULL_TREE,
 if (argvec[count].reg == 0 || argvec[count].partial != 0
 	  || reg_parm_stack_space > 0)
 	args_size.constant += argvec[count].locate.size.constant;
-FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
+targetm.calls.function_arg_advance (&args_so_far, mode, (tree) 0, true);
 }
 /* If this machine requires an external definition for library
 functions, write one out.  */
 assemble_external_libcall (fun);
 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
 args_size.constant -= reg_parm_stack_space;
 if (args_size.constant > crtl->outgoing_args_size)
 crtl->outgoing_args_size = args_size.constant;
+if (flag_stack_usage && !ACCUMULATE_OUTGOING_ARGS)
+{
+int pushed = args_size.constant + pending_stack_adjust;
+if (pushed > current_function_pushed_stack_size)
+	current_function_pushed_stack_size = pushed;
+}
 if (ACCUMULATE_OUTGOING_ARGS)
 {
 /* Since the stack pointer will never be pushed, it is possible for
 	 the evaluation of a parm to clobber something we have already
 emit_call_1 (fun, NULL,
 	       get_identifier (XSTR (orgfun, 0)),
 	       build_function_type (tfom, NULL_TREE),
 	       original_args_size.constant, args_size.constant,
 	       struct_value_size,
-	       FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
+	       targetm.calls.function_arg (&args_so_far,
+					   VOIDmode, void_type_node, true),
 	       valreg,
 	       old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
 that it should complain if nonvolatile values are live.  For

Mercurial > hg > CbC > CbC_gcc

comparison gcc/calls.c @ 67:f6334be47118