diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 4be67e3..bfc2573 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -25,6 +25,7 @@
 #include "ipa-ref.h"
 #include "plugin-api.h"
 #include "ipa-param-manipulation.h"
+#include "print-tree.h"
 
 extern void debuginfo_early_init (void);
 extern void debuginfo_init (void);
diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc
index 7b5be0f..cef7d0b 100644
--- a/gcc/cgraphunit.cc
+++ b/gcc/cgraphunit.cc
@@ -240,9 +240,14 @@
   /* Double check that no one output the function into assembly file
      early.  */
   if (!native_rtl_p ())
+  {
+      if (!(!DECL_ASSEMBLER_NAME_SET_P (decl)
+	 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
+          debug_tree (decl);
       gcc_checking_assert
 	(!DECL_ASSEMBLER_NAME_SET_P (decl)
 	 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)));
+  }
 
   if (!definition)
     return false;
@@ -1390,7 +1395,7 @@
 		      || cnode->alias
 		      || gimple_has_body_p (decl)
 		      || cnode->native_rtl_p ());
-	  gcc_assert (cnode->analyzed == cnode->definition);
+          gcc_assert (cnode->analyzed == cnode->definition);
 	}
       node->aux = NULL;
     }
diff --git a/gcc/dwarf2asm.cc b/gcc/dwarf2asm.cc
index 274f574..e640a71 100644
--- a/gcc/dwarf2asm.cc
+++ b/gcc/dwarf2asm.cc
@@ -938,7 +938,7 @@
   /* The strings are always those from IDENTIFIER_NODEs, and,
      therefore, we should never have two copies of the same
      string.  */
-  gcc_assert (ret);
+  //gcc_assert (ret);
 
   return ret;
 }
@@ -1159,4 +1159,14 @@
   va_end (ap);
 }
 
+void dwarf2asm_cc_finalize (void)
+{
+  if (indirect_pool)
+  {
+    indirect_pool->empty();
+    indirect_pool = NULL;
+  }
+  dw2_const_labelno = 0;
+}
+
 #include "gt-dwarf2asm.h"
diff --git a/gcc/dwarf2asm.h b/gcc/dwarf2asm.h
index 871a77b..53720ab 100644
--- a/gcc/dwarf2asm.h
+++ b/gcc/dwarf2asm.h
@@ -86,6 +86,8 @@
 extern rtx dw2_force_const_mem (rtx, bool);
 extern void dw2_output_indirect_constants (void);
 
+void dwarf2asm_cc_finalize (void);
+
 /* These are currently unused.  */
 
 #if 0
diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc
index 28a4ae0..1bf4289 100644
--- a/gcc/dwarf2out.cc
+++ b/gcc/dwarf2out.cc
@@ -1003,6 +1003,9 @@
 	  if (targetm.asm_out.make_eh_symbol_indirect != NULL)
 	    ref = targetm.asm_out.make_eh_symbol_indirect (ref, true);
 	  else
+            // TODO: HERE: should not insert multiple times the same personality function.
+            // If we don't, we segfault later, possibly because we don't generate the info for the duplicates.
+            // I'm not sure why it's attempting to insert multiple times the same personality function.
 	    ref = dw2_force_const_mem (ref, true);
 	}
 
diff --git a/gcc/ipa-visibility.cc b/gcc/ipa-visibility.cc
index 8a27e7b..8b1a0a4 100644
--- a/gcc/ipa-visibility.cc
+++ b/gcc/ipa-visibility.cc
@@ -709,6 +709,15 @@
 	    }
 	  node->dissolve_same_comdat_group_list ();
 	}
