PNaCl SJLJ EH: Fix handling of dependent exceptions

libstdc++-v3/libsupc++/eh_pnacl.cc

 // -*- C++ -*- Exception handling routines for PNaCl.
 // Copyright (C) 2013
 // 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.
@@ skipping 222 matching lines @@
 // UE_HEADER to __cxa_exception immediately.
 //
 // This function returns if stack unwinding did not find any stack
 // frames that match the exception being thrown.
 static void
 handle_exception (struct _Unwind_Exception *ue_header, bool check_for_catch)
 {
   __cxa_exception *xh = __get_exception_header_from_ue (ue_header);
 
   void *obj = __get_object_from_ue (ue_header);
+  // We must get exceptionType via OBJ rather than from XH in order to
+  // handle dependent exceptions.
+  const std::type_info *throw_type =
+      __get_exception_header_from_obj (obj)->exceptionType;
   struct exception_frame *frame;
   int32_t clause_id;
-  if (find_match (xh->exceptionType, &obj, __pnacl_eh_stack,
-                  &frame, &clause_id))
+  if (find_match (throw_type, &obj, __pnacl_eh_stack, &frame, &clause_id))
     {
       // Check that there is a non-cleanup handler for the exception.
       // If not, we should abort before running cleanup handlers
       // (i.e. destructors).
       //
       // This is mainly a convenience for debugging.  It means that if
       // the program throws an uncaught exception, the location of the
       // "throw" will be on the stack when the program aborts.  If we
       // ran cleanup handlers before aborting, this context would be
       // lost.
       //
       // This is optional in the C++ standard, which says "If no
       // matching handler is found, the function std::terminate() is
       // called; whether or not the stack is unwound before this call
       // to std::terminate() is implementation-defined".
       if (check_for_catch && clause_id == 0 &&
-          !is_exception_caught (xh->exceptionType, obj, frame->next))
+          !is_exception_caught (throw_type, obj, frame->next))
         return;
 
       __pnacl_eh_stack = frame->next;
 
       // Save adjusted exception pointer so that it can be returned by
       // __cxa_begin_catch() when entering a catch() block.
       xh->adjustedPtr = obj;
 
       // Save the clause ID so that if the landingpad block calls
       // __cxa_call_unexpected() and the std::set_unexpected() handler
@@ skipping 144 matching lines @@
       // If the exception spec allows std::bad_exception, throw that.
       // We don't have a thrown object to compare against, but since
       // bad_exception doesn't have virtual bases, that's OK; just pass 0.
       const std::type_info *bad_exc = &typeid (std::bad_exception);
       if (check_exception_spec (bad_exc, NULL, xh_switch_value))
         throw std::bad_exception ();
 
       __terminate (xh_terminate_handler);
     }
 }