--- a/gcc/cbc-goto.h	Mon Feb 15 00:54:17 2010 +0900
+++ b/gcc/cbc-goto.h	Mon Feb 15 14:58:24 2010 +0900
@@ -17,22 +17,22 @@
 
 static rtx
 expand_cbc_goto (tree exp, rtx target, tree fndecl, tree funtype, tree fntype,
-		tree addr,
-		int ignore,
-		int flags,
-		int num_actuals,
-		struct arg_data *args,
-		struct args_size *args_size,
-		CUMULATIVE_ARGS args_so_far,
-		rtx old_stack_level,
-		int reg_parm_stack_space,
-		int old_pending_adj,
-		unsigned HOST_WIDE_INT preferred_stack_boundary,
-		unsigned HOST_WIDE_INT preferred_unit_stack_boundary,
-		rtx structure_value_addr,
-		//int structure_value_addr_parm,
-		int old_inhibit_defer_pop
-		)
+                 tree addr,
+                 int ignore,
+                 int flags,
+                 int num_actuals,
+                 struct arg_data *args,
+                 struct args_size *args_size,
+                 CUMULATIVE_ARGS args_so_far,
+                 rtx old_stack_level,
+                 int reg_parm_stack_space,
+                 int old_pending_adj,
+                 unsigned HOST_WIDE_INT preferred_stack_boundary,
+                 unsigned HOST_WIDE_INT preferred_unit_stack_boundary,
+                 rtx structure_value_addr,
+                 //int structure_value_addr_parm,
+                 int old_inhibit_defer_pop
+                 )
 {
 
   /* folowing variables is just copied from expand_call.  */
@@ -101,9 +101,9 @@
      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 ();
 
@@ -119,20 +119,20 @@
      caller provided.  */
   unadjusted_args_size
     = compute_argument_block_size (reg_parm_stack_space,
-	&adjusted_args_size,
-	fndecl, fntype,
-	(pass == 0 ? 0
-	 : preferred_stack_boundary));
+                                   &adjusted_args_size,
+                                   fndecl, fntype,
+                                   (pass == 0 ? 0
+                                    : preferred_stack_boundary));
 
   old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
 
-      argblock = crtl->args.internal_arg_pointer;
+  argblock = crtl->args.internal_arg_pointer;
 
-      argblock
+  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
 
 
@@ -143,65 +143,65 @@
   if (ACCUMULATE_OUTGOING_ARGS)
     {
       /* The save/restore code in store_one_arg handles all
-	 cases except one: a constructor call (including a C
-	 function returning a BLKmode struct) to initialize
-	 an argument.  */
+         cases except one: a constructor call (including a C
+         function returning a BLKmode struct) to initialize
+         an argument.  */
       if (stack_arg_under_construction)
-	{
-	  rtx push_size
-	      = GEN_INT (adjusted_args_size.constant
-		      + (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,
-		      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.
-		 Pushing the stack gets a clean outgoing argument
-		 block.  */
-	      old_stack_arg_under_construction
-		  = stack_arg_under_construction;
-	      stack_arg_under_construction = 0;
-	      /* Make a new map for the new argument list.  */
-	      if (stack_usage_map_buf)
-		  free (stack_usage_map_buf);
-	      stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
-	      stack_usage_map = stack_usage_map_buf;
-	      memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
-	      highest_outgoing_arg_in_use = 0;
-	    }
-	  allocate_dynamic_stack_space (push_size, NULL_RTX,
-		  BITS_PER_UNIT);
-	}
+        {
+          rtx push_size
+            = GEN_INT (adjusted_args_size.constant
+                       + (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,
+                               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.
+                 Pushing the stack gets a clean outgoing argument
+                 block.  */
+              old_stack_arg_under_construction
+                = stack_arg_under_construction;
+              stack_arg_under_construction = 0;
+              /* Make a new map for the new argument list.  */
+              if (stack_usage_map_buf)
+                free (stack_usage_map_buf);
+              stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
+              stack_usage_map = stack_usage_map_buf;
+              memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
+              highest_outgoing_arg_in_use = 0;
+            }
+          allocate_dynamic_stack_space (push_size, NULL_RTX,
+                                        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)
-	  {
-	    argblock = copy_addr_to_reg (argblock);
-	    break;
-	  }
-  }
+        if (args[i].pass_on_stack)
+          {
+            argblock = copy_addr_to_reg (argblock);
+            break;
+          }
+    }
 
   compute_argument_addresses (args, argblock, num_actuals);
 
   /* in the case that
-     a function goto codesegment.  
+     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)) )
+    //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);
+      padding = CbC_PRETENDED_STACK_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
@@ -219,9 +219,9 @@
   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));
+    static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
   else
-      static_chain_value = 0;
+    static_chain_value = 0;
 
 
   /* parallel assignment  */
@@ -232,10 +232,10 @@
   for (i = 0; i < num_actuals; i++)
     {
       if (args[i].reg == 0 || args[i].pass_on_stack)
-	{
-	  preexpand_argument_expr (&args[i],
-		  adjusted_args_size.var != 0);
-	}
+        {
+          preexpand_argument_expr (&args[i],
+                                   adjusted_args_size.var != 0);
+        }
     }
 
 
@@ -251,13 +251,13 @@
   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]].partial!=0 )
