CbC/CbC_gcc: gcc/cbc-goto.h comparison

comparison gcc/cbc-goto.h @ 58:3aaf117db171

error at dwarf2out.c

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 15 Feb 2010 14:58:24 +0900
parents	2476ed92181e
children

comparison

equal deleted inserted replaced

-:326d9e06c2e3
+:3aaf117db171
 check_frame_offset(rtx);
 static rtx
 expand_cbc_goto (tree exp, rtx target, tree fndecl, tree funtype, tree fntype,
-		tree addr,
+tree addr,
-		int ignore,
+int ignore,
-		int flags,
+int flags,
-		int num_actuals,
+int num_actuals,
-		struct arg_data *args,
+struct arg_data *args,
-		struct args_size *args_size,
+struct args_size *args_size,
-		CUMULATIVE_ARGS args_so_far,
+CUMULATIVE_ARGS args_so_far,
-		rtx old_stack_level,
+rtx old_stack_level,
-		int reg_parm_stack_space,
+int reg_parm_stack_space,
-		int old_pending_adj,
+int old_pending_adj,
-		unsigned HOST_WIDE_INT preferred_stack_boundary,
+unsigned HOST_WIDE_INT preferred_stack_boundary,
-		unsigned HOST_WIDE_INT preferred_unit_stack_boundary,
+unsigned HOST_WIDE_INT preferred_unit_stack_boundary,
-		rtx structure_value_addr,
+rtx structure_value_addr,
-		//int structure_value_addr_parm,
+//int structure_value_addr_parm,
-		int old_inhibit_defer_pop
+int old_inhibit_defer_pop
-		)
+)
 {
 /* folowing variables is just copied from expand_call.  */
 int pass = 0;
 with stack pointer depressed.
 Also do the adjustments before a throwing call, otherwise
 exception handling can fail; PR 19225. */
 if (pending_stack_adjust >= 32
 || (pending_stack_adjust > 0
-	&& (flags & ECF_MAY_BE_ALLOCA))
+&& (flags & ECF_MAY_BE_ALLOCA))
 || (pending_stack_adjust > 0
-	&& flag_exceptions && !(flags & ECF_NOTHROW))
+&& flag_exceptions && !(flags & ECF_NOTHROW))
 || pass == 0)
 do_pending_stack_adjust ();
 if (pass == 0 && crtl->stack_protect_guard)
 and there may be a minimum required size.  When generating a sibcall
 pattern, do not round up, since we'll be re-using whatever space our
 caller provided.  */
 unadjusted_args_size
 = compute_argument_block_size (reg_parm_stack_space,
-	&adjusted_args_size,
+&adjusted_args_size,
-	fndecl, fntype,
+fndecl, fntype,
-	(pass == 0 ? 0
+(pass == 0 ? 0
-	 : preferred_stack_boundary));
+: preferred_stack_boundary));
 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
 argblock = crtl->args.internal_arg_pointer;
 argblock
 #ifdef STACK_GROWS_DOWNWARD
-	  = plus_constant (argblock, crtl->args.pretend_args_size);
+= plus_constant (argblock, crtl->args.pretend_args_size);
 #else
