Add some more casts (1/2)

[deliverable/binutils-gdb.git] / gdb / break-catch-throw.c

diff --git a/gdb/break-catch-throw.c b/gdb/break-catch-throw.c
index 72834902f0ca6a0d827223cf7b7297a0995f0a84..1ba505b6e49071c0752763e28c04c2d5624b5ec6 100644 (file)
--- a/gdb/break-catch-throw.c
+++ b/gdb/break-catch-throw.c
@@ -1,6 +1,6 @@
 /* Everything about catch/throw catchpoints, for GDB.
 
-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -29,13 +29,13 @@
 #include "completer.h"
 #include "gdb_obstack.h"
 #include "mi/mi-common.h"
-#include "exceptions.h"
 #include "linespec.h"
 #include "probe.h"
 #include "objfiles.h"
 #include "cp-abi.h"
 #include "gdb_regex.h"
 #include "cp-support.h"
+#include "location.h"
 
 /* Enums for exception-handling support.  */
 enum exception_event_kind
@@ -163,8 +163,7 @@ check_status_exception_catchpoint (struct bpstats *bs)
 {
   struct exception_catchpoint *self
     = (struct exception_catchpoint *) bs->breakpoint_at;
-  char *typename = NULL;
-  volatile struct gdb_exception e;
+  char *type_name = NULL;
 
   bkpt_breakpoint_ops.check_status (bs);
   if (bs->stop == 0)
@@ -173,28 +172,34 @@ check_status_exception_catchpoint (struct bpstats *bs)
   if (self->pattern == NULL)
     return;
 
-  TRY_CATCH (e, RETURN_MASK_ERROR)
+  TRY
     {
       struct value *typeinfo_arg;
       char *canon;
 
       fetch_probe_arguments (NULL, &typeinfo_arg);
-      typename = cplus_typename_from_type_info (typeinfo_arg);
+      type_name = cplus_typename_from_type_info (typeinfo_arg);
 
-      canon = cp_canonicalize_string (typename);
+      canon = cp_canonicalize_string (type_name);
       if (canon != NULL)
        {
-         xfree (typename);
-         typename = canon;
+         xfree (type_name);
+         type_name = canon;
        }
     }
+  CATCH (e, RETURN_MASK_ERROR)
+    {
+      exception_print (gdb_stderr, e);
+    }
+  END_CATCH
 
-  if (e.reason < 0)
-    exception_print (gdb_stderr, e);
-  else if (regexec (self->pattern, typename, 0, NULL, 0) != 0)
-    bs->stop = 0;
+  if (type_name != NULL)
+    {
+      if (regexec (self->pattern, type_name, 0, NULL, 0) != 0)
+       bs->stop = 0;
 
-  xfree (typename);
+      xfree (type_name);
+    }
 }
 
 /* Implement the 're_set' method.  */
@@ -204,33 +209,46 @@ re_set_exception_catchpoint (struct breakpoint *self)
 {
   struct symtabs_and_lines sals = {0};
   struct symtabs_and_lines sals_end = {0};
-  volatile struct gdb_exception e;
   struct cleanup *cleanup;
   enum exception_event_kind kind = classify_exception_breakpoint (self);
-  int pass;
+  struct event_location *location;
 
-  for (pass = 0; sals.sals == NULL && pass < 2; ++pass)
+  /* We first try to use the probe interface.  */
+  TRY
     {
-      TRY_CATCH (e, RETURN_MASK_ERROR)
+      location
+       = new_probe_location (exception_functions[kind].probe);
+      cleanup = make_cleanup_delete_event_location (location);
+      sals = parse_probes (location, NULL);
+      do_cleanups (cleanup);
+    }
+
+  CATCH (e, RETURN_MASK_ERROR)
+    {
+      /* Using the probe interface failed.  Let's fallback to the normal
+        catchpoint mode.  */
+      TRY
+       {
+         struct explicit_location explicit_loc;
+
+         initialize_explicit_location (&explicit_loc);
+         explicit_loc.function_name
+           = ASTRDUP (exception_functions[kind].function);
+         location = new_explicit_location (&explicit_loc);
+         cleanup = make_cleanup_delete_event_location (location);
+         self->ops->decode_location (self, location, &sals);
+         do_cleanups (cleanup);
+       }
+      CATCH (ex, RETURN_MASK_ERROR)
        {
-         char *spec;
-
-         if (pass == 0)
-           {
-             spec = ASTRDUP (exception_functions[kind].probe);
-             sals = parse_probes (&spec, NULL);
-           }
-         else
-           {
-             spec = ASTRDUP (exception_functions[kind].function);
-             self->ops->decode_linespec (self, &spec, &sals);
-           }
+         /* NOT_FOUND_ERROR just means the breakpoint will be
+            pending, so let it through.  */
+         if (ex.error != NOT_FOUND_ERROR)
+           throw_exception (ex);
        }
-      /* NOT_FOUND_ERROR just means the breakpoint will be pending, so
-        let it through.  */
-      if (e.reason < 0 && e.error != NOT_FOUND_ERROR)
-       throw_exception (e);
+      END_CATCH
     }
+  END_CATCH
 
   cleanup = make_cleanup (xfree, sals.sals);
   update_breakpoint_locations (self, sals, sals_end);