+      if (!((!DECL_WEAK (node->decl)
+		  && !DECL_COMDAT (node->decl))
+      	          || TREE_PUBLIC (node->decl)
+		  || node->weakref
+		  || DECL_EXTERNAL (node->decl)))
+      {
+          fprintf (stderr, "%d, %d, %d, %d, %d\n", DECL_WEAK (node->decl), DECL_COMDAT (node->decl), TREE_PUBLIC (node->decl), node->weakref, DECL_EXTERNAL (node->decl));
+          debug_tree (node->decl);
+      }
       gcc_assert ((!DECL_WEAK (node->decl)
 		  && !DECL_COMDAT (node->decl))
       	          || TREE_PUBLIC (node->decl)
diff --git a/gcc/jit/dummy-frontend.cc b/gcc/jit/dummy-frontend.cc
index 1110993..a9330f5 100644
--- a/gcc/jit/dummy-frontend.cc
+++ b/gcc/jit/dummy-frontend.cc
@@ -611,6 +611,10 @@
   target_builtins.empty ();
   build_common_builtin_nodes ();
 
+  /* Initialize EH, if we've been told to do so.  */
+  if (flag_exceptions)
+    using_eh_for_cleanups ();
+
   /* The default precision for floating point numbers.  This is used
      for floating point constants with abstract type.  This may
      eventually be controllable by a command line option.  */
diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc
index 83c8c21..775e08f 100644
--- a/gcc/jit/jit-playback.cc
+++ b/gcc/jit/jit-playback.cc
@@ -547,8 +547,7 @@
 	      enum built_in_function builtin_id,
 	      int is_target_builtin,
 	      const std::vector<gcc_jit_fn_attribute> &attributes,
-	      const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &string_attributes,
-	      function *personality_function)
+	      const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &string_attributes)
 {
   int i;
   param *param;
@@ -571,11 +570,7 @@
 
   /* FIXME: this uses input_location: */
   tree fndecl = build_fn_decl (name, fn_type);
-
-  if (personality_function)
-  {
-    DECL_FUNCTION_PERSONALITY (fndecl) = personality_function->as_fndecl ();
-  }
+  TREE_NOTHROW (fndecl) = 0;
 
   if (loc)
     set_tree_location (fndecl, loc);
@@ -659,6 +654,9 @@
           break;
         case GCC_JIT_FN_ATTRIBUTE_WEAK:
           DECL_WEAK (fndecl) = 1;
+          TREE_PUBLIC (fndecl) = 1;
+          //declare_weak (fndecl);
+          //make_decl_one_only(fndecl, DECL_ASSEMBLER_NAME(fndecl));
           break;
     }
 
@@ -2164,6 +2162,16 @@
   return new rvalue (m_ctxt, t_fnptr);
 }
 
+/* Construct a new local within this playback::function.  */
+
+void
+playback::function::
+set_personality_function (function *personality_function)
+{
+  //fprintf (stderr, "************* Setting personality function %s for %s\n", IDENTIFIER_POINTER (DECL_NAME (personality_function->as_fndecl ())), IDENTIFIER_POINTER (DECL_NAME (m_inner_fndecl)));
+  DECL_FUNCTION_PERSONALITY (m_inner_fndecl) = personality_function->as_fndecl ();
+}
+
 /* Build a statement list for the function as a whole out of the
    lists of statements for the individual blocks, building labels
    for each block.  */
@@ -2222,8 +2230,11 @@
   if (m_kind == GCC_JIT_FUNCTION_INTERNAL
       ||m_kind == GCC_JIT_FUNCTION_ALWAYS_INLINE)
     {
-      DECL_EXTERNAL (m_inner_fndecl) = 0;
-      TREE_PUBLIC (m_inner_fndecl) = 0;
+        if (!DECL_WEAK (m_inner_fndecl))
+        {
+            DECL_EXTERNAL (m_inner_fndecl) = 0;
+            TREE_PUBLIC (m_inner_fndecl) = 0;
+        }
     }
 
   if (m_kind != GCC_JIT_FUNCTION_IMPORTED)
@@ -2290,7 +2301,8 @@
 playback::block::
 add_try_catch (location *loc,
          block *try_block,
-         block *catch_block)
+         block *catch_block,
+         bool is_finally)
 {
   gcc_assert (try_block);
   gcc_assert (catch_block);
@@ -2318,8 +2330,38 @@
     append_to_statement_list (catch_stmt, &catch_body);
   }
 