-	  = plus_constant (argblock, -crtl->args.pretend_args_size);
+= plus_constant (argblock, -crtl->args.pretend_args_size);
 #endif
 stored_args_map = sbitmap_alloc (args_size->constant);
 sbitmap_zero (stored_args_map);
 if (ACCUMULATE_OUTGOING_ARGS)
 {
 /* The save/restore code in store_one_arg handles all
-	 cases except one: a constructor call (including a C
+cases except one: a constructor call (including a C
-	 function returning a BLKmode struct) to initialize
+function returning a BLKmode struct) to initialize
-	 an argument.  */
+an argument.  */
 if (stack_arg_under_construction)
-	{
+{
-	  rtx push_size
+rtx push_size
-	      = GEN_INT (adjusted_args_size.constant
+= GEN_INT (adjusted_args_size.constant
-		      + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
++ (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
-				  : TREE_TYPE (fndecl))) ? 0
+: TREE_TYPE (fndecl))) ? 0
-			  : reg_parm_stack_space));
+: reg_parm_stack_space));
-	  if (old_stack_level == 0)
+if (old_stack_level == 0)
-	    {
+{
-	      emit_stack_save (SAVE_BLOCK, &old_stack_level,
+emit_stack_save (SAVE_BLOCK, &old_stack_level,
-		      NULL_RTX);
+NULL_RTX);
-	      old_stack_pointer_delta = stack_pointer_delta;
+old_stack_pointer_delta = stack_pointer_delta;
-	      old_pending_adj = pending_stack_adjust;
+old_pending_adj = pending_stack_adjust;
-	      pending_stack_adjust = 0;
+pending_stack_adjust = 0;
-	      /* stack_arg_under_construction says whether a stack
+/* stack_arg_under_construction says whether a stack
-		 arg is being constructed at the old stack level.
+arg is being constructed at the old stack level.
-		 Pushing the stack gets a clean outgoing argument
+Pushing the stack gets a clean outgoing argument
-		 block.  */
+block.  */
-	      old_stack_arg_under_construction
+old_stack_arg_under_construction
-		  = stack_arg_under_construction;
+= stack_arg_under_construction;
-	      stack_arg_under_construction = 0;
+stack_arg_under_construction = 0;
-	      /* Make a new map for the new argument list.  */
+/* Make a new map for the new argument list.  */
-	      if (stack_usage_map_buf)
+if (stack_usage_map_buf)
-		  free (stack_usage_map_buf);
+free (stack_usage_map_buf);
-	      stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
+stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
-	      stack_usage_map = stack_usage_map_buf;
+stack_usage_map = stack_usage_map_buf;
-	      memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
+memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
-	      highest_outgoing_arg_in_use = 0;
+highest_outgoing_arg_in_use = 0;
-	    }
+}
-	  allocate_dynamic_stack_space (push_size, NULL_RTX,
+allocate_dynamic_stack_space (push_size, NULL_RTX,
-		  BITS_PER_UNIT);
+BITS_PER_UNIT);
-	}
+}
 /* If argument evaluation might modify the stack pointer,
-	 copy the address of the argument list to a register.  */
+copy the address of the argument list to a register.  */
 for (i = 0; i < num_actuals; i++)
-	if (args[i].pass_on_stack)
+if (args[i].pass_on_stack)
-	  {
+{
-	    argblock = copy_addr_to_reg (argblock);
+argblock = copy_addr_to_reg (argblock);
-	    break;
+break;
-	  }
+}
 }
 compute_argument_addresses (args, argblock, num_actuals);
 /* in the case that
 a function goto codesegment.
 adjust stack space.  */
 if ( !CbC_IS_CODE_SEGMENT(TREE_TYPE(current_function_decl)) )
 //if ( !(current_function_decl&&CbC_IS_CODE_SEGMENT(current_function_decl)) )
 {
 HOST_WIDE_INT padding;
 padding = CbC_PRETENDED_STACK_SIZE -
-	  (crtl->args.size - crtl->args.pretend_args_size);
+(crtl->args.size - crtl->args.pretend_args_size);
 if (0&&padding > 0)
-	  anti_adjust_stack (GEN_INT (padding));
+anti_adjust_stack (GEN_INT (padding));
 }
 /* Now that the stack is properly aligned, pops can't safely
 be deferred during the evaluation of the arguments.  */
 NO_DEFER_POP;
 /* Precompute all register parameters.  It isn't safe to compute anything
 once we have started filling any specific hard regs.  */
 precompute_register_parameters (num_actuals, args, &reg_parm_seen);
 if (CALL_EXPR_STATIC_CHAIN (exp))
 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
 else
 static_chain_value = 0;
 /* parallel assignment  */
 store_order = alloca (num_actuals * sizeof (int));
 memset (store_order, 0, num_actuals * sizeof (int));
 /* fill the arg[i]->exprs. */
 for (i = 0; i < num_actuals; i++)
 {
 if (args[i].reg == 0 || args[i].pass_on_stack)
-	{
+{
-	  preexpand_argument_expr (&args[i],
+preexpand_argument_expr (&args[i],
-		  adjusted_args_size.var != 0);
+adjusted_args_size.var != 0);
-	}
+}
 }
 /* push overlapped argument to stack.  */
 push_overlaps(args, num_actuals);
 /* push arguments in the order .  */
 for (i = 0; i < num_actuals; i++)
 {
 if (args[store_order[i]].reg == 0
-	      || args[store_order[i]].pass_on_stack
+|| args[store_order[i]].pass_on_stack
-	      || args[store_order[i]].partial!=0 )
+|| args[store_order[i]].partial!=0 )
-	{
+{
-	  expand_one_arg_push (&args[store_order[i]], argblock, flags,
+expand_one_arg_push (&args[store_order[i]], argblock, flags,
-		  adjusted_args_size.var != 0,
+adjusted_args_size.var != 0,
-		  reg_parm_stack_space);
+reg_parm_stack_space);
-	}
+}
 }
 /* If register arguments require space on the stack and stack space
 was not preallocated, allocate stack space here for arguments
 //&& must_preallocate == 0 && reg_parm_stack_space > 0)
 //anti_adjust_stack (GEN_INT (reg_parm_stack_space));
 #endif
 /*   */
