https://gcc.gnu.org/g:c4ab1c57107003e55287df06cf9b552830cb9d3c
commit c4ab1c57107003e55287df06cf9b552830cb9d3c
Author: Pranil Dey <mkd...@gmail.com>
Date: Mon Oct 7 02:23:19 2024 +0530
Formatting for all functions done according to GNU standards and fixed
testsuite fail bugs
Diff:
---
gcc/tree-eh.cc | 448 ++++++++++++++++++++++++++++++++-------------------------
1 file changed, 256 insertions(+), 192 deletions(-)
diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc
index 634f33f9a8d9..df90d1bc2049 100644
--- a/gcc/tree-eh.cc
+++ b/gcc/tree-eh.cc
@@ -2283,14 +2283,14 @@ same_or_derived_type (tree t1, tree t2)
t2 = TYPE_MAIN_VARIANT (t2);
if (t1 == t2)
return true;
- while ( (TREE_CODE (t1) == POINTER_TYPE || TREE_CODE (t1) == REFERENCE_TYPE)
- && TREE_CODE (t1) == TREE_CODE (t2))
- {
- t1 = TYPE_MAIN_VARIANT (TREE_TYPE (t1));
- t2 = TYPE_MAIN_VARIANT (TREE_TYPE (t2));
- if (TREE_CODE (t1) == VOID_TYPE)
- return true;
- }
+ while ((TREE_CODE (t1) == POINTER_TYPE || TREE_CODE (t1) == REFERENCE_TYPE)
+ && TREE_CODE (t1) == TREE_CODE (t2))
+ {
+ t1 = TYPE_MAIN_VARIANT (TREE_TYPE (t1));
+ t2 = TYPE_MAIN_VARIANT (TREE_TYPE (t2));
+ if (TREE_CODE (t1) == VOID_TYPE)
+ return true;
+ }
if (t1 == t2)
return true;
if (TREE_CODE (t2) == NULLPTR_TYPE && TREE_CODE (t1) == POINTER_TYPE)
@@ -2300,153 +2300,186 @@ same_or_derived_type (tree t1, tree t2)
return odr_equivalent_or_derived_p (t1, t2);
}
-// Check if a landing pad can handle any of the given exception types
-static bool match_lp (eh_region region, vec<tree> *exception_types){
- // Ensure the region is of type ERT_TRY
- if (region && region->type == ERT_TRY) {
- eh_catch_d *catch_handler = region->u.eh_try.first_catch;
+// Check if a region can handle any of the given exception types
+static bool
+match_lp (eh_region region, vec<tree> *exception_types)
+{
+ // Ensure the region is of type ERT_TRY
+ if (region && region->type == ERT_TRY)
+ {
+ eh_catch_d *catch_handler = region->u.eh_try.first_catch;
- while (catch_handler) {
- tree type_list = catch_handler->type_list;
+ while (catch_handler)
+ {
+ tree type_list = catch_handler->type_list;
- if (type_list == NULL) {
- return true;
+ if (type_list == NULL)
+ {
+ return true;
}
- for (tree t = type_list; t; t = TREE_CHAIN (t)) {
- tree type = TREE_VALUE (t);
- for (unsigned i = 0; i < exception_types->length (); ++i) {
+ for (tree t = type_list; t; t = TREE_CHAIN (t))
+ {
+ tree type = TREE_VALUE (t);
+ for (unsigned i = 0; i < exception_types->length (); ++i)
+ {
// match found or a catch-all handler (NULL)
- if (!type || same_or_derived_type (type,
(*exception_types)[i])) {
- return true;
+ if (!type
+ || same_or_derived_type (type, (*exception_types)[i]))
+ {
+ return true;
}
}
}
- catch_handler = catch_handler->next_catch;
+ catch_handler = catch_handler->next_catch;
}
}
- return false;
+ return false;
}
-static void unlink_eh_region(eh_region region) {
- eh_region *link;
+static void
+unlink_eh_region (eh_region region)
+{
+ eh_region *link;
- // Check if region is root
- if (!region->outer) {
- gcc_unreachable();
- return;
+ // Check if region is root
+ if (!region->outer)
+ {
+ gcc_unreachable ();
+ return;
}
- link = ®ion->outer->inner;
+ link = ®ion->outer->inner;
- while (*link && *link != region) {
- link = &(*link)->next_peer;
+ while (*link && *link != region)
+ {
+ link = &(*link)->next_peer;
}
- // Ensure the region is in the peer chain
- gcc_assert(*link == region);
+ // Ensure the region is in the peer chain
+ gcc_assert (*link == region);
- *link = region->next_peer;
+ *link = region->next_peer;
- region->outer = NULL;
- region->next_peer = NULL;
+ region->outer = NULL;
+ region->next_peer = NULL;
}
-static void reinsert_eh_region (eh_region region, eh_region new_outer) {
- region->outer = new_outer;
-
- // Insert region as the inner of new_outer, or at the top of the tree
- if (new_outer) {
- region->next_peer = new_outer->inner;
- new_outer->inner = region;
- } else {
- region->next_peer = cfun->eh->region_tree;
- cfun->eh->region_tree = region;
- }
+static void
+reinsert_eh_region (eh_region region, eh_region new_outer)
+{
+ region->outer = new_outer;
+ // Insert region as the inner of new_outer, or at the top of the tree
+ if (new_outer)
+ {
+ region->next_peer = new_outer->inner;
+ new_outer->inner = region;
+ }
+ else
+ {
+ region->next_peer = cfun->eh->region_tree;
+ cfun->eh->region_tree = region;
+ }
}
-// Function to update landing pad and region in throw_stmt_table for a given
statement
-void update_stmt_eh_region (gimple *stmt) {
+/* Function to update landing pad and region in throw_stmt_table for a given
+statement */
+void
+update_stmt_eh_region (gimple *stmt)
+{
auto_vec<tree> exception_types;
- if (!stmt_throw_types (cfun, stmt, &exception_types)) {
- return;
+ if (!stmt_throw_types (cfun, stmt, &exception_types))
+ {
+ return;
}
-
- int lp_nr = lookup_stmt_eh_lp_fn (cfun, stmt);
- if (lp_nr <= 0) {
+
+ eh_region region;
+
+ int lp_nr = lookup_stmt_eh_lp_fn (cfun, stmt);
+ if (lp_nr <= 0)
+ {
return;
}
- eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
- if (!lp) {
- return;
+ eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
+ if (!lp)
+ {
+ return;
}
- eh_region region = lp->region;
- eh_region resx_region = NULL;
+ region = lp->region;
+ eh_region resx_region = NULL;
- bool update = false;
- if (gimple_code (stmt) == GIMPLE_RESX)
- resx_region = get_eh_region_from_number (gimple_resx_region (as_a <gresx
*> (stmt)));
+ bool update = false;
+ if (gimple_code (stmt) == GIMPLE_RESX)
+ resx_region = get_eh_region_from_number (
+ gimple_resx_region (as_a<gresx *> (stmt)));
+
+ // Walk up the region tree
+ while (region)
+ {
+ switch (region->type)
+ {
+ case ERT_CLEANUP:
+ if (!update)
+ return;
+
+ if (gimple_code (stmt) == GIMPLE_RESX)
+ {
+ unlink_eh_region (resx_region);
+ reinsert_eh_region (resx_region, region);
+ }
- // Walk up the region tree
- while (region) {
- switch (region->type) {
- case ERT_CLEANUP:
- if (!update)
- return;
+ remove_stmt_from_eh_lp_fn (cfun, stmt);
+ record_stmt_eh_region (region, stmt);
+ return;
- if (gimple_code (stmt) == GIMPLE_RESX){
+ case ERT_TRY:
+ if (match_lp (region, &exception_types))
+ {
+ if (!update)
+ return;
+ if (gimple_code (stmt) == GIMPLE_RESX)
+ {
unlink_eh_region (resx_region);
reinsert_eh_region (resx_region, region);
}
- remove_stmt_from_eh_lp_fn (cfun, stmt);
- record_stmt_eh_region (region, stmt);
- return;
-
- case ERT_TRY:
- if (match_lp (region, &exception_types)) {
- if (!update)
- return;
- if (gimple_code (stmt) == GIMPLE_RESX){
- unlink_eh_region (resx_region);
- reinsert_eh_region (resx_region, region);
- }
-
- remove_stmt_from_eh_lp_fn (cfun, stmt);
- record_stmt_eh_region (region, stmt);
- return;
- }
- break;
+ remove_stmt_from_eh_lp_fn (cfun, stmt);
+ record_stmt_eh_region (region, stmt);
+ return;
+ }
+ break;
- case ERT_MUST_NOT_THROW:
- // Undefined behavior, leave edge unchanged
- return;
+ case ERT_MUST_NOT_THROW:
+ // Undefined behavior, leave edge unchanged
+ return;
- case ERT_ALLOWED_EXCEPTIONS:
- /* FIXME: match_lp will always return false. */
- if (!match_lp (region, &exception_types)) {
- return;
- }
- break;
+ case ERT_ALLOWED_EXCEPTIONS:
+ /* FIXME: match_lp will always return false. */
+ if (!match_lp (region, &exception_types))
+ {
+ return;
+ }
+ break;
- default:
- break;
+ default:
+ break;
}
- region = region->outer;
- update = true;
+ region = region->outer;
+ update = true;
}
- if (!update)
+ if (!update)
return;
- if (gimple_code (stmt) == GIMPLE_RESX){
+ if (gimple_code (stmt) == GIMPLE_RESX)
+ {
unlink_eh_region (resx_region);
reinsert_eh_region (resx_region, NULL);
}
- remove_stmt_from_eh_lp_fn (cfun, stmt);
+ remove_stmt_from_eh_lp_fn (cfun, stmt);
}
/* Create the single EH edge from STMT to its nearest landing pad,
@@ -3091,91 +3124,114 @@ stmt_could_throw_1_p (gassign *stmt)
return false;
}
-bool extract_types_for_call (gcall *call_stmt, vec<tree> *ret_vector) {
- tree callee = gimple_call_fndecl (call_stmt);
- if (callee == NULL_TREE) {
- return false;
+bool
+extract_types_for_call (gcall *call_stmt, vec<tree> *ret_vector)
+{
+ tree callee = gimple_call_fndecl (call_stmt);
+ if (callee == NULL_TREE)
+ {
+ return false;
}
- if (strcmp (IDENTIFIER_POINTER (DECL_NAME (callee)), "__cxa_throw") == 0) {
- // Extracting exception type
- tree exception_type_info = gimple_call_arg (call_stmt, 1);
- if (exception_type_info && TREE_CODE (exception_type_info) ==
ADDR_EXPR) {
- exception_type_info = TREE_OPERAND (exception_type_info, 0);
+ if (strcmp (IDENTIFIER_POINTER (DECL_NAME (callee)), "__cxa_throw") == 0)
+ {
+ // Extracting exception type
+ tree exception_type_info = gimple_call_arg (call_stmt, 1);
+ if (exception_type_info && TREE_CODE (exception_type_info) == ADDR_EXPR)
+ {
+ exception_type_info = TREE_OPERAND (exception_type_info, 0);
}
- if (exception_type_info && TREE_CODE (exception_type_info) ==
VAR_DECL) {
- // Converting the typeinfo to a compile-time type
- tree exception_type = TREE_TYPE (decl_assembler_name
(exception_type_info));
- if (exception_type) {
- ret_vector->safe_push (exception_type);
+ if (exception_type_info && TREE_CODE (exception_type_info) == VAR_DECL)
+ {
+ // Converting the typeinfo to a compile-time type
+ tree exception_type
+ = TREE_TYPE (decl_assembler_name (exception_type_info));
+ if (exception_type)
+ {
+ ret_vector->safe_push (exception_type);
}
}
- return true;
+ return true;
}
- return false;
+ return false;
}
-// Determine which types can be thrown by a GIMPLE statement and convert them
to compile-time types
-bool stmt_throw_types (function *fun, gimple *stmt, vec<tree> *ret_vector) {
- if (!flag_exceptions) {
- return false;
+/* Determine which types can be thrown by a GIMPLE statement and convert them
+ * to compile-time types */
+bool
+stmt_throw_types (function *, gimple *stmt, vec<tree> *ret_vector)
+{
+ if (!flag_exceptions)
+ {
+ return false;
}
- bool type_exists = true;
+ bool type_exists = true;
+
+ switch (gimple_code (stmt))
+ {
+ case GIMPLE_RESX:
+ type_exists = extract_types_for_resx (as_a<gresx *> (stmt), ret_vector);
+ return type_exists;
- switch (gimple_code (stmt)) {
- case GIMPLE_RESX:
- type_exists = extract_types_for_resx (as_a<gresx*> (stmt),
ret_vector);
- return type_exists;
+ case GIMPLE_CALL:
+ type_exists = extract_types_for_call (as_a<gcall *> (stmt), ret_vector);
+ /* FIXME: if type exists we should have always vector nonempty. */
+ return type_exists && !ret_vector->is_empty ();
- case GIMPLE_CALL:
- type_exists = extract_types_for_call (as_a<gcall*> (stmt),
ret_vector);
- /* FIXME: if type exists we should have always vector nonempty. */
- return type_exists && !ret_vector->is_empty ();
-
- default:
- return false;
+ default:
+ return false;
}
}
// To get the all exception types from a resx stmt
-static bool extract_types_for_resx (basic_block bb, vec<tree> *ret_vector) {
- edge e;
- edge_iterator ei;
-
+static bool
+extract_types_for_resx (basic_block bb, vec<tree> *ret_vector)
+{
+ edge e;
+ edge_iterator ei;
+
// Iterate over edges to walk up the basic blocks
FOR_EACH_EDGE (e, ei, bb->preds)
{
- // Get the last stmt of the basic block as it is an EH stmt
- bb = e->src;
- gimple_stmt_iterator gsi = gsi_last_bb (bb);
- gimple *last_stmt = gsi_stmt (gsi);
-
- if (bb->aux)continue;
- bb->aux = (void*)1;
-
- if (last_stmt && (e->flags & EDGE_EH)){
- if (gimple_code (last_stmt) == GIMPLE_CALL) {
- // check if its a throw
- if (!extract_types_for_call (as_a<gcall*> (last_stmt), ret_vector))
- return false;
- continue;
- }
- else if (gimple_code (last_stmt) == GIMPLE_RESX){
- // Recursively processing resx
- extract_types_for_resx (last_stmt, ret_vector);
- continue;
+ // Get the last stmt of the basic block as it is an EH stmt
+ bb = e->src;
+ gimple_stmt_iterator gsi = gsi_last_bb (bb);
+ gimple *last_stmt = gsi_stmt (gsi);
+
+ if (bb->aux)
+ continue;
+ bb->aux = (void *)1;
+
+ if (last_stmt && (e->flags & EDGE_EH))
+ {
+ if (gimple_code (last_stmt) == GIMPLE_CALL)
+ {
+ // check if its a throw
+ if (!extract_types_for_call (as_a<gcall *> (last_stmt),
+ ret_vector))
+ return false;
+ continue;
+ }
+ else if (gimple_code (last_stmt) == GIMPLE_RESX)
+ {
+ // Recursively processing resx
+ // FIXME: to get this linear, we should cache results.
+ if (!extract_types_for_resx (last_stmt, ret_vector))
+ return false;
+ continue;
+ }
}
-
- }
/* FIXME: remove recursion here, so we do not run out of stack. */
- else if (!extract_types_for_resx (last_stmt, ret_vector))
+ else if (!extract_types_for_resx (e->src, ret_vector))
return false;
}
return true;
}
-// To get the all exception types from a resx stmt
-bool extract_types_for_resx (gimple *resx_stmt, vec<tree> *ret_vector) {
+// To get the all exception types from a resx stmt
+bool
+extract_types_for_resx (gimple *resx_stmt, vec<tree> *ret_vector)
+{
basic_block bb = gimple_bb (resx_stmt);
bool ret = extract_types_for_resx (bb, ret_vector);
/* FIXME: this is non-linear. */
@@ -3184,40 +3240,48 @@ bool extract_types_for_resx (gimple *resx_stmt,
vec<tree> *ret_vector) {
}
// To get the types being thrown outside of a function
-bool extract_fun_resx_types (function *fun, vec<tree> *ret_vector) {
- basic_block bb;
- gimple_stmt_iterator gsi;
+bool
+extract_fun_resx_types (function *fun, vec<tree> *ret_vector)
+{
+ basic_block bb;
+ gimple_stmt_iterator gsi;
hash_set<tree> types;
- FOR_EACH_BB_FN (bb, fun)
- {
- bb->aux = (void*)1;
- gsi = gsi_last_bb (bb);
- gimple *stmt = gsi_stmt (gsi);
- auto_vec<tree> resx_types;
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ bb->aux = (void *)1;
+ gsi = gsi_last_bb (bb);
+ gimple *stmt = gsi_stmt (gsi);
+ auto_vec<tree> resx_types;
if (!stmt || !stmt_can_throw_external (fun, stmt))
- continue;
-
- if (gimple_code (stmt) == GIMPLE_RESX){
- if (!extract_types_for_resx (stmt, &resx_types))
- return false;
- }
-
- else if (gimple_code (stmt) == GIMPLE_CALL){
- if (!extract_types_for_call (as_a<gcall*> (stmt),
&resx_types))
- return false;
- }
+ continue;
- for (unsigned i = 0;i<resx_types.length ();++i){
- tree type = resx_types[i];
- types.add (type);
- }
- }
+ if (gimple_code (stmt) == GIMPLE_RESX)
+ {
+ if (!extract_types_for_resx (stmt, &resx_types))
+ return false;
+ }
+
+ else if (gimple_code (stmt) == GIMPLE_CALL)
+ {
+ if (!extract_types_for_call (as_a<gcall *> (stmt), &resx_types))
+ return false;
+ }
- for (auto it = types.begin (); it != types.end (); ++it) {
- ret_vector->safe_push (*it);
+ for (unsigned i = 0; i < resx_types.length (); ++i)
+ {
+ tree type = resx_types[i];
+ types.add (type);
+ }
}
+
+ for (auto it = types.begin (); it != types.end (); ++it)
+ {
+ ret_vector->safe_push (*it);
+ }
+
+ return true;
}
/* Return true if statement STMT within FUN could throw an exception. */
