| /* Exception handling semantics and decomposition for trees. |
| Copyright (C) 2003-2021 Free Software Foundation, Inc. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| GCC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "backend.h" |
| #include "rtl.h" |
| #include "tree.h" |
| #include "gimple.h" |
| #include "cfghooks.h" |
| #include "tree-pass.h" |
| #include "ssa.h" |
| #include "cgraph.h" |
| #include "diagnostic-core.h" |
| #include "fold-const.h" |
| #include "calls.h" |
| #include "except.h" |
| #include "cfganal.h" |
| #include "cfgcleanup.h" |
| #include "tree-eh.h" |
| #include "gimple-iterator.h" |
| #include "tree-cfg.h" |
| #include "tree-into-ssa.h" |
| #include "tree-ssa.h" |
| #include "tree-inline.h" |
| #include "langhooks.h" |
| #include "cfgloop.h" |
| #include "gimple-low.h" |
| #include "stringpool.h" |
| #include "attribs.h" |
| #include "asan.h" |
| #include "gimplify.h" |
| |
| /* In some instances a tree and a gimple need to be stored in a same table, |
| i.e. in hash tables. This is a structure to do this. */ |
| typedef union {tree *tp; tree t; gimple *g;} treemple; |
| |
| /* Misc functions used in this file. */ |
| |
| /* Remember and lookup EH landing pad data for arbitrary statements. |
| Really this means any statement that could_throw_p. We could |
| stuff this information into the stmt_ann data structure, but: |
| |
| (1) We absolutely rely on this information being kept until |
| we get to rtl. Once we're done with lowering here, if we lose |
| the information there's no way to recover it! |
| |
| (2) There are many more statements that *cannot* throw as |
| compared to those that can. We should be saving some amount |
| of space by only allocating memory for those that can throw. */ |
| |
| /* Add statement T in function IFUN to landing pad NUM. */ |
| |
| static void |
| add_stmt_to_eh_lp_fn (struct function *ifun, gimple *t, int num) |
| { |
| gcc_assert (num != 0); |
| |
| if (!get_eh_throw_stmt_table (ifun)) |
| set_eh_throw_stmt_table (ifun, hash_map<gimple *, int>::create_ggc (31)); |
| |
| gcc_assert (!get_eh_throw_stmt_table (ifun)->put (t, num)); |
| } |
| |
| /* Add statement T in the current function (cfun) to EH landing pad NUM. */ |
| |
| void |
| add_stmt_to_eh_lp (gimple *t, int num) |
| { |
| add_stmt_to_eh_lp_fn (cfun, t, num); |
| } |
| |
| /* Add statement T to the single EH landing pad in REGION. */ |
| |
| static void |
| record_stmt_eh_region (eh_region region, gimple *t) |
| { |
| if (region == NULL) |
| return; |
| if (region->type == ERT_MUST_NOT_THROW) |
| add_stmt_to_eh_lp_fn (cfun, t, -region->index); |
| else |
| { |
| eh_landing_pad lp = region->landing_pads; |
| if (lp == NULL) |
| lp = gen_eh_landing_pad (region); |
| else |
| gcc_assert (lp->next_lp == NULL); |
| add_stmt_to_eh_lp_fn (cfun, t, lp->index); |
| } |
| } |
| |
| |
| /* Remove statement T in function IFUN from its EH landing pad. */ |
| |
| bool |
| remove_stmt_from_eh_lp_fn (struct function *ifun, gimple *t) |
| { |
| if (!get_eh_throw_stmt_table (ifun)) |
| return false; |
| |
| if (!get_eh_throw_stmt_table (ifun)->get (t)) |
| return false; |
| |
| get_eh_throw_stmt_table (ifun)->remove (t); |
| return true; |
| } |
| |
| |
| /* Remove statement T in the current function (cfun) from its |
| EH landing pad. */ |
| |
| bool |
| remove_stmt_from_eh_lp (gimple *t) |
| { |
| return remove_stmt_from_eh_lp_fn (cfun, t); |
| } |
| |
| /* Determine if statement T is inside an EH region in function IFUN. |
| Positive numbers indicate a landing pad index; negative numbers |
| indicate a MUST_NOT_THROW region index; zero indicates that the |
| statement is not recorded in the region table. */ |
| |
| int |
| lookup_stmt_eh_lp_fn (struct function *ifun, const gimple *t) |
| { |
| if (ifun->eh->throw_stmt_table == NULL) |
| return 0; |
| |
| int *lp_nr = ifun->eh->throw_stmt_table->get (const_cast <gimple *> (t)); |
| return lp_nr ? *lp_nr : 0; |
| } |
| |
| /* Likewise, but always use the current function. */ |
| |
| int |
| lookup_stmt_eh_lp (const gimple *t) |
| { |
| /* We can get called from initialized data when -fnon-call-exceptions |
| is on; prevent crash. */ |
| if (!cfun) |
| return 0; |
| return lookup_stmt_eh_lp_fn (cfun, t); |
| } |
| |
| /* First pass of EH node decomposition. Build up a tree of GIMPLE_TRY_FINALLY |
| nodes and LABEL_DECL nodes. We will use this during the second phase to |
| determine if a goto leaves the body of a TRY_FINALLY_EXPR node. */ |
| |
| struct finally_tree_node |
| { |
| /* When storing a GIMPLE_TRY, we have to record a gimple. However |
| when deciding whether a GOTO to a certain LABEL_DECL (which is a |
| tree) leaves the TRY block, its necessary to record a tree in |
| this field. Thus a treemple is used. */ |
| treemple child; |
| gtry *parent; |
| }; |
| |
| /* Hashtable helpers. */ |
| |
| struct finally_tree_hasher : free_ptr_hash <finally_tree_node> |
| { |
| static inline hashval_t hash (const finally_tree_node *); |
| static inline bool equal (const finally_tree_node *, |
| const finally_tree_node *); |
| }; |
| |
| inline hashval_t |
| finally_tree_hasher::hash (const finally_tree_node *v) |
| { |
| return (intptr_t)v->child.t >> 4; |
| } |
| |
| inline bool |
| finally_tree_hasher::equal (const finally_tree_node *v, |
| const finally_tree_node *c) |
| { |
| return v->child.t == c->child.t; |
| } |
| |
| /* Note that this table is *not* marked GTY. It is short-lived. */ |
| static hash_table<finally_tree_hasher> *finally_tree; |
| |
| static void |
| record_in_finally_tree (treemple child, gtry *parent) |
| { |
| struct finally_tree_node *n; |
| finally_tree_node **slot; |
| |
| n = XNEW (struct finally_tree_node); |
| n->child = child; |
| n->parent = parent; |
| |
| slot = finally_tree->find_slot (n, INSERT); |
| gcc_assert (!*slot); |
| *slot = n; |
| } |
| |
| static void |
| collect_finally_tree (gimple *stmt, gtry *region); |
| |
| /* Go through the gimple sequence. Works with collect_finally_tree to |
| record all GIMPLE_LABEL and GIMPLE_TRY statements. */ |
| |
| static void |
| collect_finally_tree_1 (gimple_seq seq, gtry *region) |
| { |
| gimple_stmt_iterator gsi; |
| |
| for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) |
| collect_finally_tree (gsi_stmt (gsi), region); |
| } |
| |
| static void |
| collect_finally_tree (gimple *stmt, gtry *region) |
| { |
| treemple temp; |
| |
| switch (gimple_code (stmt)) |
| { |
| case GIMPLE_LABEL: |
| temp.t = gimple_label_label (as_a <glabel *> (stmt)); |
| record_in_finally_tree (temp, region); |
| break; |
| |
| case GIMPLE_TRY: |
| if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY) |
| { |
| temp.g = stmt; |
| record_in_finally_tree (temp, region); |
| collect_finally_tree_1 (gimple_try_eval (stmt), |
| as_a <gtry *> (stmt)); |
| collect_finally_tree_1 (gimple_try_cleanup (stmt), region); |
| } |
| else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH) |
| { |
| collect_finally_tree_1 (gimple_try_eval (stmt), region); |
| collect_finally_tree_1 (gimple_try_cleanup (stmt), region); |
| } |
| break; |
| |
| case GIMPLE_CATCH: |
| collect_finally_tree_1 (gimple_catch_handler ( |
| as_a <gcatch *> (stmt)), |
| region); |
| break; |
| |
| case GIMPLE_EH_FILTER: |
| collect_finally_tree_1 (gimple_eh_filter_failure (stmt), region); |
| break; |
| |
| case GIMPLE_EH_ELSE: |
| { |
| geh_else *eh_else_stmt = as_a <geh_else *> (stmt); |
| collect_finally_tree_1 (gimple_eh_else_n_body (eh_else_stmt), region); |
| collect_finally_tree_1 (gimple_eh_else_e_body (eh_else_stmt), region); |
| } |
| break; |
| |
| default: |
| /* A type, a decl, or some kind of statement that we're not |
| interested in. Don't walk them. */ |
| break; |
| } |
| } |
| |
| |
| /* Use the finally tree to determine if a jump from START to TARGET |
| would leave the try_finally node that START lives in. */ |
| |
| static bool |
| outside_finally_tree (treemple start, gimple *target) |
| { |
| struct finally_tree_node n, *p; |
| |
| do |
| { |
| n.child = start; |
| p = finally_tree->find (&n); |
| if (!p) |
| return true; |
| start.g = p->parent; |
| } |
| while (start.g != target); |
| |
| return false; |
| } |
| |
| /* Second pass of EH node decomposition. Actually transform the GIMPLE_TRY |
| nodes into a set of gotos, magic labels, and eh regions. |
| The eh region creation is straight-forward, but frobbing all the gotos |
| and such into shape isn't. */ |
| |
| /* The sequence into which we record all EH stuff. This will be |
| placed at the end of the function when we're all done. */ |
| static gimple_seq eh_seq; |
| |
| /* Record whether an EH region contains something that can throw, |
| indexed by EH region number. */ |
| static bitmap eh_region_may_contain_throw_map; |
| |
| /* The GOTO_QUEUE is an array of GIMPLE_GOTO and GIMPLE_RETURN |
| statements that are seen to escape this GIMPLE_TRY_FINALLY node. |
| The idea is to record a gimple statement for everything except for |
| the conditionals, which get their labels recorded. Since labels are |
| of type 'tree', we need this node to store both gimple and tree |
| objects. REPL_STMT is the sequence used to replace the goto/return |
| statement. CONT_STMT is used to store the statement that allows |
| the return/goto to jump to the original destination. */ |
| |
| struct goto_queue_node |
| { |
| treemple stmt; |
| location_t location; |
| gimple_seq repl_stmt; |
| gimple *cont_stmt; |
| int index; |
| /* This is used when index >= 0 to indicate that stmt is a label (as |
| opposed to a goto stmt). */ |
| int is_label; |
| }; |
| |
| /* State of the world while lowering. */ |
| |
| struct leh_state |
| { |
| /* What's "current" while constructing the eh region tree. These |
| correspond to variables of the same name in cfun->eh, which we |
| don't have easy access to. */ |
| eh_region cur_region; |
| |
| /* What's "current" for the purposes of __builtin_eh_pointer. For |
| a CATCH, this is the associated TRY. For an EH_FILTER, this is |
| the associated ALLOWED_EXCEPTIONS, etc. */ |
| eh_region ehp_region; |
| |
| /* Processing of TRY_FINALLY requires a bit more state. This is |
| split out into a separate structure so that we don't have to |
| copy so much when processing other nodes. */ |
| struct leh_tf_state *tf; |
| |
| /* Outer non-clean up region. */ |
| eh_region outer_non_cleanup; |
| }; |
| |
| struct leh_tf_state |
| { |
| /* Pointer to the GIMPLE_TRY_FINALLY node under discussion. The |
| try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain |
| this so that outside_finally_tree can reliably reference the tree used |
| in the collect_finally_tree data structures. */ |
| gtry *try_finally_expr; |
| gtry *top_p; |
| |
| /* While lowering a top_p usually it is expanded into multiple statements, |
| thus we need the following field to store them. */ |
| gimple_seq top_p_seq; |
| |
| /* The state outside this try_finally node. */ |
| struct leh_state *outer; |
| |
| /* The exception region created for it. */ |
| eh_region region; |
| |
| /* The goto queue. */ |
| struct goto_queue_node *goto_queue; |
| size_t goto_queue_size; |
| size_t goto_queue_active; |
| |
| /* Pointer map to help in searching goto_queue when it is large. */ |
| hash_map<gimple *, goto_queue_node *> *goto_queue_map; |
| |
| /* The set of unique labels seen as entries in the goto queue. */ |
| vec<tree> dest_array; |
| |
| /* A label to be added at the end of the completed transformed |
| sequence. It will be set if may_fallthru was true *at one time*, |
| though subsequent transformations may have cleared that flag. */ |
| tree fallthru_label; |
| |
| /* True if it is possible to fall out the bottom of the try block. |
| Cleared if the fallthru is converted to a goto. */ |
| bool may_fallthru; |
| |
| /* True if any entry in goto_queue is a GIMPLE_RETURN. */ |
| bool may_return; |
| |
| /* True if the finally block can receive an exception edge. |
| Cleared if the exception case is handled by code duplication. */ |
| bool may_throw; |
| }; |
| |
| static gimple_seq lower_eh_must_not_throw (struct leh_state *, gtry *); |
| |
| /* Search for STMT in the goto queue. Return the replacement, |
| or null if the statement isn't in the queue. */ |
| |
| #define LARGE_GOTO_QUEUE 20 |
| |
| static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq *seq); |
| |
| static gimple_seq |
| find_goto_replacement (struct leh_tf_state *tf, treemple stmt) |
| { |
| unsigned int i; |
| |
| if (tf->goto_queue_active < LARGE_GOTO_QUEUE) |
| { |
| for (i = 0; i < tf->goto_queue_active; i++) |
| if ( tf->goto_queue[i].stmt.g == stmt.g) |
| return tf->goto_queue[i].repl_stmt; |
| return NULL; |
| } |
| |
| /* If we have a large number of entries in the goto_queue, create a |
| pointer map and use that for searching. */ |
| |
| if (!tf->goto_queue_map) |
| { |
| tf->goto_queue_map = new hash_map<gimple *, goto_queue_node *>; |
| for (i = 0; i < tf->goto_queue_active; i++) |
| { |
| bool existed = tf->goto_queue_map->put (tf->goto_queue[i].stmt.g, |
| &tf->goto_queue[i]); |
| gcc_assert (!existed); |
| } |
| } |
| |
| goto_queue_node **slot = tf->goto_queue_map->get (stmt.g); |
| if (slot != NULL) |
| return ((*slot)->repl_stmt); |
| |
| return NULL; |
| } |
| |
| /* A subroutine of replace_goto_queue_1. Handles the sub-clauses of a |
| lowered GIMPLE_COND. If, by chance, the replacement is a simple goto, |
| then we can just splat it in, otherwise we add the new stmts immediately |
| after the GIMPLE_COND and redirect. */ |
| |
| static void |
| replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf, |
| gimple_stmt_iterator *gsi) |
| { |
| tree label; |
| gimple_seq new_seq; |
| treemple temp; |
| location_t loc = gimple_location (gsi_stmt (*gsi)); |
| |
| temp.tp = tp; |
| new_seq = find_goto_replacement (tf, temp); |
| if (!new_seq) |
| return; |
| |
| if (gimple_seq_singleton_p (new_seq) |
| && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO) |
| { |
| *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq)); |
| return; |
| } |
| |
| label = create_artificial_label (loc); |
| /* Set the new label for the GIMPLE_COND */ |
| *tp = label; |
| |
| gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING); |
| gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING); |
| } |
| |
| /* The real work of replace_goto_queue. Returns with TSI updated to |
| point to the next statement. */ |
| |
| static void replace_goto_queue_stmt_list (gimple_seq *, struct leh_tf_state *); |
| |
| static void |
| replace_goto_queue_1 (gimple *stmt, struct leh_tf_state *tf, |
| gimple_stmt_iterator *gsi) |
| { |
| gimple_seq seq; |
| treemple temp; |
| temp.g = NULL; |
| |
| switch (gimple_code (stmt)) |
| { |
| case GIMPLE_GOTO: |
| case GIMPLE_RETURN: |
| temp.g = stmt; |
| seq = find_goto_replacement (tf, temp); |
| if (seq) |
| { |
| gimple_stmt_iterator i; |
| seq = gimple_seq_copy (seq); |
| for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) |
| gimple_set_location (gsi_stmt (i), gimple_location (stmt)); |
| gsi_insert_seq_before (gsi, seq, GSI_SAME_STMT); |
| gsi_remove (gsi, false); |
| return; |
| } |
| break; |
| |
| case GIMPLE_COND: |
| replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 2), tf, gsi); |
| replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 3), tf, gsi); |
| break; |
| |
| case GIMPLE_TRY: |
| replace_goto_queue_stmt_list (gimple_try_eval_ptr (stmt), tf); |
| replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf); |
| break; |
| case GIMPLE_CATCH: |
| replace_goto_queue_stmt_list (gimple_catch_handler_ptr ( |
| as_a <gcatch *> (stmt)), |
| tf); |
| break; |
| case GIMPLE_EH_FILTER: |
| replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt), tf); |
| break; |
| case GIMPLE_EH_ELSE: |
| { |
| geh_else *eh_else_stmt = as_a <geh_else *> (stmt); |
| replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (eh_else_stmt), |
| tf); |
| replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (eh_else_stmt), |
| tf); |
| } |
| break; |
| |
| default: |
| /* These won't have gotos in them. */ |
| break; |
| } |
| |
| gsi_next (gsi); |
| } |
| |
| /* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */ |
| |
| static void |
| replace_goto_queue_stmt_list (gimple_seq *seq, struct leh_tf_state *tf) |
| { |
| gimple_stmt_iterator gsi = gsi_start (*seq); |
| |
| while (!gsi_end_p (gsi)) |
| replace_goto_queue_1 (gsi_stmt (gsi), tf, &gsi); |
| } |
| |
| /* Replace all goto queue members. */ |
| |
| static void |
| replace_goto_queue (struct leh_tf_state *tf) |
| { |
| if (tf->goto_queue_active == 0) |
| return; |
| replace_goto_queue_stmt_list (&tf->top_p_seq, tf); |
| replace_goto_queue_stmt_list (&eh_seq, tf); |
| } |
| |
| /* Add a new record to the goto queue contained in TF. NEW_STMT is the |
| data to be added, IS_LABEL indicates whether NEW_STMT is a label or |
| a gimple return. */ |
| |
| static void |
| record_in_goto_queue (struct leh_tf_state *tf, |
| treemple new_stmt, |
| int index, |
| bool is_label, |
| location_t location) |
| { |
| size_t active, size; |
| struct goto_queue_node *q; |
| |
| gcc_assert (!tf->goto_queue_map); |
| |
| active = tf->goto_queue_active; |
| size = tf->goto_queue_size; |
| if (active >= size) |
| { |
| size = (size ? size * 2 : 32); |
| tf->goto_queue_size = size; |
| tf->goto_queue |
| = XRESIZEVEC (struct goto_queue_node, tf->goto_queue, size); |
| } |
| |
| q = &tf->goto_queue[active]; |
| tf->goto_queue_active = active + 1; |
| |
| memset (q, 0, sizeof (*q)); |
| q->stmt = new_stmt; |
| q->index = index; |
| q->location = location; |
| q->is_label = is_label; |
| } |
| |
| /* Record the LABEL label in the goto queue contained in TF. |
| TF is not null. */ |
| |
| static void |
| record_in_goto_queue_label (struct leh_tf_state *tf, treemple stmt, tree label, |
| location_t location) |
| { |
| int index; |
| treemple temp, new_stmt; |
| |
| if (!label) |
| return; |
| |
| /* Computed and non-local gotos do not get processed. Given |
| their nature we can neither tell whether we've escaped the |
| finally block nor redirect them if we knew. */ |
| if (TREE_CODE (label) != LABEL_DECL) |
| return; |
| |
| /* No need to record gotos that don't leave the try block. */ |
| temp.t = label; |
| if (!outside_finally_tree (temp, tf->try_finally_expr)) |
| return; |
| |
| if (! tf->dest_array.exists ()) |
| { |
| tf->dest_array.create (10); |
| tf->dest_array.quick_push (label); |
| index = 0; |
| } |
| else |
| { |
| int n = tf->dest_array.length (); |
| for (index = 0; index < n; ++index) |
| if (tf->dest_array[index] == label) |
| break; |
| if (index == n) |
| tf->dest_array.safe_push (label); |
| } |
| |
| /* In the case of a GOTO we want to record the destination label, |
| since with a GIMPLE_COND we have an easy access to the then/else |
| labels. */ |
| new_stmt = stmt; |
| record_in_goto_queue (tf, new_stmt, index, true, location); |
| } |
| |
| /* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally |
| node, and if so record that fact in the goto queue associated with that |
| try_finally node. */ |
| |
| static void |
| maybe_record_in_goto_queue (struct leh_state *state, gimple *stmt) |
| { |
| struct leh_tf_state *tf = state->tf; |
| treemple new_stmt; |
| |
| if (!tf) |
| return; |
| |
| switch (gimple_code (stmt)) |
| { |
| case GIMPLE_COND: |
| { |
| gcond *cond_stmt = as_a <gcond *> (stmt); |
| new_stmt.tp = gimple_op_ptr (cond_stmt, 2); |
| record_in_goto_queue_label (tf, new_stmt, |
| gimple_cond_true_label (cond_stmt), |
| EXPR_LOCATION (*new_stmt.tp)); |
| new_stmt.tp = gimple_op_ptr (cond_stmt, 3); |
| record_in_goto_queue_label (tf, new_stmt, |
| gimple_cond_false_label (cond_stmt), |
| EXPR_LOCATION (*new_stmt.tp)); |
| } |
| break; |
| case GIMPLE_GOTO: |
| new_stmt.g = stmt; |
| record_in_goto_queue_label (tf, new_stmt, gimple_goto_dest (stmt), |
| gimple_location (stmt)); |
| break; |
| |
| case GIMPLE_RETURN: |
| tf->may_return = true; |
| new_stmt.g = stmt; |
| record_in_goto_queue (tf, new_stmt, -1, false, gimple_location (stmt)); |
| break; |
| |
| default: |
| gcc_unreachable (); |
| } |
| } |
| |
| |
| #if CHECKING_P |
| /* We do not process GIMPLE_SWITCHes for now. As long as the original source |
| was in fact structured, and we've not yet done jump threading, then none |
| of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */ |
| |
| static void |
| verify_norecord_switch_expr (struct leh_state *state, |
| gswitch *switch_expr) |
| { |
| struct leh_tf_state *tf = state->tf; |
| size_t i, n; |
| |
| if (!tf) |
| return; |
| |
| n = gimple_switch_num_labels (switch_expr); |
| |
| for (i = 0; i < n; ++i) |
| { |
| treemple temp; |
| tree lab = CASE_LABEL (gimple_switch_label (switch_expr, i)); |
| temp.t = lab; |
| gcc_assert (!outside_finally_tree (temp, tf->try_finally_expr)); |
| } |
| } |
| #else |
| #define verify_norecord_switch_expr(state, switch_expr) |
| #endif |
| |
| /* Redirect a RETURN_EXPR pointed to by Q to FINLAB. If MOD is |
| non-null, insert it before the new branch. */ |
| |
| static void |
| do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod) |
| { |
| gimple *x; |
| |
| /* In the case of a return, the queue node must be a gimple statement. */ |
| gcc_assert (!q->is_label); |
| |
| /* Note that the return value may have already been computed, e.g., |
| |
| int x; |
| int foo (void) |
| { |
| x = 0; |
| try { |
| return x; |
| } finally { |
| x++; |
| } |
| } |
| |
| should return 0, not 1. We don't have to do anything to make |
| this happens because the return value has been placed in the |
| RESULT_DECL already. */ |
| |
| q->cont_stmt = q->stmt.g; |
| |
| if (mod) |
| gimple_seq_add_seq (&q->repl_stmt, mod); |
| |
| x = gimple_build_goto (finlab); |
| gimple_set_location (x, q->location); |
| gimple_seq_add_stmt (&q->repl_stmt, x); |
| } |
| |
| /* Similar, but easier, for GIMPLE_GOTO. */ |
| |
| static void |
| do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod, |
| struct leh_tf_state *tf) |
| { |
| ggoto *x; |
| |
| gcc_assert (q->is_label); |
| |
| q->cont_stmt = gimple_build_goto (tf->dest_array[q->index]); |
| |
| if (mod) |
| gimple_seq_add_seq (&q->repl_stmt, mod); |
| |
| x = gimple_build_goto (finlab); |
| gimple_set_location (x, q->location); |
| gimple_seq_add_stmt (&q->repl_stmt, x); |
| } |
| |
| /* Emit a standard landing pad sequence into SEQ for REGION. */ |
| |
| static void |
| emit_post_landing_pad (gimple_seq *seq, eh_region region) |
| { |
| eh_landing_pad lp = region->landing_pads; |
| glabel *x; |
| |
| if (lp == NULL) |
| lp = gen_eh_landing_pad (region); |
| |
| lp->post_landing_pad = create_artificial_label (UNKNOWN_LOCATION); |
| EH_LANDING_PAD_NR (lp->post_landing_pad) = lp->index; |
| |
| x = gimple_build_label (lp->post_landing_pad); |
| gimple_seq_add_stmt (seq, x); |
| } |
| |
| /* Emit a RESX statement into SEQ for REGION. */ |
| |
| static void |
| emit_resx (gimple_seq *seq, eh_region region) |
| { |
| gresx *x = gimple_build_resx (region->index); |
| gimple_seq_add_stmt (seq, x); |
| if (region->outer) |
| record_stmt_eh_region (region->outer, x); |
| } |
| |
| /* Note that the current EH region may contain a throw, or a |
| call to a function which itself may contain a throw. */ |
| |
| static void |
| note_eh_region_may_contain_throw (eh_region region) |
| { |
| while (bitmap_set_bit (eh_region_may_contain_throw_map, region->index)) |
| { |
| if (region->type == ERT_MUST_NOT_THROW) |
| break; |
| region = region->outer; |
| if (region == NULL) |
| break; |
| } |
| } |
| |
| /* Check if REGION has been marked as containing a throw. If REGION is |
| NULL, this predicate is false. */ |
| |
| static inline bool |
| eh_region_may_contain_throw (eh_region r) |
| { |
| return r && bitmap_bit_p (eh_region_may_contain_throw_map, r->index); |
| } |
| |
| /* We want to transform |
| try { body; } catch { stuff; } |
| to |
| normal_sequence: |
| body; |
| over: |
| eh_sequence: |
| landing_pad: |
| stuff; |
| goto over; |
| |
| TP is a GIMPLE_TRY node. REGION is the region whose post_landing_pad |
| should be placed before the second operand, or NULL. OVER is |
| an existing label that should be put at the exit, or NULL. */ |
| |
| static gimple_seq |
| frob_into_branch_around (gtry *tp, eh_region region, tree over) |
| { |
| gimple *x; |
| gimple_seq cleanup, result; |
| location_t loc = gimple_location (tp); |
| |
| cleanup = gimple_try_cleanup (tp); |
| result = gimple_try_eval (tp); |
| |
| if (region) |
| emit_post_landing_pad (&eh_seq, region); |
| |
| if (gimple_seq_may_fallthru (cleanup)) |
| { |
| if (!over) |
| over = create_artificial_label (loc); |
| x = gimple_build_goto (over); |
| gimple_set_location (x, loc); |
| gimple_seq_add_stmt (&cleanup, x); |
| } |
| gimple_seq_add_seq (&eh_seq, cleanup); |
| |
| if (over) |
| { |
| x = gimple_build_label (over); |
| gimple_seq_add_stmt (&result, x); |
| } |
| return result; |
| } |
| |
| /* A subroutine of lower_try_finally. Duplicate the tree rooted at T. |
| Make sure to record all new labels found. */ |
| |
| static gimple_seq |
| lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state, |
| location_t loc) |
| { |
| gtry *region = NULL; |
| gimple_seq new_seq; |
| gimple_stmt_iterator gsi; |
| |
| new_seq = copy_gimple_seq_and_replace_locals (seq); |
| |
| for (gsi = gsi_start (new_seq); !gsi_end_p (gsi); gsi_next (&gsi)) |
| { |
| gimple *stmt = gsi_stmt (gsi); |
| if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION) |
| { |
| tree block = gimple_block (stmt); |
| gimple_set_location (stmt, loc); |
| gimple_set_block (stmt, block); |
| } |
| } |
| |
| if (outer_state->tf) |
| region = outer_state->tf->try_finally_expr; |
| collect_finally_tree_1 (new_seq, region); |
| |
| return new_seq; |
| } |
| |
| /* A subroutine of lower_try_finally. Create a fallthru label for |
| the given try_finally state. The only tricky bit here is that |
| we have to make sure to record the label in our outer context. */ |
| |
| static tree |
| lower_try_finally_fallthru_label (struct leh_tf_state *tf) |
| { |
| tree label = tf->fallthru_label; |
| treemple temp; |
| |
| if (!label) |
| { |
| label = create_artificial_label (gimple_location (tf->try_finally_expr)); |
| tf->fallthru_label = label; |
| if (tf->outer->tf) |
| { |
| temp.t = label; |
| record_in_finally_tree (temp, tf->outer->tf->try_finally_expr); |
| } |
| } |
| return label; |
| } |
| |
| /* A subroutine of lower_try_finally. If FINALLY consits of a |
| GIMPLE_EH_ELSE node, return it. */ |
| |
| static inline geh_else * |
| get_eh_else (gimple_seq finally) |
| { |
| gimple *x = gimple_seq_first_stmt (finally); |
| if (gimple_code (x) == GIMPLE_EH_ELSE) |
| { |
| gcc_assert (gimple_seq_singleton_p (finally)); |
| return as_a <geh_else *> (x); |
| } |
| return NULL; |
| } |
| |
| /* A subroutine of lower_try_finally. If the eh_protect_cleanup_actions |
| langhook returns non-null, then the language requires that the exception |
| path out of a try_finally be treated specially. To wit: the code within |
| the finally block may not itself throw an exception. We have two choices |
| here. First we can duplicate the finally block and wrap it in a |
| must_not_throw region. Second, we can generate code like |
| |
| try { |
| finally_block; |
| } catch { |
| if (fintmp == eh_edge) |
| protect_cleanup_actions; |
| } |
| |
| where "fintmp" is the temporary used in the switch statement generation |
| alternative considered below. For the nonce, we always choose the first |
| option. |
| |
| THIS_STATE may be null if this is a try-cleanup, not a try-finally. */ |
| |
| static void |
| honor_protect_cleanup_actions (struct leh_state *outer_state, |
| struct leh_state *this_state, |
| struct leh_tf_state *tf) |
| { |
| gimple_seq finally = gimple_try_cleanup (tf->top_p); |
| |
| /* EH_ELSE doesn't come from user code; only compiler generated stuff. |
| It does need to be handled here, so as to separate the (different) |
| EH path from the normal path. But we should not attempt to wrap |
| it with a must-not-throw node (which indeed gets in the way). */ |
| if (geh_else *eh_else = get_eh_else (finally)) |
| { |
| gimple_try_set_cleanup (tf->top_p, gimple_eh_else_n_body (eh_else)); |
| finally = gimple_eh_else_e_body (eh_else); |
| |
| /* Let the ELSE see the exception that's being processed, but |
| since the cleanup is outside the try block, process it with |
| outer_state, otherwise it may be used as a cleanup for |
| itself, and Bad Things (TM) ensue. */ |
| eh_region save_ehp = outer_state->ehp_region; |
| outer_state->ehp_region = this_state->cur_region; |
| lower_eh_constructs_1 (outer_state, &finally); |
| outer_state->ehp_region = save_ehp; |
| } |
| else |
| { |
| /* First check for nothing to do. */ |
| if (lang_hooks.eh_protect_cleanup_actions == NULL) |
| return; |
| tree actions = lang_hooks.eh_protect_cleanup_actions (); |
| if (actions == NULL) |
| return; |
| |
| if (this_state) |
| finally = lower_try_finally_dup_block (finally, outer_state, |
| gimple_location (tf->try_finally_expr)); |
| |
| /* If this cleanup consists of a TRY_CATCH_EXPR with TRY_CATCH_IS_CLEANUP |
| set, the handler of the TRY_CATCH_EXPR is another cleanup which ought |
| to be in an enclosing scope, but needs to be implemented at this level |
| to avoid a nesting violation (see wrap_temporary_cleanups in |
| cp/decl.c). Since it's logically at an outer level, we should call |
| terminate before we get to it, so strip it away before adding the |
| MUST_NOT_THROW filter. */ |
| gimple_stmt_iterator gsi = gsi_start (finally); |
| gimple *x = gsi_stmt (gsi); |
| if (gimple_code (x) == GIMPLE_TRY |
| && gimple_try_kind (x) == GIMPLE_TRY_CATCH |
| && gimple_try_catch_is_cleanup (x)) |
| { |
| gsi_insert_seq_before (&gsi, gimple_try_eval (x), GSI_SAME_STMT); |
| gsi_remove (&gsi, false); |
| } |
| |
| /* Wrap the block with protect_cleanup_actions as the action. */ |
| geh_mnt *eh_mnt = gimple_build_eh_must_not_throw (actions); |
| gtry *try_stmt = gimple_build_try (finally, |
| gimple_seq_alloc_with_stmt (eh_mnt), |
| GIMPLE_TRY_CATCH); |
| finally = lower_eh_must_not_throw (outer_state, try_stmt); |
| } |
| |
| /* Drop all of this into the exception sequence. */ |
| emit_post_landing_pad (&eh_seq, tf->region); |
| gimple_seq_add_seq (&eh_seq, finally); |
| if (gimple_seq_may_fallthru (finally)) |
| emit_resx (&eh_seq, tf->region); |
| |
| /* Having now been handled, EH isn't to be considered with |
| the rest of the outgoing edges. */ |
| tf->may_throw = false; |
| } |
| |
| /* A subroutine of lower_try_finally. We have determined that there is |
| no fallthru edge out of the finally block. This means that there is |
| no outgoing edge corresponding to any incoming edge. Restructure the |
| try_finally node for this special case. */ |
| |
| static void |
| lower_try_finally_nofallthru (struct leh_state *state, |
| struct leh_tf_state *tf) |
| { |
| tree lab; |
| gimple *x; |
| geh_else *eh_else; |
| gimple_seq finally; |
| struct goto_queue_node *q, *qe; |
| |
| lab = create_artificial_label (gimple_location (tf->try_finally_expr)); |
| |
| /* We expect that tf->top_p is a GIMPLE_TRY. */ |
| finally = gimple_try_cleanup (tf->top_p); |
| tf->top_p_seq = gimple_try_eval (tf->top_p); |
| |
| x = gimple_build_label (lab); |
| gimple_seq_add_stmt (&tf->top_p_seq, x); |
| |
| q = tf->goto_queue; |
| qe = q + tf->goto_queue_active; |
| for (; q < qe; ++q) |
| if (q->index < 0) |
| do_return_redirection (q, lab, NULL); |
| else |
| do_goto_redirection (q, lab, NULL, tf); |
| |
| replace_goto_queue (tf); |
| |
| /* Emit the finally block into the stream. Lower EH_ELSE at this time. */ |
| eh_else = get_eh_else (finally); |
| if (eh_else) |
| { |
| finally = gimple_eh_else_n_body (eh_else); |
| lower_eh_constructs_1 (state, &finally); |
| gimple_seq_add_seq (&tf->top_p_seq, finally); |
| |
| if (tf->may_throw) |
| { |
| finally = gimple_eh_else_e_body (eh_else); |
| lower_eh_constructs_1 (state, &finally); |
| |
| emit_post_landing_pad (&eh_seq, tf->region); |
| gimple_seq_add_seq (&eh_seq, finally); |
| } |
| } |
| else |
| { |
| lower_eh_constructs_1 (state, &finally); |
| gimple_seq_add_seq (&tf->top_p_seq, finally); |
| |
| if (tf->may_throw) |
| { |
| emit_post_landing_pad (&eh_seq, tf->region); |
| |
| x = gimple_build_goto (lab); |
| gimple_set_location (x, gimple_location (tf->try_finally_expr)); |
| gimple_seq_add_stmt (&eh_seq, x); |
| } |
| } |
| } |
| |
| /* A subroutine of lower_try_finally. We have determined that there is |
| exactly one destination of the finally block. Restructure the |
| try_finally node for this special case. */ |
| |
| static void |
| lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf) |
| { |
| struct goto_queue_node *q, *qe; |
| geh_else *eh_else; |
| glabel *label_stmt; |
| gimple *x; |
| gimple_seq finally; |
| gimple_stmt_iterator gsi; |
| tree finally_label; |
| location_t loc = gimple_location (tf->try_finally_expr); |
| |
| finally = gimple_try_cleanup (tf->top_p); |
| tf->top_p_seq = gimple_try_eval (tf->top_p); |
| |
| /* Since there's only one destination, and the destination edge can only |
| either be EH or non-EH, that implies that all of our incoming edges |
| are of the same type. Therefore we can lower EH_ELSE immediately. */ |
| eh_else = get_eh_else (finally); |
| if (eh_else) |
| { |
| if (tf->may_throw) |
| finally = gimple_eh_else_e_body (eh_else); |
| else |
| finally = gimple_eh_else_n_body (eh_else); |
| } |
| |
| lower_eh_constructs_1 (state, &finally); |
| |
| for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi)) |
| { |
| gimple *stmt = gsi_stmt (gsi); |
| if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION) |
| { |
| tree block = gimple_block (stmt); |
| gimple_set_location (stmt, gimple_location (tf->try_finally_expr)); |
| gimple_set_block (stmt, block); |
| } |
| } |
| |
| if (tf->may_throw) |
| { |
| /* Only reachable via the exception edge. Add the given label to |
| the head of the FINALLY block. Append a RESX at the end. */ |
| emit_post_landing_pad (&eh_seq, tf->region); |
| gimple_seq_add_seq (&eh_seq, finally); |
| emit_resx (&eh_seq, tf->region); |
| return; |
| } |
| |
| if (tf->may_fallthru) |
| { |
| /* Only reachable via the fallthru edge. Do nothing but let |
| the two blocks run together; we'll fall out the bottom. */ |
| gimple_seq_add_seq (&tf->top_p_seq, finally); |
| return; |
| } |
| |
| finally_label = create_artificial_label (loc); |
| label_stmt = gimple_build_label (finally_label); |
| gimple_seq_add_stmt (&tf->top_p_seq, label_stmt); |
| |
| gimple_seq_add_seq (&tf->top_p_seq, finally); |
| |
| q = tf->goto_queue; |
| qe = q + tf->goto_queue_active; |
| |
| if (tf->may_return) |
| { |
| /* Reachable by return expressions only. Redirect them. */ |
| for (; q < qe; ++q) |
| do_return_redirection (q, finally_label, NULL); |
| replace_goto_queue (tf); |
| } |
| else |
| { |
| /* Reachable by goto expressions only. Redirect them. */ |
| for (; q < qe; ++q) |
| do_goto_redirection (q, finally_label, NULL, tf); |
| replace_goto_queue (tf); |
| |
| if (tf->dest_array[0] == tf->fallthru_label) |
| { |
| /* Reachable by goto to fallthru label only. Redirect it |
| to the new label (already created, sadly), and do not |
| emit the final branch out, or the fallthru label. */ |
| tf->fallthru_label = NULL; |
| return; |
| } |
| } |
| |
| /* Place the original return/goto to the original destination |
| immediately after the finally block. */ |
| x = tf->goto_queue[0].cont_stmt; |
| gimple_seq_add_stmt (&tf->top_p_seq, x); |
| maybe_record_in_goto_queue (state, x); |
| } |
| |
| /* A subroutine of lower_try_finally. There are multiple edges incoming |
| and outgoing from the finally block. Implement this by duplicating the |
| finally block for every destination. */ |
| |
| static void |
| lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf) |
| { |
| gimple_seq finally; |
| gimple_seq new_stmt; |
| gimple_seq seq; |
| gimple *x; |
| geh_else *eh_else; |
| tree tmp; |
| location_t tf_loc = gimple_location (tf->try_finally_expr); |
| |
| finally = gimple_try_cleanup (tf->top_p); |
| |
| /* Notice EH_ELSE, and simplify some of the remaining code |
| by considering FINALLY to be the normal return path only. */ |
| eh_else = get_eh_else (finally); |
| if (eh_else) |
| finally = gimple_eh_else_n_body (eh_else); |
| |
| tf->top_p_seq = gimple_try_eval (tf->top_p); |
| new_stmt = NULL; |
| |
| if (tf->may_fallthru) |
| { |
| seq = lower_try_finally_dup_block (finally, state, tf_loc); |
| lower_eh_constructs_1 (state, &seq); |
| gimple_seq_add_seq (&new_stmt, seq); |
| |
| tmp = lower_try_finally_fallthru_label (tf); |
| x = gimple_build_goto (tmp); |
| gimple_set_location (x, tf_loc); |
| gimple_seq_add_stmt (&new_stmt, x); |
| } |
| |
| if (tf->may_throw) |
| { |
| /* We don't need to copy the EH path of EH_ELSE, |
| since it is only emitted once. */ |
| if (eh_else) |
| seq = gimple_eh_else_e_body (eh_else); |
| else |
| seq = lower_try_finally_dup_block (finally, state, tf_loc); |
| lower_eh_constructs_1 (state, &seq); |
| |
| emit_post_landing_pad (&eh_seq, tf->region); |
| gimple_seq_add_seq (&eh_seq, seq); |
| emit_resx (&eh_seq, tf->region); |
| } |
| |
| if (tf->goto_queue) |
| { |
| struct goto_queue_node *q, *qe; |
| int return_index, index; |
| struct labels_s |
| { |
| struct goto_queue_node *q; |
| tree label; |
| } *labels; |
| |
| return_index = tf->dest_array.length (); |
| labels = XCNEWVEC (struct labels_s, return_index + 1); |
| |
| q = tf->goto_queue; |
| qe = q + tf->goto_queue_active; |
| for (; q < qe; q++) |
| { |
| index = q->index < 0 ? return_index : q->index; |
| |
| if (!labels[index].q) |
| labels[index].q = q; |
| } |
| |
| for (index = 0; index < return_index + 1; index++) |
| { |
| tree lab; |
| |
| q = labels[index].q; |
| if (! q) |
| continue; |
| |
| lab = labels[index].label |
| = create_artificial_label (tf_loc); |
| |
| if (index == return_index) |
| do_return_redirection (q, lab, NULL); |
| else |
| do_goto_redirection (q, lab, NULL, tf); |
| |
| x = gimple_build_label (lab); |
| gimple_seq_add_stmt (&new_stmt, x); |
| |
| seq = lower_try_finally_dup_block (finally, state, q->location); |
| lower_eh_constructs_1 (state, &seq); |
| gimple_seq_add_seq (&new_stmt, seq); |
| |
| gimple_seq_add_stmt (&new_stmt, q->cont_stmt); |
| maybe_record_in_goto_queue (state, q->cont_stmt); |
| } |
| |
| for (q = tf->goto_queue; q < qe; q++) |
| { |
| tree lab; |
| |
| index = q->index < 0 ? return_index : q->index; |
| |
| if (labels[index].q == q) |
| continue; |
| |
| lab = labels[index].label; |
| |
| if (index == return_index) |
| do_return_redirection (q, lab, NULL); |
| else |
| do_goto_redirection (q, lab, NULL, tf); |
| } |
| |
| replace_goto_queue (tf); |
| free (labels); |
| } |
| |
| /* Need to link new stmts after running replace_goto_queue due |
| to not wanting to process the same goto stmts twice. */ |
| gimple_seq_add_seq (&tf->top_p_seq, new_stmt); |
| } |
| |
| /* A subroutine of lower_try_finally. There are multiple edges incoming |
| and outgoing from the finally block. Implement this by instrumenting |
| each incoming edge and creating a switch statement at the end of the |
| finally block that branches to the appropriate destination. */ |
| |
| static void |
| lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf) |
| { |
| struct goto_queue_node *q, *qe; |
| tree finally_tmp, finally_label; |
| int return_index, eh_index, fallthru_index; |
| int nlabels, ndests, j, last_case_index; |
| tree last_case; |
| auto_vec<tree> case_label_vec; |
| gimple_seq switch_body = NULL; |
| gimple *x; |
| geh_else *eh_else; |
| tree tmp; |
| gimple *switch_stmt; |
| gimple_seq finally; |
| hash_map<tree, gimple *> *cont_map = NULL; |
| /* The location of the TRY_FINALLY stmt. */ |
| location_t tf_loc = gimple_location (tf->try_finally_expr); |
| /* The location of the finally block. */ |
| location_t finally_loc; |
| |
| finally = gimple_try_cleanup (tf->top_p); |
| eh_else = get_eh_else (finally); |
| |
| /* Mash the TRY block to the head of the chain. */ |
| tf->top_p_seq = gimple_try_eval (tf->top_p); |
| |
| /* The location of the finally is either the last stmt in the finally |
| block or the location of the TRY_FINALLY itself. */ |
| x = gimple_seq_last_stmt (finally); |
| finally_loc = x ? gimple_location (x) : tf_loc; |
| |
| /* Prepare for switch statement generation. */ |
| nlabels = tf->dest_array.length (); |
| return_index = nlabels; |
| eh_index = return_index + tf->may_return; |
| fallthru_index = eh_index + (tf->may_throw && !eh_else); |
| ndests = fallthru_index + tf->may_fallthru; |
| |
| finally_tmp = create_tmp_var (integer_type_node, "finally_tmp"); |
| finally_label = create_artificial_label (finally_loc); |
| |
| /* We use vec::quick_push on case_label_vec throughout this function, |
| since we know the size in advance and allocate precisely as muce |
| space as needed. */ |
| case_label_vec.create (ndests); |
| last_case = NULL; |
| last_case_index = 0; |
| |
| /* Begin inserting code for getting to the finally block. Things |
| are done in this order to correspond to the sequence the code is |
| laid out. */ |
| |
| if (tf->may_fallthru) |
| { |
| x = gimple_build_assign (finally_tmp, |
| build_int_cst (integer_type_node, |
| fallthru_index)); |
| gimple_set_location (x, finally_loc); |
| gimple_seq_add_stmt (&tf->top_p_seq, x); |
| |
| tmp = build_int_cst (integer_type_node, fallthru_index); |
| last_case = build_case_label (tmp, NULL, |
| create_artificial_label (finally_loc)); |
| case_label_vec.quick_push (last_case); |
| last_case_index++; |
| |
| x = gimple_build_label (CASE_LABEL (last_case)); |
| gimple_seq_add_stmt (&switch_body, x); |
| |
| tmp = lower_try_finally_fallthru_label (tf); |
| x = gimple_build_goto (tmp); |
| gimple_set_location (x, finally_loc); |
| gimple_seq_add_stmt (&switch_body, x); |
| } |
| |
| /* For EH_ELSE, emit the exception path (plus resx) now, then |
| subsequently we only need consider the normal path. */ |
| if (eh_else) |
| { |
| if (tf->may_throw) |
| { |
| finally = gimple_eh_else_e_body (eh_else); |
| lower_eh_constructs_1 (state, &finally); |
| |
| emit_post_landing_pad (&eh_seq, tf->region); |
| gimple_seq_add_seq (&eh_seq, finally); |
| emit_resx (&eh_seq, tf->region); |
| } |
| |
| finally = gimple_eh_else_n_body (eh_else); |
| } |
| else if (tf->may_throw) |
| { |
| emit_post_landing_pad (&eh_seq, tf->region); |
| |
| x = gimple_build_assign (finally_tmp, |
| build_int_cst (integer_type_node, eh_index)); |
| gimple_seq_add_stmt (&eh_seq, x); |
| |
| x = gimple_build_goto (finally_label); |
| gimple_set_location (x, tf_loc); |
| gimple_seq_add_stmt (&eh_seq, x); |
| |
| tmp = build_int_cst (integer_type_node, eh_index); |
| last_case = build_case_label (tmp, NULL, |
| create_artificial_label (tf_loc)); |
| case_label_vec.quick_push (last_case); |
| last_case_index++; |
| |
| x = gimple_build_label (CASE_LABEL (last_case)); |
| gimple_seq_add_stmt (&eh_seq, x); |
| emit_resx (&eh_seq, tf->region); |
| } |
| |
| x = gimple_build_label (finally_label); |
| gimple_seq_add_stmt (&tf->top_p_seq, x); |
| |
| lower_eh_constructs_1 (state, &finally); |
| gimple_seq_add_seq (&tf->top_p_seq, finally); |
| |
| /* Redirect each incoming goto edge. */ |
| q = tf->goto_queue; |
| qe = q + tf->goto_queue_active; |
| j = last_case_index + tf->may_return; |
| /* Prepare the assignments to finally_tmp that are executed upon the |
| entrance through a particular edge. */ |
| for (; q < qe; ++q) |
| { |
| gimple_seq mod = NULL; |
| int switch_id; |
| unsigned int case_index; |
| |
| if (q->index < 0) |
| { |
| x = gimple_build_assign (finally_tmp, |
| build_int_cst (integer_type_node, |
| return_index)); |
| gimple_seq_add_stmt (&mod, x); |
| do_return_redirection (q, finally_label, mod); |
| switch_id = return_index; |
| } |
| else |
| { |
| x = gimple_build_assign (finally_tmp, |
| build_int_cst (integer_type_node, q->index)); |
| gimple_seq_add_stmt (&mod, x); |
| do_goto_redirection (q, finally_label, mod, tf); |
| switch_id = q->index; |
| } |
| |
| case_index = j + q->index; |
| if (case_label_vec.length () <= case_index || !case_label_vec[case_index]) |
| { |
| tree case_lab; |
| tmp = build_int_cst (integer_type_node, switch_id); |
| case_lab = build_case_label (tmp, NULL, |
| create_artificial_label (tf_loc)); |
| /* We store the cont_stmt in the pointer map, so that we can recover |
| it in the loop below. */ |
| if (!cont_map) |
| cont_map = new hash_map<tree, gimple *>; |
| cont_map->put (case_lab, q->cont_stmt); |
| case_label_vec.quick_push (case_lab); |
| } |
| } |
| for (j = last_case_index; j < last_case_index + nlabels; j++) |
| { |
| gimple *cont_stmt; |
| |
| last_case = case_label_vec[j]; |
| |
| gcc_assert (last_case); |
| gcc_assert (cont_map); |
| |
| cont_stmt = *cont_map->get (last_case); |
| |
| x = gimple_build_label (CASE_LABEL (last_case)); |
| gimple_seq_add_stmt (&switch_body, x); |
| gimple_seq_add_stmt (&switch_body, cont_stmt); |
| maybe_record_in_goto_queue (state, cont_stmt); |
| } |
| if (cont_map) |
| delete cont_map; |
| |
| replace_goto_queue (tf); |
| |
| /* Make sure that the last case is the default label, as one is required. |
| Then sort the labels, which is also required in GIMPLE. */ |
| CASE_LOW (last_case) = NULL; |
| tree tem = case_label_vec.pop (); |
| gcc_assert (tem == last_case); |
| sort_case_labels (case_label_vec); |
| |
| /* Build the switch statement, setting last_case to be the default |
| label. */ |
| switch_stmt = gimple_build_switch (finally_tmp, last_case, |
| case_label_vec); |
| gimple_set_location (switch_stmt, finally_loc); |
| |
| /* Need to link SWITCH_STMT after running replace_goto_queue |
| due to not wanting to process the same goto stmts twice. */ |
| gimple_seq_add_stmt (&tf->top_p_seq, switch_stmt); |
| gimple_seq_add_seq (&tf->top_p_seq, switch_body); |
| } |
| |
| /* Decide whether or not we are going to duplicate the finally block. |
| There are several considerations. |
| |
| Second, we'd like to prevent egregious code growth. One way to |
| do this is to estimate the size of the finally block, multiply |
| that by the number of copies we'd need to make, and compare against |
| the estimate of the size of the switch machinery we'd have to add. */ |
| |
| static bool |
| decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally) |
| { |
| int f_estimate, sw_estimate; |
| geh_else *eh_else; |
| |
| /* If there's an EH_ELSE involved, the exception path is separate |
| and really doesn't come into play for this computation. */ |
| eh_else = get_eh_else (finally); |
| if (eh_else) |
| { |
| ndests -= may_throw; |
| finally = gimple_eh_else_n_body (eh_else); |
| } |
| |
| if (!optimize) |
| { |
| gimple_stmt_iterator gsi; |
| |
| if (ndests == 1) |
| return true; |
| |
| for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi)) |
| { |
| /* Duplicate __builtin_stack_restore in the hope of eliminating it |
| on the EH paths and, consequently, useless cleanups. */ |
| gimple *stmt = gsi_stmt (gsi); |
| if (!is_gimple_debug (stmt) |
| && !gimple_clobber_p (stmt) |
| && !gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE)) |
| return false; |
| } |
| return true; |
| } |
| |
| /* Finally estimate N times, plus N gotos. */ |
| f_estimate = estimate_num_insns_seq (finally, &eni_size_weights); |
| f_estimate = (f_estimate + 1) * ndests; |
| |
| /* Switch statement (cost 10), N variable assignments, N gotos. */ |
| sw_estimate = 10 + 2 * ndests; |
| |
| /* Optimize for size clearly wants our best guess. */ |
| if (optimize_function_for_size_p (cfun)) |
| return f_estimate < sw_estimate; |
| |
| /* ??? These numbers are completely made up so far. */ |
| if (optimize > 1) |
| return f_estimate < 100 || f_estimate < sw_estimate * 2; |
| else |
| return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3; |
| } |
| |
| /* REG is current region of a LEH state. |
| is the enclosing region for a possible cleanup region, or the region |
| itself. Returns TRUE if such a region would be unreachable. |
| |
| Cleanup regions within a must-not-throw region aren't actually reachable |
| even if there are throwing stmts within them, because the personality |
| routine will call terminate before unwinding. */ |
| |
| static bool |
| cleanup_is_dead_in (leh_state *state) |
| { |
| if (flag_checking) |
| { |
| eh_region reg = state->cur_region; |
| while (reg && reg->type == ERT_CLEANUP) |
| reg = reg->outer; |
| |
| gcc_assert (reg == state->outer_non_cleanup); |
| } |
| |
| eh_region reg = state->outer_non_cleanup; |
| return (reg && reg->type == ERT_MUST_NOT_THROW); |
| } |
| |
| /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_FINALLY nodes |
| to a sequence of labels and blocks, plus the exception region trees |
| that record all the magic. This is complicated by the need to |
| arrange for the FINALLY block to be executed on all exits. */ |
| |
| static gimple_seq |
| lower_try_finally (struct leh_state *state, gtry *tp) |
| { |
| struct leh_tf_state this_tf; |
| struct leh_state this_state; |
| int ndests; |
| gimple_seq old_eh_seq; |
| |
| /* Process the try block. */ |
| |
| memset (&this_tf, 0, sizeof (this_tf)); |
| this_tf.try_finally_expr = tp; |
| this_tf.top_p = tp; |
| this_tf.outer = state; |
| if (using_eh_for_cleanups_p () && !cleanup_is_dead_in (state)) |
| { |
| this_tf.region = gen_eh_region_cleanup (state->cur_region); |
| this_state.cur_region = this_tf.region; |
| } |
| else |
| { |
| this_tf.region = NULL; |
| this_state.cur_region = state->cur_region; |
| } |
| |
| this_state.outer_non_cleanup = state->outer_non_cleanup; |
| this_state.ehp_region = state->ehp_region; |
| this_state.tf = &this_tf; |
| |
| old_eh_seq = eh_seq; |
| eh_seq = NULL; |
| |
| lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
| |
| /* Determine if the try block is escaped through the bottom. */ |
| this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp)); |
| |
| /* Determine if any exceptions are possible within the try block. */ |
| if (this_tf.region) |
| this_tf.may_throw = eh_region_may_contain_throw (this_tf.region); |
| if (this_tf.may_throw) |
| honor_protect_cleanup_actions (state, &this_state, &this_tf); |
| |
| /* Determine how many edges (still) reach the finally block. Or rather, |
| how many destinations are reached by the finally block. Use this to |
| determine how we process the finally block itself. */ |
| |
| ndests = this_tf.dest_array.length (); |
| ndests += this_tf.may_fallthru; |
| ndests += this_tf.may_return; |
| ndests += this_tf.may_throw; |
| |
| /* If the FINALLY block is not reachable, dike it out. */ |
| if (ndests == 0) |
| { |
| gimple_seq_add_seq (&this_tf.top_p_seq, gimple_try_eval (tp)); |
| gimple_try_set_cleanup (tp, NULL); |
| } |
| /* If the finally block doesn't fall through, then any destination |
| we might try to impose there isn't reached either. There may be |
| some minor amount of cleanup and redirection still needed. */ |
| else if (!gimple_seq_may_fallthru (gimple_try_cleanup (tp))) |
| lower_try_finally_nofallthru (state, &this_tf); |
| |
| /* We can easily special-case redirection to a single destination. */ |
| else if (ndests == 1) |
| lower_try_finally_onedest (state, &this_tf); |
| else if (decide_copy_try_finally (ndests, this_tf.may_throw, |
| gimple_try_cleanup (tp))) |
| lower_try_finally_copy (state, &this_tf); |
| else |
| lower_try_finally_switch (state, &this_tf); |
| |
| /* If someone requested we add a label at the end of the transformed |
| block, do so. */ |
| if (this_tf.fallthru_label) |
| { |
| /* This must be reached only if ndests == 0. */ |
| gimple *x = gimple_build_label (this_tf.fallthru_label); |
| gimple_seq_add_stmt (&this_tf.top_p_seq, x); |
| } |
| |
| this_tf.dest_array.release (); |
| free (this_tf.goto_queue); |
| if (this_tf.goto_queue_map) |
| delete this_tf.goto_queue_map; |
| |
| /* If there was an old (aka outer) eh_seq, append the current eh_seq. |
| If there was no old eh_seq, then the append is trivially already done. */ |
| if (old_eh_seq) |
| { |
| if (eh_seq == NULL) |
| eh_seq = old_eh_seq; |
| else |
| { |
| gimple_seq new_eh_seq = eh_seq; |
| eh_seq = old_eh_seq; |
| gimple_seq_add_seq (&eh_seq, new_eh_seq); |
| } |
| } |
| |
| return this_tf.top_p_seq; |
| } |
| |
| /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_CATCH with a |
| list of GIMPLE_CATCH to a sequence of labels and blocks, plus the |
| exception region trees that records all the magic. */ |
| |
| static gimple_seq |
| lower_catch (struct leh_state *state, gtry *tp) |
| { |
| eh_region try_region = NULL; |
| struct leh_state this_state = *state; |
| gimple_stmt_iterator gsi; |
| tree out_label; |
| gimple_seq new_seq, cleanup; |
| gimple *x; |
| geh_dispatch *eh_dispatch; |
| location_t try_catch_loc = gimple_location (tp); |
| location_t catch_loc = UNKNOWN_LOCATION; |
| |
| if (flag_exceptions) |
| { |
| try_region = gen_eh_region_try (state->cur_region); |
| this_state.cur_region = try_region; |
| this_state.outer_non_cleanup = this_state.cur_region; |
| } |
| |
| lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
| |
| if (!eh_region_may_contain_throw (try_region)) |
| return gimple_try_eval (tp); |
| |
| new_seq = NULL; |
| eh_dispatch = gimple_build_eh_dispatch (try_region->index); |
| gimple_seq_add_stmt (&new_seq, eh_dispatch); |
| emit_resx (&new_seq, try_region); |
| |
| this_state.cur_region = state->cur_region; |
| this_state.outer_non_cleanup = state->outer_non_cleanup; |
| this_state.ehp_region = try_region; |
| |
| /* Add eh_seq from lowering EH in the cleanup sequence after the cleanup |
| itself, so that e.g. for coverage purposes the nested cleanups don't |
| appear before the cleanup body. See PR64634 for details. */ |
| gimple_seq old_eh_seq = eh_seq; |
| eh_seq = NULL; |
| |
| out_label = NULL; |
| cleanup = gimple_try_cleanup (tp); |
| for (gsi = gsi_start (cleanup); |
| !gsi_end_p (gsi); |
| gsi_next (&gsi)) |
| { |
| eh_catch c; |
| gcatch *catch_stmt; |
| gimple_seq handler; |
| |
| catch_stmt = as_a <gcatch *> (gsi_stmt (gsi)); |
| if (catch_loc == UNKNOWN_LOCATION) |
| catch_loc = gimple_location (catch_stmt); |
| c = gen_eh_region_catch (try_region, gimple_catch_types (catch_stmt)); |
| |
| handler = gimple_catch_handler (catch_stmt); |
| lower_eh_constructs_1 (&this_state, &handler); |
| |
| c->label = create_artificial_label (UNKNOWN_LOCATION); |
| x = gimple_build_label (c->label); |
| gimple_seq_add_stmt (&new_seq, x); |
| |
| gimple_seq_add_seq (&new_seq, handler); |
| |
| if (gimple_seq_may_fallthru (new_seq)) |
| { |
| if (!out_label) |
| out_label = create_artificial_label (try_catch_loc); |
| |
| x = gimple_build_goto (out_label); |
| gimple_seq_add_stmt (&new_seq, x); |
| } |
| if (!c->type_list) |
| break; |
| } |
| |
| /* Try to set a location on the dispatching construct to avoid inheriting |
| the location of the previous statement. */ |
| gimple_set_location (eh_dispatch, catch_loc); |
| |
| gimple_try_set_cleanup (tp, new_seq); |
| |
| gimple_seq new_eh_seq = eh_seq; |
| eh_seq = old_eh_seq; |
| gimple_seq ret_seq = frob_into_branch_around (tp, try_region, out_label); |
| gimple_seq_add_seq (&eh_seq, new_eh_seq); |
| return ret_seq; |
| } |
| |
| /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a |
| GIMPLE_EH_FILTER to a sequence of labels and blocks, plus the exception |
| region trees that record all the magic. */ |
| |
| static gimple_seq |
| lower_eh_filter (struct leh_state *state, gtry *tp) |
| { |
| struct leh_state this_state = *state; |
| eh_region this_region = NULL; |
| gimple *inner, *x; |
| gimple_seq new_seq; |
| |
| inner = gimple_seq_first_stmt (gimple_try_cleanup (tp)); |
| |
| if (flag_exceptions) |
| { |
| this_region = gen_eh_region_allowed (state->cur_region, |
| gimple_eh_filter_types (inner)); |
| this_state.cur_region = this_region; |
| this_state.outer_non_cleanup = this_state.cur_region; |
| } |
| |
| lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
| |
| if (!eh_region_may_contain_throw (this_region)) |
| return gimple_try_eval (tp); |
| |
| this_state.cur_region = state->cur_region; |
| this_state.ehp_region = this_region; |
| |
| new_seq = NULL; |
| x = gimple_build_eh_dispatch (this_region->index); |
| gimple_set_location (x, gimple_location (tp)); |
| gimple_seq_add_stmt (&new_seq, x); |
| emit_resx (&new_seq, this_region); |
| |
| this_region->u.allowed.label = create_artificial_label (UNKNOWN_LOCATION); |
| x = gimple_build_label (this_region->u.allowed.label); |
| gimple_seq_add_stmt (&new_seq, x); |
| |
| lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure_ptr (inner)); |
| gimple_seq_add_seq (&new_seq, gimple_eh_filter_failure (inner)); |
| |
| gimple_try_set_cleanup (tp, new_seq); |
| |
| return frob_into_branch_around (tp, this_region, NULL); |
| } |
| |
| /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with |
| an GIMPLE_EH_MUST_NOT_THROW to a sequence of labels and blocks, |
| plus the exception region trees that record all the magic. */ |
| |
| static gimple_seq |
| lower_eh_must_not_throw (struct leh_state *state, gtry *tp) |
| { |
| struct leh_state this_state = *state; |
| |
| if (flag_exceptions) |
| { |
| gimple *inner = gimple_seq_first_stmt (gimple_try_cleanup (tp)); |
| eh_region this_region; |
| |
| this_region = gen_eh_region_must_not_throw (state->cur_region); |
| this_region->u.must_not_throw.failure_decl |
| = gimple_eh_must_not_throw_fndecl ( |
| as_a <geh_mnt *> (inner)); |
| this_region->u.must_not_throw.failure_loc |
| = LOCATION_LOCUS (gimple_location (tp)); |
| |
| /* In order to get mangling applied to this decl, we must mark it |
| used now. Otherwise, pass_ipa_free_lang_data won't think it |
| needs to happen. */ |
| TREE_USED (this_region->u.must_not_throw.failure_decl) = 1; |
| |
| this_state.cur_region = this_region; |
| this_state.outer_non_cleanup = this_state.cur_region; |
| } |
| |
| lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
| |
| return gimple_try_eval (tp); |
| } |
| |
| /* Implement a cleanup expression. This is similar to try-finally, |
| except that we only execute the cleanup block for exception edges. */ |
| |
| static gimple_seq |
| lower_cleanup (struct leh_state *state, gtry *tp) |
| { |
| struct leh_state this_state = *state; |
| eh_region this_region = NULL; |
| struct leh_tf_state fake_tf; |
| gimple_seq result; |
| bool cleanup_dead = cleanup_is_dead_in (state); |
| |
| if (flag_exceptions && !cleanup_dead) |
| { |
| this_region = gen_eh_region_cleanup (state->cur_region); |
| this_state.cur_region = this_region; |
| this_state.outer_non_cleanup = state->outer_non_cleanup; |
| } |
| |
| lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
| |
| if (cleanup_dead || !eh_region_may_contain_throw (this_region)) |
| return gimple_try_eval (tp); |
| |
| /* Build enough of a try-finally state so that we can reuse |
| honor_protect_cleanup_actions. */ |
| memset (&fake_tf, 0, sizeof (fake_tf)); |
| fake_tf.top_p = fake_tf.try_finally_expr = tp; |
| fake_tf.outer = state; |
| fake_tf.region = this_region; |
| fake_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp)); |
| fake_tf.may_throw = true; |
| |
| honor_protect_cleanup_actions (state, NULL, &fake_tf); |
| |
| if (fake_tf.may_throw) |
| { |
| /* In this case honor_protect_cleanup_actions had nothing to do, |
| and we should process this normally. */ |
| lower_eh_constructs_1 (state, gimple_try_cleanup_ptr (tp)); |
| result = frob_into_branch_around (tp, this_region, |
| fake_tf.fallthru_label); |
| } |
| else |
| { |
| /* In this case honor_protect_cleanup_actions did nearly all of |
| the work. All we have left is to append the fallthru_label. */ |
| |
| result = gimple_try_eval (tp); |
| if (fake_tf.fallthru_label) |
| { |
| gimple *x = gimple_build_label (fake_tf.fallthru_label); |
| gimple_seq_add_stmt (&result, x); |
| } |
| } |
| return result; |
| } |
| |
| /* Main loop for lowering eh constructs. Also moves gsi to the next |
| statement. */ |
| |
| static void |
| lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi) |
| { |
| gimple_seq replace; |
| gimple *x; |
| gimple *stmt = gsi_stmt (*gsi); |
| |
| switch (gimple_code (stmt)) |
| { |
| case GIMPLE_CALL: |
| { |
| tree fndecl = gimple_call_fndecl (stmt); |
| tree rhs, lhs; |
| |
| if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)) |
| switch (DECL_FUNCTION_CODE (fndecl)) |
| { |
| case BUILT_IN_EH_POINTER: |
| /* The front end may have generated a call to |
| __builtin_eh_pointer (0) within a catch region. Replace |
| this zero argument with the current catch region number. */ |
| if (state->ehp_region) |
| { |
| tree nr = build_int_cst (integer_type_node, |
| state->ehp_region->index); |
| gimple_call_set_arg (stmt, 0, nr); |
| } |
| else |
| { |
| /* The user has dome something silly. Remove it. */ |
| rhs = null_pointer_node; |
| goto do_replace; |
| } |
| break; |
| |
| case BUILT_IN_EH_FILTER: |
| /* ??? This should never appear, but since it's a builtin it |
| is accessible to abuse by users. Just remove it and |
| replace the use with the arbitrary value zero. */ |
| rhs = build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0); |
| do_replace: |
| lhs = gimple_call_lhs (stmt); |
| x = gimple_build_assign (lhs, rhs); |
| gsi_insert_before (gsi, x, GSI_SAME_STMT); |
| /* FALLTHRU */ |
| |
| case BUILT_IN_EH_COPY_VALUES: |
| /* Likewise this should not appear. Remove it. */ |
| gsi_remove (gsi, true); |
| return; |
| |
| default: |
| break; |
| } |
| } |
| /* FALLTHRU */ |
| |
| case GIMPLE_ASSIGN: |
| /* If the stmt can throw, use a new temporary for the assignment |
| to a LHS. This makes sure the old value of the LHS is |
| available on the EH edge. Only do so for statements that |
| potentially fall through (no noreturn calls e.g.), otherwise |
| this new assignment might create fake fallthru regions. */ |
| if (stmt_could_throw_p (cfun, stmt) |
| && gimple_has_lhs (stmt) |
| && gimple_stmt_may_fallthru (stmt) |
| && !tree_could_throw_p (gimple_get_lhs (stmt)) |
| && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt)))) |
| { |
| tree lhs = gimple_get_lhs (stmt); |
| tree tmp = create_tmp_var (TREE_TYPE (lhs)); |
| gimple *s = gimple_build_assign (lhs, tmp); |
| gimple_set_location (s, gimple_location (stmt)); |
| gimple_set_block (s, gimple_block (stmt)); |
| gimple_set_lhs (stmt, tmp); |
| gsi_insert_after (gsi, s, GSI_SAME_STMT); |
| } |
| /* Look for things that can throw exceptions, and record them. */ |
| if (state->cur_region && stmt_could_throw_p (cfun, stmt)) |
| { |
| record_stmt_eh_region (state->cur_region, stmt); |
| note_eh_region_may_contain_throw (state->cur_region); |
| } |
| break; |
| |
| case GIMPLE_COND: |
| case GIMPLE_GOTO: |
| case GIMPLE_RETURN: |
| maybe_record_in_goto_queue (state, stmt); |
| break; |
| |
| case GIMPLE_SWITCH: |
| verify_norecord_switch_expr (state, as_a <gswitch *> (stmt)); |
| break; |
| |
| case GIMPLE_TRY: |
| { |
| gtry *try_stmt = as_a <gtry *> (stmt); |
| if (gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY) |
| replace = lower_try_finally (state, try_stmt); |
| else |
| { |
| x = gimple_seq_first_stmt (gimple_try_cleanup (try_stmt)); |
| if (!x) |
| { |
| replace = gimple_try_eval (try_stmt); |
| lower_eh_constructs_1 (state, &replace); |
| } |
| else |
| switch (gimple_code (x)) |
| { |
| case GIMPLE_CATCH: |
| replace = lower_catch (state, try_stmt); |
| break; |
| case GIMPLE_EH_FILTER: |
| replace = lower_eh_filter (state, try_stmt); |
| break; |
| case GIMPLE_EH_MUST_NOT_THROW: |
| replace = lower_eh_must_not_throw (state, try_stmt); |
| break; |
| case GIMPLE_EH_ELSE: |
| /* This code is only valid with GIMPLE_TRY_FINALLY. */ |
| gcc_unreachable (); |
| default: |
| replace = lower_cleanup (state, try_stmt); |
| break; |
| } |
| } |
| } |
| |
| /* Remove the old stmt and insert the transformed sequence |
| instead. */ |
| gsi_insert_seq_before (gsi, replace, GSI_SAME_STMT); |
| gsi_remove (gsi, true); |
| |
| /* Return since we don't want gsi_next () */ |
| return; |
| |
| case GIMPLE_EH_ELSE: |
| /* We should be eliminating this in lower_try_finally et al. */ |
| gcc_unreachable (); |
| |
| default: |
| /* A type, a decl, or some kind of statement that we're not |
| interested in. Don't walk them. */ |
| break; |
| } |
| |
| gsi_next (gsi); |
| } |
| |
| /* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */ |
| |
| static void |
| lower_eh_constructs_1 (struct leh_state *state, gimple_seq *pseq) |
| { |
| gimple_stmt_iterator gsi; |
| for (gsi = gsi_start (*pseq); !gsi_end_p (gsi);) |
| lower_eh_constructs_2 (state, &gsi); |
| } |
| |
| namespace { |
| |
| const pass_data pass_data_lower_eh = |
| { |
| GIMPLE_PASS, /* type */ |
| "eh", /* name */ |
| OPTGROUP_NONE, /* optinfo_flags */ |
| TV_TREE_EH, /* tv_id */ |
| PROP_gimple_lcf, /* properties_required */ |
| PROP_gimple_leh, /* properties_provided */ |
| 0, /* properties_destroyed */ |
| 0, /* todo_flags_start */ |
| 0, /* todo_flags_finish */ |
| }; |
| |
| class pass_lower_eh : public gimple_opt_pass |
| { |
| public: |
| pass_lower_eh (gcc::context *ctxt) |
| : gimple_opt_pass (pass_data_lower_eh, ctxt) |
| {} |
| |
| /* opt_pass methods: */ |
| virtual unsigned int execute (function *); |
| |
| }; // class pass_lower_eh |
| |
| unsigned int |
| pass_lower_eh::execute (function *fun) |
| { |
| struct leh_state null_state; |
| gimple_seq bodyp; |
| |
| bodyp = gimple_body (current_function_decl); |
| if (bodyp == NULL) |
| return 0; |
| |
| finally_tree = new hash_table<finally_tree_hasher> (31); |
| eh_region_may_contain_throw_map = BITMAP_ALLOC (NULL); |
| memset (&null_state, 0, sizeof (null_state)); |
| |
| collect_finally_tree_1 (bodyp, NULL); |
| lower_eh_constructs_1 (&null_state, &bodyp); |
| gimple_set_body (current_function_decl, bodyp); |
| |
| /* We assume there's a return statement, or something, at the end of |
| the function, and thus ploping the EH sequence afterward won't |
| change anything. */ |
| gcc_assert (!gimple_seq_may_fallthru (bodyp)); |
| gimple_seq_add_seq (&bodyp, eh_seq); |
| |
| /* We assume that since BODYP already existed, adding EH_SEQ to it |
| didn't change its value, and we don't have to re-set the function. */ |
| gcc_assert (bodyp == gimple_body (current_function_decl)); |
| |
| delete finally_tree; |
| finally_tree = NULL; |
| BITMAP_FREE (eh_region_may_contain_throw_map); |
| eh_seq = NULL; |
| |
| /* If this function needs a language specific EH personality routine |
| and the frontend didn't already set one do so now. */ |
| if (function_needs_eh_personality (fun) == eh_personality_lang |
| && !DECL_FUNCTION_PERSONALITY (current_function_decl)) |
| DECL_FUNCTION_PERSONALITY (current_function_decl) |
| = lang_hooks.eh_personality (); |
| |
| return 0; |
| } |
| |
| } // anon namespace |
| |
| gimple_opt_pass * |
| make_pass_lower_eh (gcc::context *ctxt) |
| { |
| return new pass_lower_eh (ctxt); |
| } |
| |
| /* Create the multiple edges from an EH_DISPATCH statement to all of |
| the possible handlers for its EH region. Return true if there's |
| no fallthru edge; false if there is. */ |
| |
| bool |
| make_eh_dispatch_edges (geh_dispatch *stmt) |
| { |
| eh_region r; |
| eh_catch c; |
| basic_block src, dst; |
| |
| r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); |
| src = gimple_bb (stmt); |
| |
| switch (r->type) |
| { |
| case ERT_TRY: |
| for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) |
| { |
| dst = label_to_block (cfun, c->label); |
| make_edge (src, dst, 0); |
| |
| /* A catch-all handler doesn't have a fallthru. */ |
| if (c->type_list == NULL) |
| return false; |
| } |
| break; |
| |
| case ERT_ALLOWED_EXCEPTIONS: |
| dst = label_to_block (cfun, r->u.allowed.label); |
| make_edge (src, dst, 0); |
| break; |
| |
| default: |
| gcc_unreachable (); |
| } |
| |
| return true; |
| } |
| |
| /* Create the single EH edge from STMT to its nearest landing pad, |
| if there is such a landing pad within the current function. */ |
| |
| void |
| make_eh_edges (gimple *stmt) |
| { |
| basic_block src, dst; |
| eh_landing_pad lp; |
| int lp_nr; |
| |
| lp_nr = lookup_stmt_eh_lp (stmt); |
| if (lp_nr <= 0) |
| return; |
| |
| lp = get_eh_landing_pad_from_number (lp_nr); |
| gcc_assert (lp != NULL); |
| |
| src = gimple_bb (stmt); |
| dst = label_to_block (cfun, lp->post_landing_pad); |
| make_edge (src, dst, EDGE_EH); |
| } |
| |
| /* Do the work in redirecting EDGE_IN to NEW_BB within the EH region tree; |
| do not actually perform the final edge redirection. |
| |
| CHANGE_REGION is true when we're being called from cleanup_empty_eh and |
| we intend to change the destination EH region as well; this means |
| EH_LANDING_PAD_NR must already be set on the destination block label. |
| If false, we're being called from generic cfg manipulation code and we |
| should preserve our place within the region tree. */ |
| |
| static void |
| redirect_eh_edge_1 (edge edge_in, basic_block new_bb, bool change_region) |
| { |
| eh_landing_pad old_lp, new_lp; |
| basic_block old_bb; |
| gimple *throw_stmt; |
| int old_lp_nr, new_lp_nr; |
| tree old_label, new_label; |
| edge_iterator ei; |
| edge e; |
| |
| old_bb = edge_in->dest; |
| old_label = gimple_block_label (old_bb); |
| old_lp_nr = EH_LANDING_PAD_NR (old_label); |
| gcc_assert (old_lp_nr > 0); |
| old_lp = get_eh_landing_pad_from_number (old_lp_nr); |
| |
| throw_stmt = last_stmt (edge_in->src); |
| gcc_checking_assert (lookup_stmt_eh_lp (throw_stmt) == old_lp_nr); |
| |
| new_label = gimple_block_label (new_bb); |
| |
| /* Look for an existing region that might be using NEW_BB already. */ |
| new_lp_nr = EH_LANDING_PAD_NR (new_label); |
| if (new_lp_nr) |
| { |
| new_lp = get_eh_landing_pad_from_number (new_lp_nr); |
| gcc_assert (new_lp); |
| |
| /* Unless CHANGE_REGION is true, the new and old landing pad |
| had better be associated with the same EH region. */ |
| gcc_assert (change_region || new_lp->region == old_lp->region); |
| } |
| else |
| { |
| new_lp = NULL; |
| gcc_assert (!change_region); |
| } |
| |
| /* Notice when we redirect the last EH edge away from OLD_BB. */ |
| FOR_EACH_EDGE (e, ei, old_bb->preds) |
| if (e != edge_in && (e->flags & EDGE_EH)) |
| break; |
| |
| if (new_lp) |
| { |
| /* NEW_LP already exists. If there are still edges into OLD_LP, |
| there's nothing to do with the EH tree. If there are no more |
| edges into OLD_LP, then we want to remove OLD_LP as it is unused. |
| If CHANGE_REGION is true, then our caller is expecting to remove |
| the landing pad. */ |
| if (e == NULL && !change_region) |
| remove_eh_landing_pad (old_lp); |
| } |
| else |
| { |
| /* No correct landing pad exists. If there are no more edges |
| into OLD_LP, then we can simply re-use the existing landing pad. |
| Otherwise, we have to create a new landing pad. */ |
| if (e == NULL) |
| { |
| EH_LANDING_PAD_NR (old_lp->post_landing_pad) = 0; |
| new_lp = old_lp; |
| } |
| else |
| new_lp = gen_eh_landing_pad (old_lp->region); |
| new_lp->post_landing_pad = new_label; |
| EH_LANDING_PAD_NR (new_label) = new_lp->index; |
| } |
| |
| /* Maybe move the throwing statement to the new region. */ |
| if (old_lp != new_lp) |
| { |
| remove_stmt_from_eh_lp (throw_stmt); |
| add_stmt_to_eh_lp (throw_stmt, new_lp->index); |
| } |
| } |
| |
| /* Redirect EH edge E to NEW_BB. */ |
| |
| edge |
| redirect_eh_edge (edge edge_in, basic_block new_bb) |
| { |
| redirect_eh_edge_1 (edge_in, new_bb, false); |
| return ssa_redirect_edge (edge_in, new_bb); |
| } |
| |
| /* This is a subroutine of gimple_redirect_edge_and_branch. Update the |
| labels for redirecting a non-fallthru EH_DISPATCH edge E to NEW_BB. |
| The actual edge update will happen in the caller. */ |
| |
| void |
| redirect_eh_dispatch_edge (geh_dispatch *stmt, edge e, basic_block new_bb) |
| { |
| tree new_lab = gimple_block_label (new_bb); |
| bool any_changed = false; |
| basic_block old_bb; |
| eh_region r; |
| eh_catch c; |
| |
| r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); |
| switch (r->type) |
| { |
| case ERT_TRY: |
| for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) |
| { |
| old_bb = label_to_block (cfun, c->label); |
| if (old_bb == e->dest) |
| { |
| c->label = new_lab; |
| any_changed = true; |
| } |
| } |
| break; |
| |
| case ERT_ALLOWED_EXCEPTIONS: |
| old_bb = label_to_block (cfun, r->u.allowed.label); |
| gcc_assert (old_bb == e->dest); |
| r->u.allowed.label = new_lab; |
| any_changed = true; |
| break; |
| |
| default: |
| gcc_unreachable (); |
| } |
| |
| gcc_assert (any_changed); |
| } |
| |
| /* Helper function for operation_could_trap_p and stmt_could_throw_p. */ |
| |
| bool |
| operation_could_trap_helper_p (enum tree_code op, |
| bool fp_operation, |
| bool honor_trapv, |
| bool honor_nans, |
| bool honor_snans, |
| tree divisor, |
| bool *handled) |
| { |
| *handled = true; |
| switch (op) |
| { |
| case TRUNC_DIV_EXPR: |
| case CEIL_DIV_EXPR: |
| case FLOOR_DIV_EXPR: |
| case ROUND_DIV_EXPR: |
| case EXACT_DIV_EXPR: |
| case CEIL_MOD_EXPR: |
| case FLOOR_MOD_EXPR: |
| case ROUND_MOD_EXPR: |
| case TRUNC_MOD_EXPR: |
| case RDIV_EXPR: |
| if (honor_snans) |
| return true; |
| if (fp_operation) |
| return flag_trapping_math; |
| if (!TREE_CONSTANT (divisor) || integer_zerop (divisor)) |
| return true; |
| return false; |
| |
| case LT_EXPR: |
| case LE_EXPR: |
| case GT_EXPR: |
| case GE_EXPR: |
| case LTGT_EXPR: |
| /* Some floating point comparisons may trap. */ |
| return honor_nans; |
| |
| case EQ_EXPR: |
| case NE_EXPR: |
| case UNORDERED_EXPR: |
| case ORDERED_EXPR: |
| case UNLT_EXPR: |
| case UNLE_EXPR: |
| case UNGT_EXPR: |
| case UNGE_EXPR: |
| case UNEQ_EXPR: |
| return honor_snans; |
| |
| case NEGATE_EXPR: |
| case ABS_EXPR: |
| case CONJ_EXPR: |
| /* These operations don't trap with floating point. */ |
| if (honor_trapv) |
| return true; |
| return false; |
| |
| case ABSU_EXPR: |
| /* ABSU_EXPR never traps. */ |
| return false; |
| |
| case PLUS_EXPR: |
| case MINUS_EXPR: |
| case MULT_EXPR: |
| /* Any floating arithmetic may trap. */ |
| if (fp_operation && flag_trapping_math) |
| return true; |
| if (honor_trapv) |
| return true; |
| return false; |
| |
| case COMPLEX_EXPR: |
| case CONSTRUCTOR: |
| /* Constructing an object cannot trap. */ |
| return false; |
| |
| case COND_EXPR: |
| case VEC_COND_EXPR: |
| /* Whether *COND_EXPR can trap depends on whether the |
| first argument can trap, so signal it as not handled. |
| Whether lhs is floating or not doesn't matter. */ |
| *handled = false; |
| return false; |
| |
| default: |
| /* Any floating arithmetic may trap. */ |
| if (fp_operation && flag_trapping_math) |
| return true; |
| |
| *handled = false; |
| return false; |
| } |
| } |
| |
| /* Return true if operation OP may trap. FP_OPERATION is true if OP is applied |
| on floating-point values. HONOR_TRAPV is true if OP is applied on integer |
| type operands that may trap. If OP is a division operator, DIVISOR contains |
| the value of the divisor. */ |
| |
| bool |
| operation_could_trap_p (enum tree_code op, bool fp_operation, bool honor_trapv, |
| tree divisor) |
| { |
| bool honor_nans = (fp_operation && flag_trapping_math |
| && !flag_finite_math_only); |
| bool honor_snans = fp_operation && flag_signaling_nans != 0; |
| bool handled; |
| |
| /* This function cannot tell whether or not COND_EXPR could trap, |
| because that depends on its condition op. */ |
| gcc_assert (op != COND_EXPR); |
| |
| if (TREE_CODE_CLASS (op) != tcc_comparison |
| && TREE_CODE_CLASS (op) != tcc_unary |
| && TREE_CODE_CLASS (op) != tcc_binary) |
| return false; |
| |
| return operation_could_trap_helper_p (op, fp_operation, honor_trapv, |
| honor_nans, honor_snans, divisor, |
| &handled); |
| } |
| |
| |
| /* Returns true if it is possible to prove that the index of |
| an array access REF (an ARRAY_REF expression) falls into the |
| array bounds. */ |
| |
| static bool |
| in_array_bounds_p (tree ref) |
| { |
| tree idx = TREE_OPERAND (ref, 1); |
| tree min, max; |
| |
| if (TREE_CODE (idx) != INTEGER_CST) |
| return false; |
| |
| min = array_ref_low_bound (ref); |
| max = array_ref_up_bound (ref); |
| if (!min |
| || !max |
| || TREE_CODE (min) != INTEGER_CST |
| || TREE_CODE (max) != INTEGER_CST) |
| return false; |
| |
| if (tree_int_cst_lt (idx, min) |
| || tree_int_cst_lt (max, idx)) |
| return false; |
| |
| return true; |
| } |
| |
| /* Returns true if it is possible to prove that the range of |
| an array access REF (an ARRAY_RANGE_REF expression) falls |
| into the array bounds. */ |
| |
| static bool |
| range_in_array_bounds_p (tree ref) |
| { |
| tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref)); |
| tree range_min, range_max, min, max; |
| |
| range_min = TYPE_MIN_VALUE (domain_type); |
| range_max = TYPE_MAX_VALUE (domain_type); |
| if (!range_min |
| || !range_max |
| || TREE_CODE (range_min) != INTEGER_CST |
| || TREE_CODE (range_max) != INTEGER_CST) |
| return false; |
| |
| min = array_ref_low_bound (ref); |
| max = array_ref_up_bound (ref); |
| if (!min |
| || !max |
| || TREE_CODE (min) != INTEGER_CST |
| || TREE_CODE (max) != INTEGER_CST) |
| return false; |
| |
| if (tree_int_cst_lt (range_min, min) |
| || tree_int_cst_lt (max, range_max)) |
| return false; |
| |
| return true; |
| } |
| |
| /* Return true if EXPR can trap, as in dereferencing an invalid pointer |
| location or floating point arithmetic. C.f. the rtl version, may_trap_p. |
| This routine expects only GIMPLE lhs or rhs input. */ |
| |
| bool |
| tree_could_trap_p (tree expr) |
| { |
| enum tree_code code; |
| bool fp_operation = false; |
| bool honor_trapv = false; |
| tree t, base, div = NULL_TREE; |
| |
| if (!expr) |
| return false; |
| |
| /* In COND_EXPR and VEC_COND_EXPR only the condition may trap, but |
| they won't appear as operands in GIMPLE form, so this is just for the |
| GENERIC uses where it needs to recurse on the operands and so |
| *COND_EXPR itself doesn't trap. */ |
| if (TREE_CODE (expr) == COND_EXPR || TREE_CODE (expr) == VEC_COND_EXPR) |
| return false; |
| |
| code = TREE_CODE (expr); |
| t = TREE_TYPE (expr); |
| |
| if (t) |
| { |
| if (COMPARISON_CLASS_P (expr)) |
| fp_operation = FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))); |
| else |
| fp_operation = FLOAT_TYPE_P (t); |
| honor_trapv = INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t); |
| } |
| |
| if (TREE_CODE_CLASS (code) == tcc_binary) |
| div = TREE_OPERAND (expr, 1); |
| if (operation_could_trap_p (code, fp_operation, honor_trapv, div)) |
| return true; |
| |
| restart: |
| switch (code) |
| { |
| case COMPONENT_REF: |
| case REALPART_EXPR: |
| case IMAGPART_EXPR: |
| case BIT_FIELD_REF: |
| case VIEW_CONVERT_EXPR: |
| case WITH_SIZE_EXPR: |
| expr = TREE_OPERAND (expr, 0); |
| code = TREE_CODE (expr); |
| goto restart; |
| |
| case ARRAY_RANGE_REF: |
| base = TREE_OPERAND (expr, 0); |
| if (tree_could_trap_p (base)) |
| return true; |
| if (TREE_THIS_NOTRAP (expr)) |
| return false; |
| return !range_in_array_bounds_p (expr); |
| |
| case ARRAY_REF: |
| base = TREE_OPERAND (expr, 0); |
| if (tree_could_trap_p (base)) |
| return true; |
| if (TREE_THIS_NOTRAP (expr)) |
| return false; |
| return !in_array_bounds_p (expr); |
| |
| case TARGET_MEM_REF: |
| case MEM_REF: |
| if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR |
| && tree_could_trap_p (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))) |
| return true; |
| if (TREE_THIS_NOTRAP (expr)) |
| return false; |
| /* We cannot prove that the access is in-bounds when we have |
| variable-index TARGET_MEM_REFs. */ |
| if (code == TARGET_MEM_REF |
| && (TMR_INDEX (expr) || TMR_INDEX2 (expr))) |
| return true; |
| if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR) |
| { |
| tree base = TREE_OPERAND (TREE_OPERAND (expr, 0), 0); |
| poly_offset_int off = mem_ref_offset (expr); |
| if (maybe_lt (off, 0)) |
| return true; |
| if (TREE_CODE (base) == STRING_CST) |
| return maybe_le (TREE_STRING_LENGTH (base), off); |
| tree size = DECL_SIZE_UNIT (base); |
| if (size == NULL_TREE |
| || !poly_int_tree_p (size) |
| || maybe_le (wi::to_poly_offset (size), off)) |
| return true; |
| /* Now we are sure the first byte of the access is inside |
| the object. */ |
| return false; |
| } |
| return true; |
| |
| case INDIRECT_REF: |
| return !TREE_THIS_NOTRAP (expr); |
| |
| case ASM_EXPR: |
| return TREE_THIS_VOLATILE (expr); |
| |
| case CALL_EXPR: |
| /* Internal function calls do not trap. */ |
| if (CALL_EXPR_FN (expr) == NULL_TREE) |
| return false; |
| t = get_callee_fndecl (expr); |
| /* Assume that indirect and calls to weak functions may trap. */ |
| if (!t || !DECL_P (t)) |
| return true; |
| if (DECL_WEAK (t)) |
| return tree_could_trap_p (t); |
| return false; |
| |
| case FUNCTION_DECL: |
| /* Assume that accesses to weak functions may trap, unless we know |
| they are certainly defined in current TU or in some other |
| LTO partition. */ |
| if (DECL_WEAK (expr) && !DECL_COMDAT (expr) && DECL_EXTERNAL (expr)) |
| { |
| cgraph_node *node = cgraph_node::get (expr); |
| if (node) |
| node = node->function_symbol (); |
| return !(node && node->in_other_partition); |
| } |
| return false; |
| |
| case VAR_DECL: |
| /* Assume that accesses to weak vars may trap, unless we know |
| they are certainly defined in current TU or in some other |
| LTO partition. */ |
| if (DECL_WEAK (expr) && !DECL_COMDAT (expr) && DECL_EXTERNAL (expr)) |
| { |
| varpool_node *node = varpool_node::get (expr); |
| if (node) |
| node = node->ultimate_alias_target (); |
| return !(node && node->in_other_partition); |
| } |
| return false; |
| |
| default: |
| return false; |
| } |
| } |
| |
| /* Return non-NULL if there is an integer operation with trapping overflow |
| we can rewrite into non-trapping. Called via walk_tree from |
| rewrite_to_non_trapping_overflow. */ |
| |
| static tree |
| find_trapping_overflow (tree *tp, int *walk_subtrees, void *data) |
| { |
| if (EXPR_P (*tp) |
| && ANY_INTEGRAL_TYPE_P (TREE_TYPE (*tp)) |
| && !operation_no_trapping_overflow (TREE_TYPE (*tp), TREE_CODE (*tp))) |
| return *tp; |
| if (IS_TYPE_OR_DECL_P (*tp) |
| || (TREE_CODE (*tp) == SAVE_EXPR && data == NULL)) |
| *walk_subtrees = 0; |
| return NULL_TREE; |
| } |
| |
| /* Rewrite selected operations into unsigned arithmetics, so that they |
| don't trap on overflow. */ |
| |
| static tree |
| replace_trapping_overflow (tree *tp, int *walk_subtrees, void *data) |
| { |
| if (find_trapping_overflow (tp, walk_subtrees, data)) |
| { |
| tree type = TREE_TYPE (*tp); |
| tree utype = unsigned_type_for (type); |
| *walk_subtrees = 0; |
| int len = TREE_OPERAND_LENGTH (*tp); |
| for (int i = 0; i < len; ++i) |
| walk_tree (&TREE_OPERAND (*tp, i), replace_trapping_overflow, |
| data, (hash_set<tree> *) data); |
| |
| if (TREE_CODE (*tp) == ABS_EXPR) |
| { |
| TREE_SET_CODE (*tp, ABSU_EXPR); |
| TREE_TYPE (*tp) = utype; |
| *tp = fold_convert (type, *tp); |
| } |
| else |
| { |
| TREE_TYPE (*tp) = utype; |
| len = TREE_OPERAND_LENGTH (*tp); |
| for (int i = 0; i < len; ++i) |
| TREE_OPERAND (*tp, i) |
| = fold_convert (utype, TREE_OPERAND (*tp, i)); |
| *tp = fold_convert (type, *tp); |
| } |
| } |
| return NULL_TREE; |
| } |
| |
| /* If any subexpression of EXPR can trap due to -ftrapv, rewrite it |
| using unsigned arithmetics to avoid traps in it. */ |
| |
| tree |
| rewrite_to_non_trapping_overflow (tree expr) |
| { |
| if (!flag_trapv) |
| return expr; |
| hash_set<tree> pset; |
| if (!walk_tree (&expr, find_trapping_overflow, &pset, &pset)) |
| return expr; |
| expr = unshare_expr (expr); |
| pset.empty (); |
| walk_tree (&expr, replace_trapping_overflow, &pset, &pset); |
| return expr; |
| } |
| |
| /* Helper for stmt_could_throw_p. Return true if STMT (assumed to be a |
| an assignment or a conditional) may throw. */ |
| |
| static bool |
| stmt_could_throw_1_p (gassign *stmt) |
| { |
| enum tree_code code = gimple_assign_rhs_code (stmt); |
| bool honor_nans = false; |
| bool honor_snans = false; |
| bool fp_operation = false; |
| bool honor_trapv = false; |
| tree t; |
| size_t i; |
| bool handled, ret; |
| |
| if (TREE_CODE_CLASS (code) == tcc_comparison |
| || TREE_CODE_CLASS (code) == tcc_unary |
| || TREE_CODE_CLASS (code) == tcc_binary) |
| { |
| if (TREE_CODE_CLASS (code) == tcc_comparison) |
| t = TREE_TYPE (gimple_assign_rhs1 (stmt)); |
| else |
| t = TREE_TYPE (gimple_assign_lhs (stmt)); |
| fp_operation = FLOAT_TYPE_P (t); |
| if (fp_operation) |
| { |
| honor_nans = flag_trapping_math && !flag_finite_math_only; |
| honor_snans = flag_signaling_nans != 0; |
| } |
| else if (INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t)) |
| honor_trapv = true; |
| } |
| |
| /* First check the LHS. */ |
| if (tree_could_trap_p (gimple_assign_lhs (stmt))) |
| return true; |
| |
| /* Check if the main expression may trap. */ |
| ret = operation_could_trap_helper_p (code, fp_operation, honor_trapv, |
| honor_nans, honor_snans, |
| gimple_assign_rhs2 (stmt), |
| &handled); |
| if (handled) |
| return ret; |
| |
| /* If the expression does not trap, see if any of the individual operands may |
| trap. */ |
| for (i = 1; i < gimple_num_ops (stmt); i++) |
| if (tree_could_trap_p (gimple_op (stmt, i))) |
| return true; |
| |
| return false; |
| } |
| |
| |
| /* Return true if statement STMT within FUN could throw an exception. */ |
| |
| bool |
| stmt_could_throw_p (function *fun, gimple *stmt) |
| { |
| if (!flag_exceptions) |
| return false; |
| |
| /* The only statements that can throw an exception are assignments, |
| conditionals, calls, resx, and asms. */ |
| switch (gimple_code (stmt)) |
| { |
| case GIMPLE_RESX: |
| return true; |
| |
| case GIMPLE_CALL: |
| return !gimple_call_nothrow_p (as_a <gcall *> (stmt)); |
| |
| case GIMPLE_COND: |
| { |
| if (fun && !fun->can_throw_non_call_exceptions) |
| return false; |
| gcond *cond = as_a <gcond *> (stmt); |
| tree lhs = gimple_cond_lhs (cond); |
| return operation_could_trap_p (gimple_cond_code (cond), |
| FLOAT_TYPE_P (TREE_TYPE (lhs)), |
| false, NULL_TREE); |
| } |
| |
| case GIMPLE_ASSIGN: |
| if ((fun && !fun->can_throw_non_call_exceptions) |
| || gimple_clobber_p (stmt)) |
| return false; |
| return stmt_could_throw_1_p (as_a <gassign *> (stmt)); |
| |
| case GIMPLE_ASM: |
| if (fun && !fun->can_throw_non_call_exceptions) |
| return false; |
| return gimple_asm_volatile_p (as_a <gasm *> (stmt)); |
| |
| default: |
| return false; |
| } |
| } |
| |
| /* Return true if STMT in function FUN must be assumed necessary because of |
| non-call exceptions. */ |
| |
| bool |
| stmt_unremovable_because_of_non_call_eh_p (function *fun, gimple *stmt) |
| { |
| return (fun->can_throw_non_call_exceptions |
| && !fun->can_delete_dead_exceptions |
| && stmt_could_throw_p (fun, stmt)); |
| } |
| |
| /* Return true if expression T could throw an exception. */ |
| |
| bool |
| tree_could_throw_p (tree t) |
| { |
| if (!flag_exceptions) |
| return false; |
| if (TREE_CODE (t) == MODIFY_EXPR) |
| { |
| if (cfun->can_throw_non_call_exceptions |
| && tree_could_trap_p (TREE_OPERAND (t, 0))) |
| return true; |
| t = TREE_OPERAND (t, 1); |
| } |
| |
| if (TREE_CODE (t) == WITH_SIZE_EXPR) |
| t = TREE_OPERAND (t, 0); |
| if (TREE_CODE (t) == CALL_EXPR) |
| return (call_expr_flags (t) & ECF_NOTHROW) == 0; |
| if (cfun->can_throw_non_call_exceptions) |
| return tree_could_trap_p (t); |
| return false; |
| } |
| |
| /* Return true if STMT can throw an exception that is not caught within its |
| function FUN. FUN can be NULL but the function is extra conservative |
| then. */ |
| |
| bool |
| stmt_can_throw_external (function *fun, gimple *stmt) |
| { |
| int lp_nr; |
| |
| if (!stmt_could_throw_p (fun, stmt)) |
| return false; |
| if (!fun) |
| return true; |
| |
| lp_nr = lookup_stmt_eh_lp_fn (fun, stmt); |
| return lp_nr == 0; |
| } |
| |
| /* Return true if STMT can throw an exception that is caught within its |
| function FUN. */ |
| |
| bool |
| stmt_can_throw_internal (function *fun, gimple *stmt) |
| { |
| int lp_nr; |
| |
| gcc_checking_assert (fun); |
| if (!stmt_could_throw_p (fun, stmt)) |
| return false; |
| |
| lp_nr = lookup_stmt_eh_lp_fn (fun, stmt); |
| return lp_nr > 0; |
| } |
| |
| /* Given a statement STMT in IFUN, if STMT can no longer throw, then |
| remove any entry it might have from the EH table. Return true if |
| any change was made. */ |
| |
| bool |
| maybe_clean_eh_stmt_fn (struct function *ifun, gimple *stmt) |
| { |
| if (stmt_could_throw_p (ifun, stmt)) |
| return false; |
| return remove_stmt_from_eh_lp_fn (ifun, stmt); |
| } |
| |
| /* Likewise, but always use the current function. */ |
| |
| bool |
| maybe_clean_eh_stmt (gimple *stmt) |
| { |
| return maybe_clean_eh_stmt_fn (cfun, stmt); |
| } |
| |
| /* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced |
| OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT |
| in the table if it should be in there. Return TRUE if a replacement was |
| done that my require an EH edge purge. */ |
| |
| bool |
| maybe_clean_or_replace_eh_stmt (gimple *old_stmt, gimple *new_stmt) |
| { |
| int lp_nr = lookup_stmt_eh_lp (old_stmt); |
| |
| if (lp_nr != 0) |
| { |
| bool new_stmt_could_throw = stmt_could_throw_p (cfun, new_stmt); |
| |
| if (new_stmt == old_stmt && new_stmt_could_throw) |
| return false; |
| |
| remove_stmt_from_eh_lp (old_stmt); |
| if (new_stmt_could_throw) |
| { |
| add_stmt_to_eh_lp (new_stmt, lp_nr); |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /* Given a statement OLD_STMT in OLD_FUN and a duplicate statement NEW_STMT |
| in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP |
| operand is the return value of duplicate_eh_regions. */ |
| |
| bool |
| maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple *new_stmt, |
| struct function *old_fun, gimple *old_stmt, |
| hash_map<void *, void *> *map, |
| int default_lp_nr) |
| { |
| int old_lp_nr, new_lp_nr; |
| |
| if (!stmt_could_throw_p (new_fun, new_stmt)) |
| return false; |
| |
| old_lp_nr = lookup_stmt_eh_lp_fn (old_fun, old_stmt); |
| if (old_lp_nr == 0) |
| { |
| if (default_lp_nr == 0) |
| return false; |
| new_lp_nr = default_lp_nr; |
| } |
| else if (old_lp_nr > 0) |
| { |
| eh_landing_pad old_lp, new_lp; |
| |
| old_lp = (*old_fun->eh->lp_array)[old_lp_nr]; |
| new_lp = static_cast<eh_landing_pad> (*map->get (old_lp)); |
| new_lp_nr = new_lp->index; |
| } |
| else |
| { |
| eh_region old_r, new_r; |
| |
| old_r = (*old_fun->eh->region_array)[-old_lp_nr]; |
| new_r = static_cast<eh_region> (*map->get (old_r)); |
| new_lp_nr = -new_r->index; |
| } |
| |
| add_stmt_to_eh_lp_fn (new_fun, new_stmt, new_lp_nr); |
| return true; |
| } |
| |
| /* Similar, but both OLD_STMT and NEW_STMT are within the current function, |
| and thus no remapping is required. */ |
| |
| bool |
| maybe_duplicate_eh_stmt (gimple *new_stmt, gimple *old_stmt) |
| { |
| int lp_nr; |
| |
| if (!stmt_could_throw_p (cfun, new_stmt)) |
| return false; |
| |
| lp_nr = lookup_stmt_eh_lp (old_stmt); |
| if (lp_nr == 0) |
| return false; |
| |
| add_stmt_to_eh_lp (new_stmt, lp_nr); |
| return true; |
| } |
| |
| /* Returns TRUE if oneh and twoh are exception handlers (gimple_try_cleanup of |
| GIMPLE_TRY) that are similar enough to be considered the same. Currently |
| this only handles handlers consisting of a single call, as that's the |
| important case for C++: a destructor call for a particular object showing |
| up in multiple handlers. */ |
| |
| static bool |
| same_handler_p (gimple_seq oneh, gimple_seq twoh) |
| { |
| gimple_stmt_iterator gsi; |
| gimple *ones, *twos; |
| unsigned int ai; |
| |
| gsi = gsi_start (oneh); |
| if (!gsi_one_before_end_p (gsi)) |
| return false; |
| ones = gsi_stmt (gsi); |
| |
| gsi = gsi_start (twoh); |
| if (!gsi_one_before_end_p (gsi)) |
| return false; |
| twos = gsi_stmt (gsi); |
| |
| if (!is_gimple_call (ones) |
| || !is_gimple_call (twos) |
| || gimple_call_lhs (ones) |
| || gimple_call_lhs (twos) |
| || gimple_call_chain (ones) |
| || gimple_call_chain (twos) |
| || !gimple_call_same_target_p (ones, twos) |
| || gimple_call_num_args (ones) != gimple_call_num_args (twos)) |
| return false; |
| |
| for (ai = 0; ai < gimple_call_num_args (ones); ++ai) |
| if (!operand_equal_p (gimple_call_arg (ones, ai), |
| gimple_call_arg (twos, ai), 0)) |
| return false; |
| |
| return true; |
| } |
| |
| /* Optimize |
| try { A() } finally { try { ~B() } catch { ~A() } } |
| try { ... } finally { ~A() } |
| into |
| try { A() } catch { ~B() } |
| try { ~B() ... } finally { ~A() } |
| |
| This occurs frequently in C++, where A is a local variable and B is a |
| temporary used in the initializer for A. */ |
| |
| static void |
| optimize_double_finally (gtry *one, gtry *two) |
| { |
| gimple *oneh; |
| gimple_stmt_iterator gsi; |
| gimple_seq cleanup; |
| |
| cleanup = gimple_try_cleanup (one); |
| gsi = gsi_start (cleanup); |
| if (!gsi_one_before_end_p (gsi)) |
| return; |
| |
| oneh = gsi_stmt (gsi); |
| if (gimple_code (oneh) != GIMPLE_TRY |
| || gimple_try_kind (oneh) != GIMPLE_TRY_CATCH) |
| return; |
| |
| if (same_handler_p (gimple_try_cleanup (oneh), gimple_try_cleanup (two))) |
| { |
| gimple_seq seq = gimple_try_eval (oneh); |
| |
| gimple_try_set_cleanup (one, seq); |
| gimple_try_set_kind (one, GIMPLE_TRY_CATCH); |
| seq = copy_gimple_seq_and_replace_locals (seq); |
| gimple_seq_add_seq (&seq, gimple_try_eval (two)); |
| gimple_try_set_eval (two, seq); |
| } |
| } |
| |
| /* Perform EH refactoring optimizations that are simpler to do when code |
| flow has been lowered but EH structures haven't. */ |
| |
| static void |
| refactor_eh_r (gimple_seq seq) |
| { |
| gimple_stmt_iterator gsi; |
| gimple *one, *two; |
| |
| one = NULL; |
| two = NULL; |
| gsi = gsi_start (seq); |
| while (1) |
| { |
| one = two; |
| if (gsi_end_p (gsi)) |
| two = NULL; |
| else |
| two = gsi_stmt (gsi); |
| if (one && two) |
| if (gtry *try_one = dyn_cast <gtry *> (one)) |
| if (gtry *try_two = dyn_cast <gtry *> (two)) |
| if (gimple_try_kind (try_one) == GIMPLE_TRY_FINALLY |
| && gimple_try_kind (try_two) == GIMPLE_TRY_FINALLY) |
| optimize_double_finally (try_one, try_two); |
| if (one) |
| switch (gimple_code (one)) |
| { |
| case GIMPLE_TRY: |
| refactor_eh_r (gimple_try_eval (one)); |
| refactor_eh_r (gimple_try_cleanup (one)); |
| break; |
| case GIMPLE_CATCH: |
| refactor_eh_r (gimple_catch_handler (as_a <gcatch *> (one))); |
| break; |
| case GIMPLE_EH_FILTER: |
| refactor_eh_r (gimple_eh_filter_failure (one)); |
| break; |
| case GIMPLE_EH_ELSE: |
| { |
| geh_else *eh_else_stmt = as_a <geh_else *> (one); |
| refactor_eh_r (gimple_eh_else_n_body (eh_else_stmt)); |
| refactor_eh_r (gimple_eh_else_e_body (eh_else_stmt)); |
| } |
| break; |
| default: |
| break; |
| } |
| if (two) |
| gsi_next (&gsi); |
| else |
| break; |
| } |
| } |
| |
| namespace { |
| |
| const pass_data pass_data_refactor_eh = |
| { |
| GIMPLE_PASS, /* type */ |
| "ehopt", /* name */ |
| OPTGROUP_NONE, /* optinfo_flags */ |
| TV_TREE_EH, /* tv_id */ |
| PROP_gimple_lcf, /* properties_required */ |
| 0, /* properties_provided */ |
| 0, /* properties_destroyed */ |
| 0, /* todo_flags_start */ |
| 0, /* todo_flags_finish */ |
| }; |
| |
| class pass_refactor_eh : public gimple_opt_pass |
| { |
| public: |
| pass_refactor_eh (gcc::context *ctxt) |
| : gimple_opt_pass (pass_data_refactor_eh, ctxt) |
| {} |
| |
| /* opt_pass methods: */ |
| virtual bool gate (function *) { return flag_exceptions != 0; } |
| virtual unsigned int execute (function *) |
| { |
| refactor_eh_r (gimple_body (current_function_decl)); |
| return 0; |
| } |
| |
| }; // class pass_refactor_eh |
| |
| } // anon namespace |
| |
| gimple_opt_pass * |
| make_pass_refactor_eh (gcc::context *ctxt) |
| { |
| return new pass_refactor_eh (ctxt); |
| } |
| |
| /* At the end of gimple optimization, we can lower RESX. */ |
| |
| static bool |
| lower_resx (basic_block bb, gresx *stmt, |
| hash_map<eh_re
|