-funexp = prepare_call_address (funexp, static_chain_value,
+funexp = prepare_call_address (fndecl, funexp, static_chain_value,
 &call_fusage, reg_parm_seen, pass == 0);
 /* store args into register.  */
 load_register_parameters (args, num_actuals, &call_fusage, flags,
 //pass == 0, &sibcall_failure);
-			   0, NULL);
+0, NULL);
 /* Save a pointer to the last insn before the call, so that we can
 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,
-	void_type_node, 1);
+void_type_node, 1);
 else
 #endif
 next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
-	void_type_node, 1);
+void_type_node, 1);
 /* All arguments and registers used for the call must be set up by
 now!  */
 /* Stack must be properly aligned now.  */
 gcc_assert (!pass
 || !(stack_pointer_delta % preferred_unit_stack_boundary));
 #if 0
 /* store environment.  */
 if ( env_tree!=NULL )
 {
 emit_insn (gen_rtx_CLOBBER (VOIDmode,
-		  gen_rtx_MEM (BLKmode,
+gen_rtx_MEM (BLKmode,
-		      hard_frame_pointer_rtx)));
+hard_frame_pointer_rtx)));
 emit_move_insn (hard_frame_pointer_rtx, env_rtx);
 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 //pop_temp_slots ();
 emit_indirect_jump (funexp);
 {
 push_temp_slots();
 preserve_temp_slots(funexp);
 /* Generate the actual call instruction.  */
 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
-	  adjusted_args_size.constant, struct_value_size,
+adjusted_args_size.constant, struct_value_size,
-	  //next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
+//next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
-	  next_arg_reg, valreg, 0, call_fusage,
+next_arg_reg, valreg, 0, call_fusage,
-	  flags, & args_so_far);
+flags, & args_so_far);
 pop_temp_slots();
 }
 else
 {
 /* Generate the actual call instruction.  */
 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
 adjusted_args_size.constant, struct_value_size,
 //next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
 next_arg_reg, valreg, 0, call_fusage,
 flags, & args_so_far);
 }
 /* If a non-BLKmode value is returned at the most significant end
 of a register, shift the register right by the appropriate amount
 and update VALREG accordingly.  BLKmode values are handled by the
 && !pcc_struct_value
 && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
 && targetm.calls.return_in_msb (TREE_TYPE (exp)))
 {
 if (shift_return_value (TYPE_MODE (TREE_TYPE (exp)), false, valreg))
-	  sibcall_failure = 1;
+sibcall_failure = 1;
 valreg = gen_rtx_REG (TYPE_MODE (TREE_TYPE (exp)), REGNO (valreg));
 }
 /* For calls to `setjmp', etc., inform flow.c it should complain
 inform flow that control does not fall through.  */
 if ((flags & ECF_NORETURN) || pass == 0)
 {
 /* The barrier must be emitted
-	 immediately after the CALL_INSN.  Some ports emit more
+immediately after the CALL_INSN.  Some ports emit more
-	 than just a CALL_INSN above, so we must search for it here.  */
+than just a CALL_INSN above, so we must search for it here.  */
 rtx last = get_last_insn ();
 while (!CALL_P (last))
-	{
+{
-	  last = PREV_INSN (last);
+last = PREV_INSN (last);
-	  /* There was no CALL_INSN?  */
+/* There was no CALL_INSN?  */
-	  gcc_assert (last != before_call);
+gcc_assert (last != before_call);
-	}
+}
 emit_barrier_after (last);
 /* Stack adjustments after a noreturn call are dead code.
-	 However when NO_DEFER_POP is in effect, we must preserve
+However when NO_DEFER_POP is in effect, we must preserve
-	 stack_pointer_delta.  */
+stack_pointer_delta.  */
 if (inhibit_defer_pop == 0)
-	{
+{
-	  stack_pointer_delta = old_stack_allocated;
+stack_pointer_delta = old_stack_allocated;
-	  pending_stack_adjust = 0;
+pending_stack_adjust = 0;
-	}
+}
 }
 /* If value type not void, return an rtx for the value.  */
 if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
 || ignore)
 target = const0_rtx;