-	{
-	  expand_one_arg_push (&args[store_order[i]], argblock, flags,
-		  adjusted_args_size.var != 0,
-		  reg_parm_stack_space);
-	}
+          || args[store_order[i]].pass_on_stack
+          || args[store_order[i]].partial!=0 )
+        {
+          expand_one_arg_push (&args[store_order[i]], argblock, flags,
+                               adjusted_args_size.var != 0,
+                               reg_parm_stack_space);
+        }
     }
 
 
@@ -271,13 +271,13 @@
 #endif
 
   /*   */
-  funexp = prepare_call_address (funexp, static_chain_value,
-      &call_fusage, reg_parm_seen, pass == 0);
+  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);
+                            //pass == 0, &sibcall_failure);
+                            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.  */
@@ -288,25 +288,25 @@
 #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));
+              || !(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,
-		      hard_frame_pointer_rtx)));
+                                  gen_rtx_MEM (BLKmode,
+                                               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 ();
@@ -320,21 +320,21 @@
       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,
-	  //next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
-	  next_arg_reg, valreg, 0, call_fusage,
-	  flags, & args_so_far);
+                   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);
       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);
+      /* 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
@@ -347,7 +347,7 @@
       && 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));
     }
 
@@ -359,27 +359,27 @@
   if ((flags & ECF_NORETURN) || pass == 0)
     {
       /* The barrier must be emitted
-	 immediately after the CALL_INSN.  Some ports emit more
-	 than just a CALL_INSN above, so we must search for it here.  */
+         immediately after the CALL_INSN.  Some ports emit more
+         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);
-	  /* There was no CALL_INSN?  */
-	  gcc_assert (last != before_call);
-	}
+        {
+          last = PREV_INSN (last);
+          /* There was no CALL_INSN?  */
+          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
-	 stack_pointer_delta.  */
+         However when NO_DEFER_POP is in effect, we must preserve
+         stack_pointer_delta.  */
       if (inhibit_defer_pop == 0)
-	{
-	  stack_pointer_delta = old_stack_allocated;
-	  pending_stack_adjust = 0;
-	}
+        {
+          stack_pointer_delta = old_stack_allocated;
+          pending_stack_adjust = 0;
+        }
     }
 
   /* If value type not void, return an rtx for the value.  */
@@ -388,38 +388,41 @@
       || 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
-	      && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
-	{
-	  tree type = TREE_TYPE (exp);
-	  int unsignedp = TYPE_UNSIGNED (type);
-	  int offset = 0;
-	  enum machine_mode pmode;
+          && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
+          && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
+        {
+          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.  */
-	  gcc_assert (GET_MODE (target) == pmode);
+          pmode = promote_mode (type, TYPE_MODE (type), &unsignedp);//, 1);
+          /* 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))
-		      > GET_MODE_SIZE (TYPE_MODE (type))))
-	    {
-	      offset = GET_MODE_SIZE (GET_MODE (target))
-		  - GET_MODE_SIZE (TYPE_MODE (type));
-	      if (! BYTES_BIG_ENDIAN)
-		  offset = (offset / UNITS_PER_WORD) * 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;
-	  SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
-	}
+          if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
+              && (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));
+              if (! BYTES_BIG_ENDIAN)
+                offset = (offset / UNITS_PER_WORD) * 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;
+          SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
+        }
     }
 
   /* If size of args is variable or this was a constructor call for a stack
@@ -479,7 +482,7 @@
 
 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;
@@ -521,17 +524,17 @@
     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);
+                            (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--;
@@ -549,7 +552,7 @@
 
 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;
@@ -592,42 +595,42 @@
       int size;
 
       /* Argument is a scalar, not entirely passed in registers.
-	 (If part is passed in registers, arg->partial says how much
-	 and emit_push_insn will take care of putting it there.)
+         (If part is passed in registers, arg->partial says how much
+         and emit_push_insn will take care of putting it there.)
 
-	 Push it, and if its size is less than the
-	 amount of space allocated to it,
-	 also bump stack pointer by the additional space.
-	 Note that in C the default argument promotions
-	 will prevent such mismatches.  */
+         Push it, and if its size is less than the
+         amount of space allocated to it,
+         also bump stack pointer by the additional space.
+         Note that in C the default argument promotions
+         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
-	 pointer by a halfword.  */
+         On many machines, pushing a byte will advance the stack
+         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)
-		      / (PARM_BOUNDARY / BITS_PER_UNIT))
-		  * (PARM_BOUNDARY / BITS_PER_UNIT));
+        used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
+                 / (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,
-	      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
-	      ARGS_SIZE_RTX (arg->locate.alignment_pad));
+                      PARM_BOUNDARY, partial, reg, used - size, argblock,
+                      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
+                      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
     {
@@ -638,88 +641,88 @@
       rtx size_rtx;
 
       /* Pushing a nonscalar.
-	 If part is passed in registers, PARTIAL says how much
-	 and emit_push_insn will take care of putting it there.  */
+         If part is passed in registers, PARTIAL says how much
+         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;
-	  size_rtx = ARGS_SIZE_RTX (arg->locate.size);
-	}
+        {
+          excess = 0;
+          size_rtx = ARGS_SIZE_RTX (arg->locate.size);
+        }
       else