-  add_stmt (build2 (TRY_CATCH_EXPR, void_type_node,
+  if (is_finally)
+  {
+    tree noop = build_int_cst (integer_type_node, 0);
+    tree stmt = build1 (NOP_EXPR, void_type_node, size_zero_node);
+    tree success_body = alloc_stmt_list ();
+    //append_to_statement_list (stmt, &success_body);
+
+
+  tree t_string = build_string ("nop");
+  tree asm_stmt
+    = build5 (ASM_EXPR, void_type_node, t_string, NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
+
+  // asm statements without outputs, including simple ones, are treated
+  //   as volatile.
+  ASM_VOLATILE_P (asm_stmt) = 1;
+  ASM_INPUT_P (asm_stmt) = 0;
+    append_to_statement_list (asm_stmt, &success_body);
+    //debug_tree (success_body);
+
+    catch_body = build2 (EH_ELSE_EXPR, void_type_node, success_body, catch_body);
+    add_stmt (build2 (TRY_FINALLY_EXPR, void_type_node,
             try_body, catch_body));
+  }
+  else
+  {
+    catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
+    tree try_catch = build2 (TRY_CATCH_EXPR, void_type_node,
+            try_body, catch_body);
+    //if (is_finally)
+    //  TRY_CATCH_IS_CLEANUP (try_catch) = true;
+    add_stmt (try_catch);
+  }
 }
 
 /* Add an assignment to the function's statement list.  */
diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h
index 75fb21b..83021bb 100644
--- a/gcc/jit/jit-playback.h
+++ b/gcc/jit/jit-playback.h
@@ -113,8 +113,7 @@
 		enum built_in_function builtin_id,
 		int is_target_builtin,
 		const std::vector<gcc_jit_fn_attribute> &attributes,
-		const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &string_attributes,
-		function *personality_function);
+		const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &string_attributes);
 
   lvalue *
   new_global (location *loc,
@@ -537,6 +536,9 @@
   get_address (location *loc);
 
   void
+  set_personality_function (function *personality_function);
+
+  void
   build_stmt_list ();
 
   void
@@ -609,7 +611,8 @@
   void
   add_try_catch (location *loc,
 		 block *try_block,
-		 block *catch_block);
+		 block *catch_block,
+		 bool is_finally);
 
   void
   add_assignment (location *loc,
diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc
index ba87421..c5420c5 100644
--- a/gcc/jit/jit-recording.cc
+++ b/gcc/jit/jit-recording.cc
@@ -4180,8 +4180,7 @@
   m_fn_ptr_type (NULL),
   m_is_target_builtin (is_target_builtin),
   m_attributes(),
-  m_string_attributes(),
-  m_personality_function (NULL)
+  m_string_attributes()
 {
   for (int i = 0; i< num_params; i++)
     {
@@ -4234,12 +4233,6 @@
   FOR_EACH_VEC_ELT (m_params, i, param)
     params.safe_push (param->playback_param ());
 
-  playback::function *personality_function = NULL;
-  if (m_personality_function)
-  {
-    personality_function = m_personality_function->playback_function ();
-  }
-
   set_playback_obj (r->new_function (playback_location (r, m_loc),
 				     m_kind,
 				     m_return_type->playback_type (),
@@ -4249,14 +4242,37 @@
 				     m_builtin_id,
 				     m_is_target_builtin,
 				     m_attributes,
-				     m_string_attributes,
-				     personality_function));
+				     m_string_attributes));
+}
+
+/* Implementation of recording::memento::make_debug_string for
+   setting a personality function.  */
+
+recording::string *
+recording::memento_of_set_personality_function::make_debug_string ()
+{
+  return string::from_printf (m_ctxt,
+			      "%s",
+			      m_personality_function->get_debug_string ());
+}
+
+/* Implementation of recording::memento::write_reproducer for setting the personality function. */
+
+void
+recording::memento_of_set_personality_function::write_reproducer (reproducer &r)
+{
+  r.write ("    gcc_jit_function_set_personality_function (%s,\n"
+	   "                                               %s);\n",
+	   r.get_identifier (m_function),
+	   r.get_identifier (m_personality_function));
 }
 
 void
 recording::function::set_personality_function (function *function)
 {
-  m_personality_function = function;
+  recording::memento_of_set_personality_function *result =
+    new memento_of_set_personality_function (m_ctxt, this, function);
+  m_ctxt->record (result);
 }
 
 /* Create a recording::local instance and add it to
@@ -4613,9 +4629,10 @@
 recording::statement *
 recording::block::add_try_catch (location *loc,
                    block *try_block,
-                   block *catch_block)
+                   block *catch_block,
+                   bool is_finally)
 {
-  statement *result = new try_catch (this, loc, try_block, catch_block);
+  statement *result = new try_catch (this, loc, try_block, catch_block, is_finally);
   //try_block->m_has_been_terminated = true;
   //catch_block->m_has_been_terminated = true;
   try_block->m_is_reachable = true;
@@ -7041,6 +7058,17 @@
     m_loc = d.make_location ();
 }
 
+/* The implementation of class gcc::jit::recording::memento_of_set_personality_function.  */
+
+/* Implementation of pure virtual hook recording::memento::replay_into
+   for recording::memento_of_set_personality_function.  */
+
+void
+recording::memento_of_set_personality_function::replay_into (replayer *r)
+{
+  m_function->playback_function ()->set_personality_function (m_personality_function->playback_function ());
+}
+
 /* The implementation of class gcc::jit::recording::eval.  */
 
 /* Implementation of pure virtual hook recording::memento::replay_into
@@ -7090,7 +7118,8 @@
   playback_block (get_block ())
     ->add_try_catch (playback_location (r),
         m_try_block->playback_block (),
-        m_catch_block->playback_block ());
+        m_catch_block->playback_block (),
+        m_is_finally);
 }
 
 /* Implementation of recording::memento::make_debug_string for
@@ -7099,6 +7128,7 @@
 recording::string *
 recording::try_catch::make_debug_string ()
 {
+    // TODO: handle m_is_finally.
   return string::from_printf (m_ctxt,
                   "try { %s } catch { %s };",
                   m_try_block->get_debug_string (),
@@ -7111,6 +7141,7 @@
 void
 recording::try_catch::write_reproducer (reproducer &r)
 {
+    // TODO: handle m_is_finally.
   r.write ("  gcc_jit_block_add_try_catch (%s, /*gcc_jit_block *block */\n"
        "                                 %s, /* gcc_jit_location *loc */\n"
        "                                 %s, /* gcc_jit_block *try_block */\n"
diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
index 246bf3e..547f5de 100644
--- a/gcc/jit/jit-recording.h
+++ b/gcc/jit/jit-recording.h
@@ -1465,7 +1465,6 @@
   int m_is_target_builtin;
   std::vector<gcc_jit_fn_attribute> m_attributes;
   std::vector<std::pair<gcc_jit_fn_attribute, std::string>> m_string_attributes;
-  function *m_personality_function;
 };
 
 class block : public memento
@@ -1497,7 +1496,8 @@
   statement *
   add_try_catch (location *loc,
 		 block *try_block,
-		 block *catch_block);
+		 block *catch_block,
+		 bool is_finally = false);
 
   statement *
   add_assignment (location *loc,
@@ -1714,6 +1714,27 @@
   string *m_value;
 };
 
+class memento_of_set_personality_function : public memento
+{
+public:
+  memento_of_set_personality_function (context *ctx,
+				       function *func,
+				       function *personality_function)
+  : memento(ctx),
+    m_function (func),
+    m_personality_function (personality_function) {}
+
+  void replay_into (replayer *r) final override;
+
+private:
+  string * make_debug_string () final override;
+  void write_reproducer (reproducer &r) final override;
+
+private:
+  function *m_function;
+  function *m_personality_function;
+};
+
 class memento_of_new_rvalue_from_vector : public rvalue
 {
 public:
@@ -2357,10 +2378,12 @@
   try_catch (block *b,
     location *loc,
     block *try_block,
-    block *catch_block)
+    block *catch_block,
+    bool is_finally = false)
   : statement (b, loc),
     m_try_block (try_block),