-if (targetm.calls.promote_function_return(funtype))
+tree type = TREE_TYPE (exp);
+int unsignedp = TYPE_UNSIGNED (type);
+/* if (targetm.calls.promote_function_return(funtype))*/
+if (promote_function_mode(type, TYPE_MODE (type), &unsignedp,
+fndecl ? TREE_TYPE (fndecl) : fntype, 0))
 {
 /* If we promoted this return value, make the proper SUBREG.
-	 TARGET might be const0_rtx here, so be careful.  */
+TARGET might be const0_rtx here, so be careful.  */
 if (REG_P (target)
-	      && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
+&& TYPE_MODE (TREE_TYPE (exp)) != BLKmode
-	      && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
+&& GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
-	{
+{
-	  tree type = TREE_TYPE (exp);
+int offset = 0;
-	  int unsignedp = TYPE_UNSIGNED (type);
+enum machine_mode pmode;
-	  int offset = 0;
-	  enum machine_mode pmode;
+pmode = promote_mode (type, TYPE_MODE (type), &unsignedp);//, 1);
+/* If we don't promote as expected, something is wrong.  */
-	  pmode = promote_mode (type, TYPE_MODE (type), &unsignedp, 1);
+gcc_assert (GET_MODE (target) == pmode);
-	  /* If we don't promote as expected, something is wrong.  */
-	  gcc_assert (GET_MODE (target) == pmode);
+if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
+&& (GET_MODE_SIZE (GET_MODE (target))
-	  if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
+> GET_MODE_SIZE (TYPE_MODE (type))))
-		  && (GET_MODE_SIZE (GET_MODE (target))
+{
-		      > GET_MODE_SIZE (TYPE_MODE (type))))
+offset = GET_MODE_SIZE (GET_MODE (target))
-	    {
+- GET_MODE_SIZE (TYPE_MODE (type));
-	      offset = GET_MODE_SIZE (GET_MODE (target))
+if (! BYTES_BIG_ENDIAN)
-		  - GET_MODE_SIZE (TYPE_MODE (type));
+offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
-	      if (! BYTES_BIG_ENDIAN)
+else if (! WORDS_BIG_ENDIAN)
-		  offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
+offset %= UNITS_PER_WORD;
-	      else if (! WORDS_BIG_ENDIAN)
+}
-		  offset %= UNITS_PER_WORD;
+target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
-	    }
+SUBREG_PROMOTED_VAR_P (target) = 1;
-	  target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
+SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
-	  SUBREG_PROMOTED_VAR_P (target) = 1;
+}
-	  SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
-	}
 }
 /* If size of args is variable or this was a constructor call for a stack
 argument, restore saved stack-pointer value.  */
 }
 static void
 preexpand_argument_expr (struct arg_data *arg,
-	       int variable_size ATTRIBUTE_UNUSED)
+int variable_size ATTRIBUTE_UNUSED)
 {
 tree pval = arg->tree_value;
 rtx reg = 0;
 int partial = 0;
 if (arg->pass_on_stack)
 stack_arg_under_construction++;
 arg->value = expand_expr (pval,
 (partial
 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
 ? NULL_RTX : arg->stack,
 VOIDmode, EXPAND_STACK_PARM);
 /* If we are promoting object (or for any other reason) the mode
 doesn't agree, convert the mode.  */
 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
-	arg->value, arg->unsignedp);
+arg->value, arg->unsignedp);
 if (arg->pass_on_stack)
 stack_arg_under_construction--;
 arg->exprs = get_insns ();
 return ;
 }
 static int
 expand_one_arg_push (struct arg_data *arg, rtx argblock, int flags,
-	       int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
+int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
 {
 tree pval = arg->tree_value;
 int used = 0;
 int i, lower_bound = 0, upper_bound = 0;
 rtx reg = 0;
 else if (arg->mode != BLKmode)
 {
 int size;
 /* Argument is a scalar, not entirely passed in registers.
-	 (If part is passed in registers, arg->partial says how much
+(If part is passed in registers, arg->partial says how much
-	 and emit_push_insn will take care of putting it there.)
+and emit_push_insn will take care of putting it there.)
-	 Push it, and if its size is less than the
+Push it, and if its size is less than the
-	 amount of space allocated to it,
+amount of space allocated to it,
-	 also bump stack pointer by the additional space.
+also bump stack pointer by the additional space.
-	 Note that in C the default argument promotions
+Note that in C the default argument promotions
-	 will prevent such mismatches.  */
+will prevent such mismatches.  */
 size = GET_MODE_SIZE (arg->mode);
 /* Compute how much space the push instruction will push.
-	 On many machines, pushing a byte will advance the stack
+On many machines, pushing a byte will advance the stack
-	 pointer by a halfword.  */
+pointer by a halfword.  */
 #ifdef PUSH_ROUNDING
 size = PUSH_ROUNDING (size);
 #endif
 used = size;
 /* Compute how much space the argument should get:
-	 round up to a multiple of the alignment for arguments.  */
+round up to a multiple of the alignment for arguments.  */
 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
-	  used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
+used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
-		      / (PARM_BOUNDARY / BITS_PER_UNIT))
+/ (PARM_BOUNDARY / BITS_PER_UNIT))
-		  * (PARM_BOUNDARY / BITS_PER_UNIT));
+* (PARM_BOUNDARY / BITS_PER_UNIT));
 /* This isn't already where we want it on the stack, so put it there.
-	 This can either be done with push or copy insns.  */
+This can either be done with push or copy insns.  */
 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