-	{
-	  /* PUSH_ROUNDING has no effect on us, because emit_push_insn
-	     for BLKmode is careful to avoid it.  */
-	  excess = (arg->locate.size.constant
-		  - int_size_in_bytes (TREE_TYPE (pval))
-		  + partial);
-	  size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
-		  NULL_RTX, TYPE_MODE (sizetype), 0);
-	}
+        {
+          /* PUSH_ROUNDING has no effect on us, because emit_push_insn
+             for BLKmode is careful to avoid it.  */
+          excess = (arg->locate.size.constant
+                    - int_size_in_bytes (TREE_TYPE (pval))
+                    + partial);
+          size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
+                                  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)
-	      parm_align = BITS_PER_UNIT;
-	  else if (excess)
-	    {
-	      unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
-	      parm_align = MIN (parm_align, excess_align);
-	    }
-	}
+        {
+          if (arg->locate.size.var)
+            parm_align = BITS_PER_UNIT;
+          else if (excess)
+            {
+              unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
+              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
-	     argblock + arg->locate.offset areas overlap.  */
-	  rtx x = arg->value;
-	  int i = 0;
+        {
+          /* emit_push_insn might not work properly if arg->value and
+             argblock + arg->locate.offset areas overlap.  */
+          rtx x = arg->value;
+          int i = 0;
 
-	  if (XEXP (x, 0) == crtl->args.internal_arg_pointer
-		  || (GET_CODE (XEXP (x, 0)) == PLUS
-		      && XEXP (XEXP (x, 0), 0) ==
-		      crtl->args.internal_arg_pointer
-		      && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
-	    {
-	      if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
-		  i = INTVAL (XEXP (XEXP (x, 0), 1));
+          if (XEXP (x, 0) == crtl->args.internal_arg_pointer
+              || (GET_CODE (XEXP (x, 0)) == PLUS
+                  && XEXP (XEXP (x, 0), 0) ==
+                  crtl->args.internal_arg_pointer
+                  && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
+            {
+              if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
+                i = INTVAL (XEXP (XEXP (x, 0), 1));
 
-	      /* expand_call should ensure this.  */
-	      gcc_assert (!arg->locate.offset.var
-		      && GET_CODE (size_rtx) == CONST_INT);
-	    }
-	}
+              /* expand_call should ensure this.  */
+              gcc_assert (!arg->locate.offset.var
+                          && GET_CODE (size_rtx) == CONST_INT);
+            }
+        }
 
       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
-	      parm_align, partial, reg, excess, argblock,
-	      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
-	      ARGS_SIZE_RTX (arg->locate.alignment_pad));
+                      parm_align, partial, reg, excess, argblock,
+                      ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
+                      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
-	 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
-	 it's properly aligned for word-by-word copying or something
-	 like that.  It's not clear that this is always correct.  */
+         ??? Unlike the case above, in which we want the actual
+         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
+         it's properly aligned for word-by-word copying or something
+         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,
-		  int_size_in_bytes (type));
+        = emit_group_load_into_temps (arg->reg, arg->value, type,
+                                      int_size_in_bytes (type));
     }
 
   /* Mark all slots this store used.  */
@@ -747,7 +750,7 @@
 {
   int i;
   for (i=0; i<num_actuals; i++)
-      order[i] = num_actuals-i-1;
+    order[i] = num_actuals-i-1;
   return;
 }
 
@@ -767,9 +770,9 @@
       /* 退避  */
       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;
 
     }
@@ -782,21 +785,21 @@
   int i;
   rtx addr;
   if ( !x || !MEM_P(x))
-      return -1;
+    return -1;
 
   addr = XEXP(x, 0);
   if (addr == crtl->args.internal_arg_pointer)
-      i = 0;
+    i = 0;
   else if (GET_CODE (addr) == PLUS
-	  && XEXP (addr, 0) == crtl->args.internal_arg_pointer
-	  && GET_CODE (XEXP (addr, 1)) == CONST_INT)
-      i = INTVAL (XEXP (addr, 1));
+           && XEXP (addr, 0) == crtl->args.internal_arg_pointer
+           && 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
-	  && XEXP (addr, 1) == crtl->args.internal_arg_pointer )
-      i = INTVAL (XEXP (addr, 0));
+           && GET_CODE (XEXP (addr, 0)) == CONST_INT
+           && XEXP (addr, 1) == crtl->args.internal_arg_pointer )
+    i = INTVAL (XEXP (addr, 0));
   else
-      return -1;
+    return -1;
 
   return i;
 }