CbC/CbC_gcc: gcc/calls.c~ comparison

comparison gcc/calls.c~ @ 82:895e19fe9c22

modify calls.c

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Fri, 11 Nov 2011 02:35:16 +0900
parents	561a7518be6b
children	6fb1a677d0b5

comparison

equal deleted inserted replaced

-:d8bf5c8fdea8
+:895e19fe9c22
 copy in smaller-sized pieces into pseudos.  These are stored in a
 block pointed to by this field.  The next field says how many
 word-sized pseudos we made.  */
 rtx *aligned_regs;
 int n_aligned_regs;
+#ifndef noCbC
+rtx exprs;
+#endif
 };
 /* A vector of one char per byte of stack space.  A byte if nonzero if
 the corresponding stack location has been used.
 This vector is used to prevent a function call within an argument from
 			   value, GEN_INT (shift), value, 1, OPTAB_WIDEN))
 gcc_unreachable ();
 return true;
 }
+#ifndef noCbC
+#include "cbc-tree.h"
+#endif
 /* If X is a likely-spilled register value, copy it to a pseudo
 register and return that register.  Return X otherwise.  */
 static rtx
 avoid_likely_spilled_reg (rtx x)
 /* Tail calls can make things harder to debug, and we've traditionally
 pushed these optimizations into -O2.  Don't try if we're already
 expanding a call, as that means we're an argument.  Don't try if
 there's cleanups, as we know there's code to follow the call.  */
+// -O2オプションがないときも末尾最適化が行われるように(Code Segmentのみ)
 if (currently_expanding_call++ != 0
+#ifndef noCbC
+|| ((!fndecl || !CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl))) && !flag_optimize_sibling_calls)
+#else
 || !flag_optimize_sibling_calls
+#endif
 || args_size.var
 || dbg_cnt (tail_call) == false)
 try_tail_call = 0;
 /*  Rest of purposes for tail call optimizations to fail.  */
 	  != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl)))
 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (fndecl))
 #endif
 /* Check whether the target is able to optimize the call
 	 into a sibcall.  */
+#ifndef noCbC
+|| (!targetm.function_ok_for_sibcall (fndecl, exp)
+	  && !CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl)))
+#else
 || !targetm.function_ok_for_sibcall (fndecl, exp)
+#endif
 /* Functions that do not return exactly once may not be sibcall
 	 optimized.  */
 || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
 /* If the called function is nested in the current one, it might access
 					     TREE_TYPE (current_function_decl),
 					     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.  */
+#ifndef noCbC
+if(0)
+#else
 if (try_tail_call)
+#endif
 {
 enum machine_mode caller_mode, caller_promoted_mode;
 enum machine_mode callee_mode, callee_promoted_mode;
 int caller_unsignedp, callee_unsignedp;
 tree caller_res = DECL_RESULT (current_function_decl);
 else
 preferred_stack_boundary = crtl->preferred_stack_boundary;
 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
+#ifndef noCbC
+if ( fntype
+&& CbC_IS_CbC_GOTO (exp) // it's better? than CALL_EXPR_TAILCALL()
+&& CbC_IS_CODE_SEGMENT (TREE_TYPE (current_function_decl))
+)
+{
+args_size.constant = CbC_PRETENDED_STACK_SIZE;
+// try_tail_callを矯正的に立たせて末尾最適化を必ずうように変更
+// -> expand_cbc_gotは不要に。
+/* return expand_cbc_goto(exp, target, fndecl, funtype, fntype,
+*         addr, ignore, flags, num_actuals, args, &args_size,
+*         args_so_far,
+*         old_stack_level, reg_parm_stack_space, old_pending_adj,
+*         preferred_stack_boundary, preferred_unit_stack_boundary,
+*         structure_value_addr, old_inhibit_defer_pop); */
+}
+else if ( CbC_IS_CbC_GOTO (exp) )
+{
+// TODO: 関数からコードセグメントへの遷移
+/*
+if (fndecl)
+{
+char *name_callee = IDENTIFIER_POINTER(DECL_NAME(fndecl));
+warning(0, "no warning: code segment `%s' has been called from a function.", name_callee);
+}
+else
+{
+warning(0, "no warning: unnamed code segment has been called from a function.");
+}
+*/
+args_size.constant = CbC_PRETENDED_STACK_SIZE;
+}
+else if ( fndecl && CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl)) )
+{
+// 警告コードセグメントを関数呼び出し
+//char *name= IDENTIFIER_POINTER(DECL_NAME(fndecl));
+//warning (0, "code segment `%s' has been \"called\" instead \"goto\".", name);
+}
+else if (CbC_IS_CODE_SEGMENT(TREE_TYPE (current_function_decl)) )
+{
+// code segment内部からの関数呼び出し。なんも問題ない。
+//warning (0, "no warning: normal call from a code segment.");
+}
+#endif
+// when tail call optimization flag was down, warn about them.
+// and flag it to force a tail call optimize.
+#ifndef noCbC
+if (fndecl && CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl))
+&& CbC_IS_CODE_SEGMENT (TREE_TYPE (current_function_decl))
+&& try_tail_call == 0)
+{
+location_t loc = EXPR_LOCATION (exp);
+char *name_callee = IDENTIFIER_POINTER(DECL_NAME(fndecl));
+warning_at (loc, 0, "transition to code segment \"%s\" with CbC goto, but tail call optimization was cut.",
+name_callee);
+try_tail_call = 1;
+}
+#endif
 /* We want to make two insn chains; one for a sibling call, the other
 for a normal call.  We will select one of the two chains after
 initial RTL generation is complete.  */
 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
 {
 if (pass == 0 && crtl->stack_protect_guard)
 	stack_protect_epilogue ();
 adjusted_args_size = args_size;
 /* Compute the actual size of the argument block required.  The variable
-	 and constant sizes must be combined, the size may have to be rounded,
+and constant sizes must be combined, the size may have to be rounded,
-	 and there may be a minimum required size.  When generating a sibcall
+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
+pattern, do not round up, since we'll be re-using whatever space our
-	 caller provided.  */
+caller provided.  */
+#ifndef noCbC
+if ( fntype && CbC_IS_CODE_SEGMENT(fntype) )
+{
+unadjusted_args_size = args_size.constant;
+adjusted_args_size.constant = CbC_PRETENDED_STACK_SIZE;
+compute_argument_block_size (reg_parm_stack_space,
+&adjusted_args_size,
+fndecl, fntype,
+(pass == 0 ? 0
+: preferred_stack_boundary));
+}
+else
+#endif
+{
 unadjusted_args_size
-	= compute_argument_block_size (reg_parm_stack_space,
+= 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;
 /* The argument block when performing a sibling call is the
 	 incoming argument block.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/calls.c~ @ 82:895e19fe9c22