-	      PARM_BOUNDARY, partial, reg, used - size, argblock,
+PARM_BOUNDARY, partial, reg, used - size, argblock,
-	      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
+ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
-	      ARGS_SIZE_RTX (arg->locate.alignment_pad));
+ARGS_SIZE_RTX (arg->locate.alignment_pad));
 /* Unless this is a partially-in-register argument, the argument is now
-	 in the stack.  */
+in the stack.  */
 if (partial == 0)
-	  arg->value = arg->stack;
+arg->value = arg->stack;
 }
 else
 {
 /* BLKmode, at least partly to be pushed.  */
 unsigned int parm_align;
 int excess;
 rtx size_rtx;
 /* Pushing a nonscalar.
-	 If part is passed in registers, PARTIAL says how much
+If part is passed in registers, PARTIAL says how much
-	 and emit_push_insn will take care of putting it there.  */
+and emit_push_insn will take care of putting it there.  */
 /* Round its size up to a multiple
-	 of the allocation unit for arguments.  */
+of the allocation unit for arguments.  */
 if (arg->locate.size.var != 0)
-	{
+{
-	  excess = 0;
+excess = 0;
-	  size_rtx = ARGS_SIZE_RTX (arg->locate.size);
+size_rtx = ARGS_SIZE_RTX (arg->locate.size);
-	}
+}
 else
-	{
+{
-	  /* PUSH_ROUNDING has no effect on us, because emit_push_insn
+/* PUSH_ROUNDING has no effect on us, because emit_push_insn
-	     for BLKmode is careful to avoid it.  */
+for BLKmode is careful to avoid it.  */
-	  excess = (arg->locate.size.constant
+excess = (arg->locate.size.constant
-		  - int_size_in_bytes (TREE_TYPE (pval))
+- int_size_in_bytes (TREE_TYPE (pval))
-		  + partial);
++ partial);
-	  size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
+size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
-		  NULL_RTX, TYPE_MODE (sizetype), 0);
+NULL_RTX, TYPE_MODE (sizetype), 0);
-	}
+}
 parm_align = arg->locate.boundary;
 /* When an argument is padded down, the block is aligned to
-	 PARM_BOUNDARY, but the actual argument isn't.  */
+PARM_BOUNDARY, but the actual argument isn't.  */
 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
-	{
+{
-	  if (arg->locate.size.var)
+if (arg->locate.size.var)
-	      parm_align = BITS_PER_UNIT;
+parm_align = BITS_PER_UNIT;
-	  else if (excess)
+else if (excess)
-	    {
+{
-	      unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
+unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
-	      parm_align = MIN (parm_align, excess_align);
+parm_align = MIN (parm_align, excess_align);
-	    }
+}
-	}
+}
 if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
