Switch try_catch to the region API

Author: antoyo

gcc/jit/jit-playback.cc

@@ -2616,42 +2616,47 @@ add_eval (location *loc,
 void
 playback::block::
 add_try_catch (location *loc,
-         block *try_block,
-         block *catch_block,
+         recording::region *try_region,
+         recording::region *catch_region,
          bool is_finally)
 {
-  gcc_assert (try_block);
-  gcc_assert (catch_block);
+  gcc_assert (try_region);
+  gcc_assert (catch_region);
 
-  try_block->m_is_try_or_catch = true;
-  catch_block->m_is_try_or_catch = true;
-
-  if (loc)
+  auto_vec<block *> try_blocks;
+  auto_vec<block *> handler_blocks;
+  unsigned i;
+  recording::block *try_block;
+  FOR_EACH_VEC_ELT (try_region->get_blocks (), i, try_block)
   {
-    set_tree_location (try_block->as_label_decl (), loc);
-    set_tree_location (catch_block->as_label_decl (), loc);
+    block *b = try_block->playback_block ();
+    gcc_assert (b);
+    try_blocks.safe_push (b);
   }
-
-  tree try_body = alloc_stmt_list ();
-  unsigned int i;
-  tree stmt;
-  FOR_EACH_VEC_ELT (try_block->m_stmts, i, stmt) {
-    append_to_statement_list (stmt, &try_body);
+  FOR_EACH_VEC_ELT (catch_region->get_blocks (), i, try_block)
+  {
+    block *b = try_block->playback_block ();
+    gcc_assert (b);
+    handler_blocks.safe_push (b);
   }
 
-  tree handler_body = alloc_stmt_list ();
-  unsigned int j;
-  tree handler_stmt;
-  FOR_EACH_VEC_ELT (catch_block->m_stmts, j, handler_stmt) {
-    append_to_statement_list (handler_stmt, &handler_body);
-  }
+      tree try_body
+	= block::assemble_region_body (&try_blocks);
+      tree handler_body
+	= block::assemble_region_body (&handler_blocks);
 
+  tree stmt;
   if (is_finally)
-    add_stmt (build2 (TRY_FINALLY_EXPR, void_type_node,
-		      try_body, handler_body));
+    stmt = build2 (TRY_FINALLY_EXPR, void_type_node,
+		      try_body, handler_body);
   else
-    add_stmt (build2 (TRY_CATCH_EXPR, void_type_node, try_body,
-		      build2 (CATCH_EXPR, void_type_node, NULL, handler_body)));
+    stmt = build2 (TRY_CATCH_EXPR, void_type_node, try_body,
+		      build2 (CATCH_EXPR, void_type_node, NULL, handler_body));
+
+  if (loc)
+    set_tree_location (stmt, loc);
+
+  add_stmt (stmt);
 }
 
 /* Add an assignment to the function's statement list.  */

gcc/jit/jit-playback.h

@@ -704,8 +704,8 @@ class block : public wrapper
 
   void
   add_try_catch (location *loc,
-		 block *try_block,
-		 block *catch_block,
+		 recording::region *try_region,
+		 recording::region *catch_region,
 		 bool is_finally);
 
   void

gcc/jit/jit-recording.cc

@@ -5398,14 +5398,11 @@ recording::block::add_eval (recording::location *loc,
 
 recording::statement *
 recording::block::add_try_catch (location *loc,
-                   block *try_block,
-                   block *catch_block,
+                   recording::region *try_region,
+                   recording::region *catch_region,
                    bool is_finally)
 {
-  statement *result = new try_catch (this, loc, try_block, catch_block, is_finally);
-  // TODO: explain why we set the blocks reachable state.
-  try_block->m_is_reachable = true;
-  catch_block->m_is_reachable = true;
+  statement *result = new try_catch (this, loc, try_region, catch_region, is_finally);
   m_ctxt->record (result);
   m_statements.safe_push (result);
   return result;
@@ -8080,16 +8077,20 @@ void
 recording::try_catch::clone_into (block_cloner &cloner, block *dest) const
 {
   dest->add_try_catch (get_loc (),
-		       cloner.remap (m_try_block),
-		       cloner.remap (m_catch_block),
+		       cloner.clone_region (m_try_region),
+		       cloner.clone_region (m_catch_region),
 		       m_is_finally);
 }
 
 void
 recording::try_catch::get_inlined_blocks (auto_vec<block *> &out) const
 {
-  out.safe_push (m_try_block);
-  out.safe_push (m_catch_block);
+  unsigned i;
+  block *b;
+  FOR_EACH_VEC_ELT (m_try_region->get_blocks (), i, b)
+    out.safe_push (b);
+  FOR_EACH_VEC_ELT (m_catch_region->get_blocks (), i, b)
+    out.safe_push (b);
 }
 
 void
@@ -8225,8 +8226,8 @@ recording::try_catch::replay_into (replayer *r)
 {
   playback_block (get_block ())
     ->add_try_catch (playback_location (r),
-        m_try_block->playback_block (),
-        m_catch_block->playback_block (),
+        m_try_region,
+        m_catch_region,
         m_is_finally);
 }
 
@@ -8239,13 +8240,13 @@ recording::try_catch::make_debug_string ()
   if (m_is_finally)
     return string::from_printf (m_ctxt,
                   "try { %s } finally { %s };",
-                  m_try_block->get_debug_string (),
-                  m_catch_block->get_debug_string ());
+                  m_try_region->get_debug_string (),
+                  m_catch_region->get_debug_string ());
   else
     return string::from_printf (m_ctxt,
                   "try { %s } catch { %s };",
-                  m_try_block->get_debug_string (),
-                  m_catch_block->get_debug_string ());
+                  m_try_region->get_debug_string (),
+                  m_catch_region->get_debug_string ());
 }
 
 /* Implementation of recording::memento::write_reproducer for
@@ -8264,8 +8265,8 @@ recording::try_catch::write_reproducer (reproducer &r)
        func_name,
        r.get_identifier (get_block ()),
        r.get_identifier (get_loc ()),
-       r.get_identifier (m_try_block),
-       r.get_identifier (m_catch_block));
+       r.get_identifier (m_try_region),
+       r.get_identifier (m_catch_region));
 }
 
 /* The implementation of class gcc::jit::recording::cleanup.  */

gcc/jit/jit-recording.h

@@ -1747,8 +1747,8 @@ class block : public memento
 
   statement *
   add_try_catch (location *loc,
-		 block *try_block,
-		 block *catch_block,
+		 region *try_region,
+		 region *catch_region,
 		 bool is_finally = false);
 
   statement *
@@ -3025,12 +3025,12 @@ class try_catch : public statement
 public:
   try_catch (block *b,
     location *loc,
-    block *try_block,
-    block *catch_block,
+    region *try_region,
+    region *catch_region,
     bool is_finally = false)
   : statement (b, loc),
-    m_try_block (try_block),
-    m_catch_block (catch_block),
+    m_try_region (try_region),
+    m_catch_region (catch_region),
     m_is_finally (is_finally) {}
 
   void replay_into (replayer *r) final override;
@@ -3043,8 +3043,8 @@ class try_catch : public statement
   void write_reproducer (reproducer &r) final override;
 
 private:
-  block *m_try_block;
-  block *m_catch_block;
+  region *m_try_region;
+  region *m_catch_region;
   bool m_is_finally;
 };
 

