#include "irgraph_t.h"
#include "irprog_t.h"
+#include "iroptimize.h"
#include "ircons.h"
#include "iropt_t.h"
-#include "cfopt.h"
#include "irgopt.h"
#include "irgmod.h"
#include "irgwalk.h"
return res;
}
+enum exc_mode {
+ exc_handler = 0, /**< There is a handler. */
+ exc_to_end = 1, /**< Branches to End. */
+ exc_no_handler = 2 /**< Exception handling not represented. */
+};
+
/* Inlines a method at the given call site. */
int inline_method(ir_node *call, ir_graph *called_graph) {
ir_node *pre_call;
ir_node **cf_pred;
ir_node *ret, *phi;
int arity, n_ret, n_exc, n_res, i, j, rem_opt, irn_arity;
- int exc_handling;
+ enum exc_mode exc_handling;
ir_type *called_frame;
irg_inline_property prop = get_irg_inline_property(called_graph);
{
ir_node *proj, *Mproj = NULL, *Xproj = NULL;
for (proj = get_irn_link(call); proj; proj = get_irn_link(proj)) {
- assert(is_Proj(proj));
- if (get_Proj_proj(proj) == pn_Call_X_except) Xproj = proj;
- if (get_Proj_proj(proj) == pn_Call_M_except) Mproj = proj;
+ long proj_nr = get_Proj_proj(proj);
+ if (proj_nr == pn_Call_X_except) Xproj = proj;
+ if (proj_nr == pn_Call_M_except) Mproj = proj;
}
- if (Mproj) { assert(Xproj); exc_handling = 0; } /* Mproj */
- else if (Xproj) { exc_handling = 1; } /* !Mproj && Xproj */
- else { exc_handling = 2; } /* !Mproj && !Xproj */
+ if (Mproj) { assert(Xproj); exc_handling = exc_handler; } /* Mproj */
+ else if (Xproj) { exc_handling = exc_to_end; } /* !Mproj && Xproj */
+ else { exc_handling = exc_no_handler; } /* !Mproj && !Xproj */
}
/* --
/* -- Performing dead node elimination inlines the graph -- */
/* Copies the nodes to the obstack of current_ir_graph. Updates links to new
entities. */
- /* @@@ endless loops are not copied!! -- they should be, I think... */
irg_walk(get_irg_end(called_graph), copy_node_inline, copy_preds,
get_irg_frame_type(called_graph));
/* -- archive keepalives -- */
irn_arity = get_irn_arity(end);
- for (i = 0; i < irn_arity; i++)
- add_End_keepalive(get_irg_end(current_ir_graph), get_irn_n(end, i));
+ for (i = 0; i < irn_arity; i++) {
+ ir_node *ka = get_End_keepalive(end, i);
+ if (! is_Bad(ka))
+ add_End_keepalive(get_irg_end(current_ir_graph), ka);
+ }
/* The new end node will die. We need not free as the in array is on the obstack:
copy_node() only generated 'D' arrays. */
/* -- Build a Tuple for all results of the method.
Add Phi node if there was more than one Return. -- */
- turn_into_tuple(post_call, 4); /* FIXME: is th 4 corrct here ? */
+ turn_into_tuple(post_call, pn_Call_max);
/* First the Memory-Phi */
n_ret = 0;
for (i = 0; i < arity; i++) {
} else {
set_Tuple_pred(call, pn_Call_T_result, new_Bad());
}
+
+ /* For now, we cannot inline calls with value_base */
+ set_Tuple_pred(call, pn_Call_P_value_res_base, new_Bad());
+
/* Finally the exception control flow.
We have two (three) possible situations:
First if the Call branches to an exception handler: We need to add a Phi node to
Second the Call branches to End, the exception is not handled. Just
add all inlined exception branches to the End node.
Third: there is no Exception edge at all. Handle as case two. */
- if (exc_handling == 0) {
+ if (exc_handling == exc_handler) {
n_exc = 0;
for (i = 0; i < arity; i++) {
- ir_node *ret;
+ ir_node *ret, *irn;
ret = get_irn_n(end_bl, i);
- if (is_fragile_op(skip_Proj(ret)) || (get_irn_op(skip_Proj(ret)) == op_Raise)) {
+ irn = skip_Proj(ret);
+ if (is_fragile_op(irn) || (get_irn_op(irn) == op_Raise)) {
cf_pred[n_exc] = ret;
- n_exc++;
+ ++n_exc;
}
}
if (n_exc > 0) {
set_Tuple_pred(call, pn_Call_X_except, new_Bad());
set_Tuple_pred(call, pn_Call_M_except, new_Bad());
}
+ set_Tuple_pred(call, pn_Call_X_regular, new_Bad());
} else {
ir_node *main_end_bl;
int main_end_bl_arity;
n_exc = 0;
for (i = 0; i < arity; i++) {
ir_node *ret = get_irn_n(end_bl, i);
+ ir_node *irn = skip_Proj(ret);
- if (is_fragile_op(skip_Proj(ret)) || (get_irn_op(skip_Proj(ret)) == op_Raise)) {
+ if (is_fragile_op(irn) || (get_irn_op(irn) == op_Raise)) {
cf_pred[n_exc] = ret;
n_exc++;
}
}
main_end_bl = get_irg_end_block(current_ir_graph);
main_end_bl_arity = get_irn_arity(main_end_bl);
- end_preds = xmalloc ((n_exc + main_end_bl_arity) * sizeof(*end_preds));
+ end_preds = xmalloc((n_exc + main_end_bl_arity) * sizeof(*end_preds));
for (i = 0; i < main_end_bl_arity; ++i)
end_preds[i] = get_irn_n(main_end_bl, i);
for (i = 0; i < n_exc; ++i)
end_preds[main_end_bl_arity + i] = cf_pred[i];
set_irn_in(main_end_bl, n_exc + main_end_bl_arity, end_preds);
- set_Tuple_pred(call, pn_Call_X_except, new_Bad());
- set_Tuple_pred(call, pn_Call_M_except, new_Bad());
+ set_Tuple_pred(call, pn_Call_X_regular, new_Bad());
+ set_Tuple_pred(call, pn_Call_X_except, new_Bad());
+ set_Tuple_pred(call, pn_Call_M_except, new_Bad());
free(end_preds);
}
free(res_pred);
projects / libfirm / blobdiff