+/**
+ * Handle calls to nothrow functions.
+ *
+ * @param ctx context
+ */
+static void handle_nothrow_Calls(env_t *ctx) {
+ int i;
+
+ ctx->n_calls_SymConst = 0;
+ ctx->n_calls_Sel = 0;
+
+ /* all calls of const functions can be transformed */
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+ ir_graph *irg = get_irp_irg(i);
+
+ ctx->nothrow_call_list = NULL;
+ ctx->proj_list = NULL;
+ irg_walk_graph(irg, NULL, collect_nothrow_calls, ctx);
+
+ if (ctx->nothrow_call_list) {
+ fix_nothrow_call_list(irg, ctx->nothrow_call_list, ctx->proj_list);
+
+ /* this graph was changed, invalidate analysis info */
+ set_irg_outs_inconsistent(irg);
+ set_irg_doms_inconsistent(irg);
+ }
+ }
+}
+
+/**
+ * Check, whether a given node represents a return value of
+ * a malloc like function (ie, new heap allocated memory).
+ *
+ * @param node the node to check
+ */
+static int is_malloc_call_result(const ir_node *node) {
+ if (is_Alloc(node) && get_Alloc_where(node) == heap_alloc) {
+ /* Firm style high-level allocation */
+ return 1;
+ }
+ if (is_alloc_entity != NULL && is_Call(node)) {
+ ir_node *ptr = get_Call_ptr(node);
+
+ if (is_SymConst_addr_ent(ptr)) {
+ ir_entity *ent = get_SymConst_entity(ptr);
+ return is_alloc_entity(ent);
+ }
+ }
+ return 0;
+} /* is_malloc_call_result */
+
+/**
+ * Update a property depending on a call property.
+ */
+static unsigned update_property(unsigned orig_prop, unsigned call_prop) {
+ unsigned t = (orig_prop | call_prop) & mtp_temporary;
+ unsigned r = orig_prop & call_prop;
+ return r | t;
+} /** update_property */
+
+/**
+ * Check if a graph represents a nothrow or a malloc function.
+ *
+ * @param irg the graph to check
+ * @param top if set, this is the top call
+ */
+static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) {
+ ir_node *end_blk = get_irg_end_block(irg);
+ int i, j;
+ unsigned curr_prop = mtp_property_malloc | mtp_property_nothrow;
+
+ if (IS_IRG_READY(irg)) {
+ /* already checked */
+ return get_irg_additional_properties(irg);
+ }
+ if (IS_IRG_BUSY(irg)) {
+ /* we are still evaluate this method. Be optimistic,
+ return the best possible so far but mark the result as temporary. */
+ return mtp_temporary | mtp_property_malloc | mtp_property_nothrow;
+ }
+ SET_IRG_BUSY(irg);
+
+ for (i = get_Block_n_cfgpreds(end_blk) - 1; i >= 0; --i) {
+ ir_node *pred = get_Block_cfgpred(end_blk, i);
+
+ if (is_Return(pred)) {
+ if (curr_prop & mtp_property_malloc) {
+ /* check, if malloc is called here */
+ for (j = get_Return_n_ress(pred) - 1; j >= 0; --j) {
+ const ir_node *res = get_Return_res(pred, j);
+ //const ir_node *irn = skip_Proj_const(res);
+ if (is_malloc_call_result(res)) {
+ /* ok, this is a malloc */
+ } else if (is_Call(res)) {
+ ir_node *ptr = get_Call_ptr(res);
+
+ if (is_SymConst_addr_ent(ptr)) {
+ /* a direct call */
+ ir_entity *ent = get_SymConst_entity(ptr);
+ ir_graph *callee = get_entity_irg(ent);
+
+ if (callee == irg) {
+ /* A self-recursive call. The property did not depend on this call. */
+ } else if (callee != NULL) {
+ unsigned prop = check_nothrow_or_malloc(callee, /*top=*/0);
+ curr_prop = update_property(curr_prop, prop);
+ } else {
+ curr_prop = update_property(curr_prop, get_entity_additional_properties(ent));
+ }
+ } else if (get_opt_closed_world() &&
+ is_Sel(ptr) &&
+ get_irg_callee_info_state(irg) == irg_callee_info_consistent) {
+ /* check if all possible callees are malloc functions. */
+ int i, n_callees = get_Call_n_callees(res);
+ if (n_callees == 0) {
+ /* This is kind of strange: dying code or a Call that will raise an exception
+ when executed as there is no implementation to call. So better not
+ optimize. */
+ curr_prop &= ~mtp_property_malloc;
+ continue;
+ }
+
+ for (i = 0; i < n_callees; ++i) {
+ ir_entity *ent = get_Call_callee(res, i);
+ if (ent == unknown_entity) {
+ /* we don't know which entity is called here */
+ curr_prop &= ~mtp_property_malloc;
+ break;
+ }
+ if ((get_entity_additional_properties(ent) & mtp_property_malloc) == 0) {
+ curr_prop &= ~mtp_property_malloc;
+ break;
+ }
+ }
+ /* if we pass the for cycle, malloc is still ok */
+ } else {
+ /* unknown call */
+ curr_prop &= ~mtp_property_malloc;
+ }
+ }
+ }
+ }
+ } else if (curr_prop & mtp_property_nothrow) {
+ /* exception flow detected */
+ pred = skip_Proj(pred);
+
+ if (is_Call(pred)) {
+ ir_node *ptr = get_Call_ptr(pred);
+
+ if (is_SymConst_addr_ent(ptr)) {
+ /* a direct call */
+ ir_entity *ent = get_SymConst_entity(ptr);
+ ir_graph *callee = get_entity_irg(ent);
+
+ if (callee == irg) {
+ /* A self-recursive call. The property did not depend on this call. */
+ } else if (callee != NULL) {
+ unsigned prop = check_nothrow_or_malloc(callee, /*top=*/0);
+ curr_prop = update_property(curr_prop, prop);
+ } else {
+ curr_prop = update_property(curr_prop, get_entity_additional_properties(ent));
+ }
+ } else if (get_opt_closed_world() &&
+ is_Sel(ptr) &&
+ get_irg_callee_info_state(irg) == irg_callee_info_consistent) {
+ /* check if all possible callees are nothrow functions. */
+ int i, n_callees = get_Call_n_callees(pred);
+ if (n_callees == 0) {
+ /* This is kind of strange: dying code or a Call that will raise an exception
+ when executed as there is no implementation to call. So better not
+ optimize. */
+ curr_prop &= ~mtp_property_nothrow;
+ continue;
+ }
+
+ for (i = 0; i < n_callees; ++i) {
+ ir_entity *ent = get_Call_callee(pred, i);
+ if (ent == unknown_entity) {
+ /* we don't know which entity is called here */
+ curr_prop &= ~mtp_property_nothrow;
+ break;
+ }
+ if ((get_entity_additional_properties(ent) & mtp_property_nothrow) == 0) {
+ curr_prop &= ~mtp_property_nothrow;
+ break;
+ }
+ }
+ /* if we pass the for cycle, nothrow is still ok */
+ } else {
+ /* unknown call */
+ curr_prop &= ~mtp_property_nothrow;
+ }
+ } else {
+ /* real exception flow possible. */
+ curr_prop &= ~mtp_property_nothrow;
+ }
+ }
+ if ((curr_prop & ~mtp_temporary) == mtp_no_property) {
+ /* no need to search further */
+ break;
+ }
+ }
+ if (curr_prop != mtp_no_property) {
+ if (top || (curr_prop & mtp_temporary) == 0) {
+ /* We use the temporary flag here to mark an optimistic result.
+ Set the property only if we are sure that it does NOT base on
+ temporary results OR if we are at top-level. */
+ set_irg_additional_property(irg, curr_prop & ~mtp_temporary);
+ SET_IRG_READY(irg);
+ }
+ }
+ if (top)
+ SET_IRG_READY(irg);
+ CLEAR_IRG_BUSY(irg);
+ return curr_prop;
+} /* check_nothrow_or_malloc */
+