-    m_catch_block (catch_block) {}
+    m_catch_block (catch_block),
+    m_is_finally (is_finally) {}
 
   void replay_into (replayer *r) final override;
 
@@ -2371,6 +2394,7 @@
 private:
   block *m_try_block;
   block *m_catch_block;
+  bool m_is_finally;
 };
 
 class assignment : public statement
diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc
index 16c8208..98cd254 100644
--- a/gcc/jit/libgccjit.cc
+++ b/gcc/jit/libgccjit.cc
@@ -2967,6 +2967,34 @@
 }
 
 /* Public entrypoint.  See description in libgccjit.h.
+   After error-checking, the real work is done by the
+   gcc::jit::recording::block::add_try_catch method in jit-recording.c.  */
+
+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)
+{
+  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");
+
+  gcc::jit::recording::statement *stmt = block->add_try_catch (loc, try_block, finally_block, true);
+
+  /* "stmt" should be good enough to be usable in error-messages,
+     but might still not be compilable; perform some more
+     error-checking here.  We do this here so that the error messages
+     can contain a stringified version of "stmt", whilst appearing
+     as close as possible to the point of failure.  */
+  /*try_block->verify_valid_within_stmt (__func__, stmt);
+  catch_block->verify_valid_within_stmt (__func__, stmt);*/
+}
+
+/* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, the real work is done by the
    gcc::jit::recording::block::add_assignment method in
diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
index 1fd5c87..399e5c8 100644
--- a/gcc/jit/libgccjit.h
+++ b/gcc/jit/libgccjit.h
@@ -1427,7 +1427,7 @@
      try {
         try_block
      }
-     catch {
+     catch (...) {
         catch_block
      }
 */
@@ -1438,6 +1438,22 @@
 			     gcc_jit_block *try_block,
 			     gcc_jit_block *catch_block);
 
+/* Add a try/finally statement.
+   This is equivalent to this C++-like code:
+     try {
+        try_block
+     }
+     finally {
+        finally_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);
+
 /* Add evaluation of an rvalue, assigning the result to the given
    lvalue.
 
diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map
index a1fc114..4d6a6ca 100644
--- a/gcc/jit/libgccjit.map
+++ b/gcc/jit/libgccjit.map
@@ -314,5 +314,6 @@
 LIBGCCJIT_ABI_32 {
   global:
     gcc_jit_block_add_try_catch;
+    gcc_jit_block_add_try_finally;
     gcc_jit_function_set_personality_function;
 } LIBGCCJIT_ABI_31;
diff --git a/gcc/toplev.cc b/gcc/toplev.cc
index 61d234a..9456c95 100644
--- a/gcc/toplev.cc
+++ b/gcc/toplev.cc
@@ -2353,6 +2353,7 @@
   cgraphunit_cc_finalize ();
   symtab_thunks_cc_finalize ();
   dwarf2out_cc_finalize ();
+  dwarf2asm_cc_finalize ();
   gcse_cc_finalize ();
   ipa_cp_cc_finalize ();
   ira_costs_cc_finalize ();
diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc
index 076ecd3..38b8ea8 100644
--- a/gcc/tree-eh.cc
+++ b/gcc/tree-eh.cc
@@ -4882,7 +4882,11 @@
      and avoids references to a never defined personality routine.  */
   if (DECL_FUNCTION_PERSONALITY (current_function_decl)
       && function_needs_eh_personality (fun) != eh_personality_lang)
-    DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE;
+  {
+      //fprintf(stderr, "Unset personality function for %s\n", IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
+      // TODO: uncomment:
+    //DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE;
+  }
 
   return ret;
 }
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 007c932..0388284 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -14766,6 +14766,7 @@
 tree_cc_finalize (void)
 {
   clear_nonstandard_integer_type_cache ();
+  gcc_eh_personality_decl = NULL;
 }
 
 #if CHECKING_P