gcc/jit/libgccjit.cc

@@ -3119,17 +3119,17 @@ gcc_jit_block_add_eval (gcc_jit_block *block,
 void
 gcc_jit_block_add_try_catch (gcc_jit_block *block,
 			     gcc_jit_location *loc,
-			     gcc_jit_block *try_block,
-			     gcc_jit_block *catch_block)
+			     gcc_jit_region *try_region,
+			     gcc_jit_region *catch_region)
 {
   RETURN_IF_NOT_VALID_BLOCK (block, loc);
   gcc::jit::recording::context *ctxt = block->get_context ();
   JIT_LOG_FUNC (ctxt->get_logger ());
   /* LOC can be NULL.  */
-  RETURN_IF_FAIL (try_block, ctxt, loc, "NULL rvalue");
-  RETURN_IF_FAIL (catch_block, ctxt, loc, "NULL rvalue");
+  RETURN_IF_FAIL (try_region, ctxt, loc, "NULL try_region");
+  RETURN_IF_FAIL (catch_region, ctxt, loc, "NULL cleanup_region");
 
-  /*gcc::jit::recording::statement *stmt =*/ block->add_try_catch (loc, try_block, catch_block);
+  /*gcc::jit::recording::statement *stmt =*/ block->add_try_catch (loc, try_region, catch_region);
 
   // TODO: remove this or use it.
   /* "stmt" should be good enough to be usable in error-messages,
@@ -3148,17 +3148,17 @@ gcc_jit_block_add_try_catch (gcc_jit_block *block,
 void
 gcc_jit_block_add_try_finally (gcc_jit_block *block,
 			     gcc_jit_location *loc,
-			     gcc_jit_block *try_block,
-			     gcc_jit_block *finally_block)
+			     gcc_jit_region *try_region,
+			     gcc_jit_region *finally_region)
 {
   RETURN_IF_NOT_VALID_BLOCK (block, loc);
   gcc::jit::recording::context *ctxt = block->get_context ();
   JIT_LOG_FUNC (ctxt->get_logger ());
   /* LOC can be NULL.  */
-  RETURN_IF_FAIL (try_block, ctxt, loc, "NULL rvalue");
-  RETURN_IF_FAIL (finally_block, ctxt, loc, "NULL rvalue");
+  RETURN_IF_FAIL (try_region, ctxt, loc, "NULL try_region");
+  RETURN_IF_FAIL (finally_region, ctxt, loc, "NULL finally_region");
 
-  /*gcc::jit::recording::statement *stmt =*/ block->add_try_catch (loc, try_block, finally_block, true);
+  /*gcc::jit::recording::statement *stmt =*/ block->add_try_catch (loc, try_region, finally_region, true);
 
   // TODO: remove this or use it.
   /* "stmt" should be good enough to be usable in error-messages,

gcc/jit/libgccjit.h

@@ -1559,8 +1559,8 @@ gcc_jit_block_add_eval (gcc_jit_block *block,
 void
 gcc_jit_block_add_try_catch (gcc_jit_block *block,
 			     gcc_jit_location *loc,
-			     gcc_jit_block *try_block,
-			     gcc_jit_block *catch_block);
+			     gcc_jit_region *try_region,
+			     gcc_jit_region *catch_region);
 
 /* Add a try/finally statement.
    This is equivalent to this C++-like code:
@@ -1575,8 +1575,8 @@ gcc_jit_block_add_try_catch (gcc_jit_block *block,
 void
 gcc_jit_block_add_try_finally (gcc_jit_block *block,
 			       gcc_jit_location *loc,
-			       gcc_jit_block *try_block,
-			       gcc_jit_block *finally_block);
+			       gcc_jit_region *try_region,
+			       gcc_jit_region *finally_region);
 
 /* Create a new region within func, for use as the body of an
    exception-handling construct (see gcc_jit_block_add_cleanup).