-	{
+{
-	  /* emit_push_insn might not work properly if arg->value and
+/* emit_push_insn might not work properly if arg->value and
-	     argblock + arg->locate.offset areas overlap.  */
+argblock + arg->locate.offset areas overlap.  */
-	  rtx x = arg->value;
+rtx x = arg->value;
-	  int i = 0;
+int i = 0;
-	  if (XEXP (x, 0) == crtl->args.internal_arg_pointer
+if (XEXP (x, 0) == crtl->args.internal_arg_pointer
-		  || (GET_CODE (XEXP (x, 0)) == PLUS
+|| (GET_CODE (XEXP (x, 0)) == PLUS
-		      && XEXP (XEXP (x, 0), 0) ==
+&& XEXP (XEXP (x, 0), 0) ==
-		      crtl->args.internal_arg_pointer
+crtl->args.internal_arg_pointer
-		      && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
+&& GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
-	    {
+{
-	      if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
+if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
-		  i = INTVAL (XEXP (XEXP (x, 0), 1));
+i = INTVAL (XEXP (XEXP (x, 0), 1));
-	      /* expand_call should ensure this.  */
+/* expand_call should ensure this.  */
-	      gcc_assert (!arg->locate.offset.var
+gcc_assert (!arg->locate.offset.var
-		      && GET_CODE (size_rtx) == CONST_INT);
+&& GET_CODE (size_rtx) == CONST_INT);
-	    }
+}
-	}
+}
 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
-	      parm_align, partial, reg, excess, argblock,
+parm_align, partial, reg, excess, argblock,
-	      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
+ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
-	      ARGS_SIZE_RTX (arg->locate.alignment_pad));
+ARGS_SIZE_RTX (arg->locate.alignment_pad));
 /* Unless this is a partially-in-register argument, the argument is now
-	 in the stack.
+in the stack.
-	 ??? Unlike the case above, in which we want the actual
+??? Unlike the case above, in which we want the actual
-	 address of the data, so that we can load it directly into a
+address of the data, so that we can load it directly into a
-	 register, here we want the address of the stack slot, so that
+register, here we want the address of the stack slot, so that
-	 it's properly aligned for word-by-word copying or something
+it's properly aligned for word-by-word copying or something
-	 like that.  It's not clear that this is always correct.  */
+like that.  It's not clear that this is always correct.  */
 if (partial == 0)
-	  arg->value = arg->stack_slot;
+arg->value = arg->stack_slot;
 }
 if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
 {
 tree type = TREE_TYPE (arg->tree_value);
 arg->parallel_value
-	  = emit_group_load_into_temps (arg->reg, arg->value, type,
+= emit_group_load_into_temps (arg->reg, arg->value, type,
-		  int_size_in_bytes (type));
+int_size_in_bytes (type));
 }
 /* Mark all slots this store used.  */
 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
 && argblock && ! variable_size && arg->stack)
 static void
 determine_order(int *order, int num_actuals)
 {
 int i;
 for (i=0; i<num_actuals; i++)
 order[i] = num_actuals-i-1;
 return;
 }
 static void
 push_overlaps(struct arg_data *args, int num_actuals)
 if ( (src_offset=check_frame_offset(args[i].value)) < 0 ) continue;
 /* $BB`Hr(B  */
 temp = assign_temp(args[i].tree_value, 1, 0, 0);
 if ( args[i].mode==BLKmode )
-	  emit_block_move ( temp, args[i].value, ARGS_SIZE_RTX(args[i].locate.size), 0 );
+emit_block_move ( temp, args[i].value, ARGS_SIZE_RTX(args[i].locate.size), 0 );
 else
-	  emit_move_insn ( temp, args[i].value );
+emit_move_insn ( temp, args[i].value );
 args[i].value = temp;
 }
 return;
 }
 check_frame_offset(rtx x)
 {
 int i;
 rtx addr;
 if ( !x || !MEM_P(x))
 return -1;
 addr = XEXP(x, 0);
 if (addr == crtl->args.internal_arg_pointer)
 i = 0;
 else if (GET_CODE (addr) == PLUS
-	  && XEXP (addr, 0) == crtl->args.internal_arg_pointer
+&& XEXP (addr, 0) == crtl->args.internal_arg_pointer
-	  && GET_CODE (XEXP (addr, 1)) == CONST_INT)
+&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
 i = INTVAL (XEXP (addr, 1));
 else if (GET_CODE (addr) == PLUS
-	  && GET_CODE (XEXP (addr, 0)) == CONST_INT
+&& GET_CODE (XEXP (addr, 0)) == CONST_INT
-	  && XEXP (addr, 1) == crtl->args.internal_arg_pointer )
+&& XEXP (addr, 1) == crtl->args.internal_arg_pointer )
 i = INTVAL (XEXP (addr, 0));
 else
 return -1;
 return i;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cbc-goto.h @ 58:3aaf117db171