+2019-04-08 Tom Tromey <tom@tromey.com>
+
+ * common/common-exceptions.h (gdb_exception_RETURN_MASK_ALL):
+ Remove.
+ (gdb_exception_error): Rename from
+ gdb_exception_RETURN_MASK_ERROR.
+ (gdb_exception_quit): Rename from gdb_exception_RETURN_MASK_QUIT.
+ (gdb_quit_bad_alloc): Update.
+ * aarch64-tdep.c: Update.
+ * ada-lang.c: Update.
+ * ada-typeprint.c: Update.
+ * ada-valprint.c: Update.
+ * amd64-tdep.c: Update.
+ * arch-utils.c: Update.
+ * break-catch-throw.c: Update.
+ * breakpoint.c: Update.
+ * btrace.c: Update.
+ * c-varobj.c: Update.
+ * cli/cli-cmds.c: Update.
+ * cli/cli-interp.c: Update.
+ * cli/cli-script.c: Update.
+ * common/common-exceptions.c: Update.
+ * common/new-op.c: Update.
+ * common/selftest.c: Update.
+ * compile/compile-c-symbols.c: Update.
+ * compile/compile-cplus-symbols.c: Update.
+ * compile/compile-object-load.c: Update.
+ * compile/compile-object-run.c: Update.
+ * completer.c: Update.
+ * corelow.c: Update.
+ * cp-abi.c: Update.
+ * cp-support.c: Update.
+ * cp-valprint.c: Update.
+ * darwin-nat.c: Update.
+ * disasm-selftests.c: Update.
+ * dtrace-probe.c: Update.
+ * dwarf-index-cache.c: Update.
+ * dwarf-index-write.c: Update.
+ * dwarf2-frame-tailcall.c: Update.
+ * dwarf2-frame.c: Update.
+ * dwarf2loc.c: Update.
+ * dwarf2read.c: Update.
+ * eval.c: Update.
+ * event-loop.c: Update.
+ * event-top.c: Update.
+ * exec.c: Update.
+ * f-valprint.c: Update.
+ * fbsd-tdep.c: Update.
+ * frame-unwind.c: Update.
+ * frame.c: Update.
+ * gdbtypes.c: Update.
+ * gnu-v3-abi.c: Update.
+ * guile/guile-internal.h: Update.
+ * guile/scm-block.c: Update.
+ * guile/scm-breakpoint.c: Update.
+ * guile/scm-cmd.c: Update.
+ * guile/scm-disasm.c: Update.
+ * guile/scm-frame.c: Update.
+ * guile/scm-lazy-string.c: Update.
+ * guile/scm-math.c: Update.
+ * guile/scm-param.c: Update.
+ * guile/scm-ports.c: Update.
+ * guile/scm-pretty-print.c: Update.
+ * guile/scm-symbol.c: Update.
+ * guile/scm-symtab.c: Update.
+ * guile/scm-type.c: Update.
+ * guile/scm-value.c: Update.
+ * i386-linux-tdep.c: Update.
+ * i386-tdep.c: Update.
+ * inf-loop.c: Update.
+ * infcall.c: Update.
+ * infcmd.c: Update.
+ * infrun.c: Update.
+ * jit.c: Update.
+ * language.c: Update.
+ * linespec.c: Update.
+ * linux-fork.c: Update.
+ * linux-nat.c: Update.
+ * linux-tdep.c: Update.
+ * linux-thread-db.c: Update.
+ * main.c: Update.
+ * mi/mi-cmd-break.c: Update.
+ * mi/mi-cmd-stack.c: Update.
+ * mi/mi-interp.c: Update.
+ * mi/mi-main.c: Update.
+ * objc-lang.c: Update.
+ * p-valprint.c: Update.
+ * parse.c: Update.
+ * ppc-linux-tdep.c: Update.
+ * printcmd.c: Update.
+ * python/py-arch.c: Update.
+ * python/py-breakpoint.c: Update.
+ * python/py-cmd.c: Update.
+ * python/py-finishbreakpoint.c: Update.
+ * python/py-frame.c: Update.
+ * python/py-framefilter.c: Update.
+ * python/py-gdb-readline.c: Update.
+ * python/py-inferior.c: Update.
+ * python/py-infthread.c: Update.
+ * python/py-lazy-string.c: Update.
+ * python/py-linetable.c: Update.
+ * python/py-objfile.c: Update.
+ * python/py-param.c: Update.
+ * python/py-prettyprint.c: Update.
+ * python/py-progspace.c: Update.
+ * python/py-record-btrace.c: Update.
+ * python/py-record.c: Update.
+ * python/py-symbol.c: Update.
+ * python/py-type.c: Update.
+ * python/py-unwind.c: Update.
+ * python/py-utils.c: Update.
+ * python/py-value.c: Update.
+ * python/python.c: Update.
+ * record-btrace.c: Update.
+ * record-full.c: Update.
+ * remote-fileio.c: Update.
+ * remote.c: Update.
+ * riscv-tdep.c: Update.
+ * rs6000-aix-tdep.c: Update.
+ * rs6000-tdep.c: Update.
+ * rust-exp.y: Update.
+ * rust-lang.c: Update.
+ * s390-tdep.c: Update.
+ * selftest-arch.c: Update.
+ * solib-dsbt.c: Update.
+ * solib-frv.c: Update.
+ * solib-spu.c: Update.
+ * solib-svr4.c: Update.
+ * solib.c: Update.
+ * sparc64-linux-tdep.c: Update.
+ * stack.c: Update.
+ * symfile-mem.c: Update.
+ * symmisc.c: Update.
+ * target.c: Update.
+ * thread.c: Update.
+ * top.c: Update.
+ * tracefile-tfile.c: Update.
+ * tui/tui.c: Update.
+ * typeprint.c: Update.
+ * unittests/cli-utils-selftests.c: Update.
+ * unittests/parse-connection-spec-selftests.c: Update.
+ * valops.c: Update.
+ * valprint.c: Update.
+ * value.c: Update.
+ * varobj.c: Update.
+ * windows-nat.c: Update.
+ * x86-linux-nat.c: Update.
+ * xml-support.c: Update.
+
2019-04-08 Tom Tromey <tom@tromey.com>
* xml-support.c: Use C++ exception handling.
{
aarch64_make_prologue_cache_1 (this_frame, cache);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
cache->prev_pc = get_frame_pc (this_frame);
cache->available_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
offset_to_top = value_as_long (value_ind (value_ptradd (val, -2)));
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
return obj;
}
if (tsd != NULL)
name = ada_tag_name_from_tsd (tsd);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
}
{
xvz_found = get_int_var_value (xvz_name, size);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* We found the variable, but somehow failed to read
its value. Rethrow the same error, but with a little
{
e_msg = ada_exception_message_1 ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
e_msg.reset (nullptr);
}
result = ada_exception_name_addr_1 (ex, b);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
warning (_("failed to get exception name: %s"), e.what ());
return 0;
block_for_pc (bl->address),
0);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
warning (_("failed to reevaluate internal exception condition "
"for catchpoint %d: %s"),
stop = value_true (evaluate_expression (ada_loc->excep_cond_expr.get ()));
value_free_to_mark (mark);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
_("Error in testing exception condition:\n"));
lo = ada_discrete_type_low_bound (type);
hi = ada_discrete_type_high_bound (type);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
/* This can happen when the range is dynamic. Sometimes,
resolving dynamic property values requires us to have
stream, recurse, val, options,
current_language);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
fprintf_filtered (stream, _("<error reading variable: %s>"),
except.what ());
{
amd64_frame_cache_1 (this_frame, cache);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
cache->base_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
cache->base_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
{
new_pc = gdbarch_skip_prologue (gdbarch, pc);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{}
return new_pc;
if (!canon.empty ())
std::swap (type_name, canon);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_print (gdb_stderr, e);
}
= new_probe_location (exception_functions[kind].probe);
sals = parse_probes (location.get (), filter_pspace, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
/* Using the probe interface failed. Let's fallback to the normal
catchpoint mode. */
sals = self->ops->decode_location (self, location.get (),
filter_pspace);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* NOT_FOUND_ERROR just means the breakpoint will be
pending, so let it through. */
aexpr = gen_eval_for_expr (scope, cond);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* If we got here, it means the condition could not be parsed to a valid
bytecode expression and thus can't be evaluated on the target's side.
format_start, format_end - format_start,
argvec.size (), argvec.data ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* If we got here, it means the command could not be parsed to a valid
bytecode expression and thus can't be evaluated on the target's side.
if (val)
bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
bp_excpt = e;
}
bp_excpt
= gdb_exception {RETURN_ERROR, GENERIC_ERROR};
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
bp_excpt = e;
}
if (val)
bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
bp_excpt = e;
}
{
e = watchpoint_check (bs);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
"Error evaluating expression "
{
condition_result = breakpoint_cond_eval (cond);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
"Error in testing breakpoint condition:\n");
{
ops->create_sals_from_location (location, &canonical, type_wanted);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
/* If caller is interested in rc value from parse, set
value. */
{
update_global_location_list (insert_mode);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
}
}
block_for_pc (sal.pc),
0);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
warning (_("failed to reevaluate condition "
"for breakpoint %d: %s"),
{
sals = b->ops->decode_location (b, location, search_pspace);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
int not_found_and_ok = 0;
{
breakpoint_re_set_one (b);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
"Error in re-setting breakpoint %d: ",
bpt->enable_state = bp_enabled;
update_watchpoint (w, 1 /* reparse */);
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
bpt->enable_state = orig_enable_state;
exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
{
print_command_lines (current_uiout, tp->commands.get (), 2);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
current_uiout->redirect (NULL);
throw_exception (ex);
else if (gdbarch_insn_is_jump (gdbarch, pc))
iclass = BTRACE_INSN_JUMP;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &error)
+ catch (const gdb_exception_error &error)
{
}
{
size = gdb_insn_length (gdbarch, pc);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &error)
+ catch (const gdb_exception_error &error)
{
}
if (errcode != 0)
result = -pte_nomap;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &error)
+ catch (const gdb_exception_error &error)
{
result = -pte_nomap;
}
ftrace_add_pt (btinfo, decoder, &level, gaps);
}
- catch (const gdb_exception_RETURN_MASK_ALL &error)
+ catch (const gdb_exception &error)
{
/* Indicate a gap in the trace if we quit trace processing. */
if (error.reason == RETURN_QUIT && !btinfo->functions.empty ())
{
btrace_compute_ftrace_1 (tp, btrace, cpu, gaps);
}
- catch (const gdb_exception_RETURN_MASK_ALL &error)
+ catch (const gdb_exception &error)
{
btrace_finalize_ftrace (tp, gaps);
&& can_access_registers_thread (tp))
btrace_add_pc (tp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
btrace_disable (tp);
{
btrace_maint_decode_pt (&btinfo->maint, decoder);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
pt_pkt_free_decoder (decoder);
*value = value_ind (*value);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
*value = NULL;
}
else
result = value_primitive_field (value, 0, type_index, type);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
return NULL;
}
{
*cvalue = value_subscript (value, real_index);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
}
}
*cvalue = value_ind (value);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
*cvalue = NULL;
}
tracker = &tracker_handle_completions;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
return;
}
{
execute_command (command, from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
e = exception;
}
{
validator ((*command)->line);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
free_command_lines (command);
throw_exception (ex);
{
read_command_file (stream);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
/* Re-throw the error, but with the file name information
prepended. */
{
if (exception.reason == RETURN_QUIT)
{
- gdb_exception_RETURN_MASK_QUIT ex (exception);
+ gdb_exception_quit ex (exception);
throw ex;
}
else if (exception.reason == RETURN_ERROR)
{
- gdb_exception_RETURN_MASK_ERROR ex (exception);
+ gdb_exception_error ex (exception);
throw ex;
}
else
around gdb_exception that add nothing but type info. Which is used
is selected depending on the MASK argument passed to CATCH. */
-struct gdb_exception_RETURN_MASK_ALL : public gdb_exception
+struct gdb_exception_error : public gdb_exception
{
- explicit gdb_exception_RETURN_MASK_ALL (const gdb_exception &ex) noexcept
+ explicit gdb_exception_error (const gdb_exception &ex) noexcept
: gdb_exception (ex)
{
}
};
-struct gdb_exception_RETURN_MASK_ERROR : public gdb_exception_RETURN_MASK_ALL
+struct gdb_exception_quit : public gdb_exception
{
- explicit gdb_exception_RETURN_MASK_ERROR (const gdb_exception &ex) noexcept
- : gdb_exception_RETURN_MASK_ALL (ex)
- {
- }
-};
-
-struct gdb_exception_RETURN_MASK_QUIT : public gdb_exception_RETURN_MASK_ALL
-{
- explicit gdb_exception_RETURN_MASK_QUIT (const gdb_exception &ex) noexcept
- : gdb_exception_RETURN_MASK_ALL (ex)
+ explicit gdb_exception_quit (const gdb_exception &ex) noexcept
+ : gdb_exception (ex)
{
}
};
spread around the codebase. */
struct gdb_quit_bad_alloc
- : public gdb_exception_RETURN_MASK_QUIT,
+ : public gdb_exception_quit,
public std::bad_alloc
{
explicit gdb_quit_bad_alloc (const gdb_exception &ex) noexcept
- : gdb_exception_RETURN_MASK_QUIT (ex),
+ : gdb_exception_quit (ex),
std::bad_alloc ()
{
}
{
malloc_failure (sz);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
throw gdb_quit_bad_alloc (ex);
}
++ran;
(*test) ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
++failed;
debug_printf ("Self test failed: %s\n", ex.what ());
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
context->plugin ().error (e.what ());
}
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
context->plugin ().error (e.what ());
}
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
compiler->insert_symbol_error (sym, e.what ());
}
}
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
/* We can't allow exceptions to escape out of this callback. Safest
is to simply emit a gcc error. */
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
instance->plugin ().error (e.what ());
}
{
gdbarch_infcall_munmap (target_gdbarch (), item.addr, item.size);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* There's not much the user can do, so just ignore
this. */
call_function_by_hand_dummy (func_val, NULL, args,
do_module_cleanup, data);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* In the case of DTOR_FOUND or in the case of EXECUTED nothing
needs to be done. */
{
type = parse_expression_for_completion (text, &fieldname, &code);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
return;
}
{
complete_line_internal_1 (tracker, text, line_buffer, point, reason);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (except.error != MAX_COMPLETIONS_REACHED_ERROR)
throw_exception (except);
{
return gdb_completion_word_break_characters_throw ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Set this to that gdb_rl_attempted_completion_function knows
to abort early. */
{
return gdb_rl_attempted_completion_function_throw (text, start, end);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
}
target_update_thread_list ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
exception_print (gdb_stderr, except);
}
{
thread_command (NULL, from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
exception_print (gdb_stderr, except);
}
embedded_offset,
address, val);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
{
ret = (*current_cp_abi.rtti_type) (v, full, top, using_enc);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
return NULL;
}
{
sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
return 0;
}
}
/* If type_print threw an exception, there is little point
in continuing, so just bow out gracefully. */
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
return 0;
}
sym = lookup_symbol (local_name.get (), 0,
VAR_DOMAIN, 0).symbol;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
v = value_static_field (type, i);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
fprintf_filtered (stream,
_("<error reading variable: %s>"),
{
boffset = baseclass_offset (type, i, valaddr, offset, address, val);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
skip = -1;
darwin_setup_exceptions (inf);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exit_inferior (inf);
inferior_ptid = null_ptid;
{
copy_shell_to_cache (shell, new_name);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
warning (_("This version of macOS has System Integrity Protection.\n\
Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
{
di.print_insn (0);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == MEMORY_ERROR)
saw_memory_error = true;
expr = parse_expression_with_language (type_str.c_str (),
language_c);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
}
write_psymtabs_to_index (dwarf2_per_objfile, m_dir.c_str (),
build_id_str.c_str (), dw_index_kind::GDB_INDEX);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (debug_index_cache)
printf_unfiltered ("index cache: couldn't store index cache for objfile "
((const gdb_byte *) mmap_resource->mapping.get (),
mmap_resource->mapping.size ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (debug_index_cache)
printf_unfiltered ("index cache: couldn't read %s: %s\n",
write_psymtabs_to_index (dwarf2_per_objfile, arg, basename,
index_kind);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
exception_fprintf (gdb_stderr, except,
_("Error while writing index for `%s': "),
}
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (entry_values_debug)
exception_print (gdb_stdout, except);
internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
EH_CIE_OR_FDE_TYPE_ID);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
warning (_("skipping .eh_frame info of %s: %s"),
objfile_name (objfile), e.what ());
&cie_table, &fde_table,
EH_CIE_OR_FDE_TYPE_ID);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
warning (_("skipping .debug_frame info of %s: %s"),
objfile_name (objfile), e.what ());
{
retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
if (e.error == NO_ENTRY_VALUE_ERROR)
{
{
ctx.eval (data, size);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
{
ctx.eval (dlbaton->data, dlbaton->size);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
/* (maybe) store an index in the cache. */
global_index_cache.store (dwarf2_per_objfile);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
exception_print (gdb_stderr, except);
}
{
result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Ignore memory errors if we want watchpoints pointing at
inaccessible memory to still be created; otherwise, throw the
value_fetch_lazy (result);
*valp = result;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
}
}
ret = value_of_variable (var, blk);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (noside != EVAL_AVOID_SIDE_EFFECTS)
throw_exception (except);
value = value_x_unop (arg2, op, noside);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (except.error == NOT_FOUND_ERROR)
break;
value = value_x_unop (arg1, op, noside);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (except.error == NOT_FOUND_ERROR)
break;
{
result = gdb_do_one_event ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
{
ui->input_handler (gdb::unique_xmalloc_ptr<char> (rl));
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
gdb_rl_expt = ex;
}
quit_cover ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
fputs_filtered ("Could not kill the program being debugged",
gdb_stderr);
{
pop_all_targets ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
}
exec_file_attach will clear state. */
exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &err)
+ catch (const gdb_exception_error &err)
{
if (err.message != NULL)
warning ("%s", err.what ());
{
symbol_file_add_main (exec_file_host, add_flags);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &err)
+ catch (const gdb_exception_error &err)
{
if (!exception_print_same (prev_err, err))
warning ("%s", err.what ());
value_print (val, gdb_stdout, &opts);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
printf_filtered ("<error reading variable: %s>",
except.what ());
{
update_thread_list ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_print (gdb_stderr, e);
}
data->rtld_offsets_valid = true;
return;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
data->off_linkmap = -1;
}
data->rtld_offsets_valid = true;
return;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
data->off_linkmap = -1;
}
{
res = unwinder->sniffer (unwinder, this_frame, this_cache);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Catch all exceptions, caused by either interrupt or error.
Reset *THIS_CACHE. */
pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
pc_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
{
prev_frame = NULL;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
prev_frame->next = NULL;
this_frame->prev = NULL;
{
prev_frame = get_prev_frame_always_1 (this_frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == MEMORY_ERROR)
{
{
*pc = frame_unwind_pc (frame->next);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
return 0;
{
*pc = get_frame_address_in_block (this_frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
return 0;
pc = get_frame_address_in_block (frame);
pc_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
+2019-04-08 Tom Tromey <tom@tromey.com>
+
+ * gdbreplay.c: Update.
+ * linux-low.c: Update.
+ * server.c: Update.
+
2019-04-08 Tom Tromey <tom@tromey.com>
* server.c: Use C++ exception handling.
{
captured_main (argc, argv);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
if (exception.reason == RETURN_ERROR)
{
if (the_low_target.prepare_to_resume != NULL)
the_low_target.prepare_to_resume (lwp);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lwp))
throw_exception (ex);
{
linux_resume_one_lwp_throw (lwp, step, signal, info);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lwp))
throw_exception (ex);
write_ok (own_buf);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &exception)
+ catch (const gdb_exception_error &exception)
{
sprintf (own_buf, "E.%s", exception.what ());
}
if (result != 0)
memcpy (cs.own_buf, cache.buffer, cache.used_size);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &exception)
+ catch (const gdb_exception_error &exception)
{
sprintf (cs.own_buf, "E.%s", exception.what ());
result = -1;
if (result != 0)
memcpy (cs.own_buf, cache.buffer, cache.used_size);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &exception)
+ catch (const gdb_exception_error &exception)
{
sprintf (cs.own_buf, "E.%s", exception.what ());
result = -1;
{
detach_or_kill_for_exit ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
fflush (stdout);
fprintf (stderr, "Detach or kill failed: %s\n",
}
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &exception)
+ catch (const gdb_exception_error &exception)
{
fflush (stdout);
fprintf (stderr, "gdbserver: %s\n", exception.what ());
{
captured_main (argc, argv);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
if (exception.reason == RETURN_ERROR)
{
{
type = parse_and_eval_type (p, length);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
type = builtin_type (gdbarch)->builtin_void;
}
{
addr = value_as_address (vfn);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
printf_filtered (_("<error: %s>"), ex.what ());
got_error = 1;
{
result = func (std::forward<Args> (args)...);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (cust != NULL && COMPUNIT_OBJFILE (cust) != NULL)
block = block_for_pc (pc);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
gdb_assert_not_reached ("invalid breakpoint type");
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
delete_breakpoint (bp_smob->bp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
else
disable_breakpoint (bp_smob->bp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
breakpoint_set_silent (bp_smob->bp, gdbscm_is_true (newvalue));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
set_ignore_count (bp_smob->number, (int) value, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
valid_id = valid_task_id (id);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
breakpoint_set_task (bp_smob->bp, id);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
print_command_lines (current_uiout, breakpoint_commands (bp), 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
current_uiout->redirect (NULL);
gdbscm_throw_gdb_exception (except);
c_smob->doc, cmd_list);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
else
insn_len = gdb_print_insn (gdbarch, pc, &buf, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
}
gdbarch = get_frame_arch (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
return gdbscm_scm_from_gdb_exception (except);
}
{
frame = frscm_frame_smob_to_frame (f_smob);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
name = find_frame_funname (frame, &lang, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
type = get_frame_type (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
frame = frscm_frame_smob_to_frame (f_smob);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
frame = frscm_frame_smob_to_frame (f_smob);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
pc = get_frame_pc (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
block = get_frame_block (frame, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
sym = find_pc_function (get_frame_address_in_block (frame));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
prev = get_prev_frame (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
next = get_next_frame (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
sal = find_frame_sal (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
value = value_of_register (regnum, frame);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
frame = frscm_frame_smob_to_frame (f_smob);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
var = lookup_sym.symbol;
block = lookup_sym.block;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
value = read_var_value (var, block, frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (frame != NULL)
select_frame (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
frame = get_current_frame ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
frame = get_selected_frame (_("No frame is currently selected"));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
break;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
*except_scmp = gdbscm_scm_from_gdb_exception (except);
return NULL;
value = NULL;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
except_scm = gdbscm_scm_from_gdb_exception (except);
}
set_list, show_list,
&p_smob->set_command, &p_smob->show_command);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
else
fputsn_filtered ((const char *) data, size, gdb_stdout);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
(_("invalid result from pretty-printer to-string"), result);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
{
result = symbol_read_needs_frame (symbol);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
can happen with nested functions). */
value = read_var_value (symbol, NULL, frame_info);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
selected_frame = get_selected_frame (_("no frame selected"));
block = get_frame_block (selected_frame, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
xfree (name);
GDBSCM_HANDLE_GDB_EXCEPTION (ex);
symbol = lookup_symbol (name, block, (domain_enum) domain,
&is_a_field_of_this).symbol;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
sal = find_pc_line (pc, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
LA_PRINT_TYPE (type, "", &stb, -1, 0, &type_print_raw_options);
return std::move (stb.string ());
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
SCM excp = gdbscm_scm_from_gdb_exception (except);
gdbscm_throw (excp);
{
result = types_deeply_equal (type1, type2);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
if (is_vector)
make_vector_type (array);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = lookup_pointer_type (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = lookup_lvalue_reference_type (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = make_cv_type (1, 0, type, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = make_cv_type (0, 1, type, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = make_cv_type (0, 0, type, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
type = lookup_typename (current_language, get_current_arch (),
type_name, block, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
return NULL;
}
common_val_print (v_smob->value, &stb, 0, &opts, current_language);
scm_puts (stb.c_str (), port);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
result = value_equal (v1_smob->value, v2_smob->value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
address = vlscm_scm_from_value (value_addr (value));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
type = NULL;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
ftype = check_typedef (value_type (function));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
length = TYPE_LENGTH (type);
contents = value_contents (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
else
l = value_as_long (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
else
l = value_as_long (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
check = value_from_longest (type, (LONGEST) d);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
buffer_contents = buffer.release ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
xfree (encoding);
GDBSCM_HANDLE_GDB_EXCEPTION (except);
result = lsscm_make_lazy_string (addr, length, encoding, type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
common_val_print (value, &stb, 0, &opts, current_language);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDBSCM_HANDLE_GDB_EXCEPTION (except);
}
access
= parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
return;
}
{
i386_frame_cache_1 (this_frame, cache);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
cache->base_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
cache->base_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
{
bpstat_do_actions ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
/* If the user was running a foreground execution
command, then propagate the error so that the prompt
target supports asynchronous execution. */
wait_sync_command_done ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
caught_error = e;
}
{
thr->suspend.stop_pc = regcache_read_pc (get_current_regcache ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
delete the breakpoint. */
print_return_value_1 (uiout, rv);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stdout, ex);
}
{
prepared = displaced_step_prepare_throw (thread);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
struct displaced_step_inferior_state *displaced_state;
{
resume_1 (sig);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* If resuming is being aborted for any reason, delete any
single-step breakpoint resume_1 may have created, to avoid
inferior_thread ()->control.exception_resume_breakpoint = bp;
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
/* We want to ignore errors here. */
}
}
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
}
}
{
insert_breakpoints ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_print (gdb_stderr, e);
stop_waiting (ecs);
{
execute_cmd_pre_hook (stop_command);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
"Error while running hook_stop:\n");
{
restore_selected_frame (inf_status->selected_frame_id);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_fprintf (gdb_stderr, ex,
"Unable to restore previously selected frame:\n");
code_entry->symfile_size))
status = 0;
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
status = 0;
}
frame = get_selected_frame (NULL);
flang = get_frame_language (frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
flang = language_unknown;
}
*result->file_symtabs
= symtabs_from_filename (source_filename, self->search_pspace);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
source_file_not_found_error (source_filename);
}
= symtabs_from_filename (user_filename.get (),
PARSER_STATE (parser)->search_pspace);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
file_exception = ex;
}
func_name_match_type,
NULL, unknown_offset);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
return;
}
{
parse_linespec (&parser, text, match_type);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
}
result = parse_linespec (parser,
ls->spec_string, ls->match_type);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
throw_exception (except);
}
/* If successful, we're done. If NOT_FOUND_ERROR
was not thrown, rethrow the exception that we did get. */
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (except.error != NOT_FOUND_ERROR)
throw_exception (except);
fork_load_infrun_state (m_oldfp);
insert_breakpoints ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
warning (_("Couldn't restore checkpoint state in %s: %s"),
target_pid_to_str (m_oldfp->ptid).c_str (),
{
inf_ptrace_target::attach (args, from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
pid_t pid = parse_pid_to_attach (args);
std::string reason = linux_ptrace_attach_fail_reason (pid);
{
linux_target->low_prepare_to_resume (lp);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lp))
throw_exception (ex);
{
linux_resume_one_lwp_throw (lp, step, signo);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lp))
throw_exception (ex);
linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (!check_ptrace_stopped_lwp_gone (lp))
throw_exception (ex);
{
update_thread_list ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_print (gdb_stderr, e);
}
thread_db_find_new_threads_2 (stopped, true);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (libthread_db_debug)
exception_fprintf (gdb_stdlog, except,
if (!tdb_testinfo->threads_seen)
error (_("no threads seen"));
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (warning_pre_print)
fputs_unfiltered (warning_pre_print, gdb_stderr);
TD_SIGNO_MASK,
TD_THR_ANY_USER_FLAGS);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (libthread_db_debug)
{
maybe_wait_sync_command_done (was_sync);
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (const gdb_exception &e)
{
return handle_command_errors (e);
}
{
captured_command_loop ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
captured_main (args);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
print_breakpoint (b);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
common_val_print (arg->val, &stb, 0, &opts,
language_def (SYMBOL_LANGUAGE (arg->sym)));
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
stb.printf (_("<error reading variable: %s>"),
except.what ());
print_breakpoint (bp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
command = mi_parse (cmd, &token);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
mi_print_exception (token, exception);
xfree (token);
{
captured_mi_execute_command (current_uiout, command.get ());
}
- catch (const gdb_exception_RETURN_MASK_ALL &result)
+ catch (const gdb_exception &result)
{
/* Like in start_event_loop, enable input and force display
of the prompt. Otherwise, any command that calls
if (f (pc, new_pc) == 0)
return 1;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
"Unable to determine target of "
{
boffset = baseclass_offset (type, i, valaddr, offset, address, val);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == NOT_AVAILABLE_ERROR)
skip = -1;
{
lang->la_parser (&ps);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
/* If parsing for completion, allow this to succeed; but if no
expression elements have been written, then there's nothing
exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
nullptr, &cstate);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* Nothing, EXP remains NULL. */
}
spe_context_cache_ptid = inferior_ptid;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
return 0;
}
d->exp = parse_expression (d->exp_string, &tracker);
d->block = tracker.block ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Can't re-parse the expression. Disable this display item. */
d->enabled_p = 0;
addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
do_examine (d->format, d->exp->gdbarch, addr);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
fprintf_filtered (gdb_stdout, _("<error: %s>\n"),
ex.what ());
val = evaluate_expression (d->exp.get ());
print_formatted (val, d->format.size, &opts, gdb_stdout);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.what ());
}
function. */
frame = NULL;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
fprintf_filtered (stream, "<error reading variable %s (%s)>", name,
except.what ());
{
insn_len = gdb_print_insn (gdbarch, pc, &stb, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
return NULL;
else
disable_breakpoint (self_bp->bp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_SET_HANDLE_EXCEPTION (except);
}
{
valid_id = valid_task_id (id);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_SET_HANDLE_EXCEPTION (except);
}
{
delete_breakpoint (self_bp->bp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
set_ignore_count (self_bp->number, (int) value, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_SET_HANDLE_EXCEPTION (except);
}
{
set_breakpoint_condition (self_bp->bp, exp, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
print_command_lines (current_uiout, breakpoint_commands (bp), 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
current_uiout->redirect (NULL);
gdbpy_convert_exception (except);
counted_command_line lines = read_command_lines_1 (reader, 1, nullptr);
breakpoint_set_commands (self_bp->bp, std::move (lines));
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
error(_("Do not understand breakpoint type to set."));
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
bppy_pending_object = NULL;
gdbpy_convert_exception (except);
set_cmd_completer_handle_brkchars (cmd,
cmdpy_completer_handle_brkchars);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
xfree (cmd_name);
xfree (docstring);
self_finishbp->return_value = Py_None;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
gdbpy_print_stack ();
disable_breakpoint (bp_obj->bp);
gdb_assert (bp_obj->bp->disposition == disp_del);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
gdbpy_print_stack ();
}
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
return -1;
}
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
/* Just swallow. Either the return type or the function value
remain NULL. */
&bkpt_breakpoint_ops,
0, 1, internal_bp, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_SET_HANDLE_EXCEPTION (except);
}
|| frame_find_by_id (b->frame_id) == NULL))
bpfinishpy_out_of_scope (finish_bp);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
gdbpy_print_stack ();
{
frame = frame_object_to_frame_info (self);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
name = find_frame_funname (frame, &lang, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
type = get_frame_type (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
FRAPY_REQUIRE_VALID (self, frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
FRAPY_REQUIRE_VALID (self, frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
pc = get_frame_pc (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (val == NULL)
PyErr_SetString (PyExc_ValueError, _("Unknown register."));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
FRAPY_REQUIRE_VALID (self, frame);
block = get_frame_block (frame, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
gdb::unique_xmalloc_ptr<char> funname
= find_frame_funname (frame, &funlang, &sym);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
}
frame_obj->gdbarch = get_frame_arch (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
return NULL;
prev = get_prev_frame (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
next = get_next_frame (frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
symtab_and_line sal = find_frame_sal (frame);
sal_obj = symtab_and_line_to_sal_object (sal);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
var = lookup_sym.symbol;
block = lookup_sym.block;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
return NULL;
val = read_var_value (var, block, frame);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
select_frame (fi);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
frame = get_current_frame ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
frame = get_selected_frame ("No frame is currently selected.");
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
gdbarch = get_frame_arch (frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* Let gdb try to print the stack trace. */
return EXT_LANG_BT_NO_FILTERS;
success = py_print_frame (item.get (), flags, args_type, out, 0,
levels_printed.get ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
gdbpy_convert_exception (except);
success = EXT_LANG_BT_ERROR;
p = command_line_input (prompt, "python");
}
/* Handle errors by raising Python exceptions. */
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
/* Detect user interrupt (Ctrl-C). */
if (except.reason == RETURN_QUIT)
{
update_thread_list ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
read_memory (addr, buffer.get (), length);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
write_memory_with_notification (addr, buffer, length);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
buffer, pattern_size,
&found_addr);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
if (thread_info != NULL)
return thread_to_thread_object (thread_info).release ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
switch_to_thread (thread_obj->thread);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
break;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
pcs = find_pcs_for_symtab_line (symtab, py_line, &best_entry);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
build_id = build_id_bfd_get (objfile->obfd);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
symbol_file_add_separate (abfd.get (), file_name, 0, obj->objfile);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
set_doc.get (), show_doc.get (),
doc.get (), set_list, show_list);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
xfree (cmd_name);
Py_DECREF (self);
}
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
{
value = value_copy (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (cust != NULL && COMPUNIT_OBJFILE (cust) != NULL)
block = block_for_pc (pc);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
sal = find_pc_line (pc, 0);
result = symtab_and_line_to_sal_object (sal);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
result = symtab_and_line_to_sal_object (find_pc_line (insn->pc, 0));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
buffer.resize (insn->size);
read_memory (insn->pc, buffer.data (), insn->size);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
gdb_print_insn (target_gdbarch (), insn->pc, &strfile, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
return NULL;
else
target_goto_record (obj->number);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
record_start (method, format, 0);
ret = gdbpy_current_recording (self, args);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
}
{
record_stop (0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
result = symbol_read_needs_frame (symbol);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
can happen with nested functions). */
value = read_var_value (symbol, NULL, frame_info);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
selected_frame = get_selected_frame (_("No frame selected."));
block = get_frame_block (selected_frame, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
symbol = lookup_symbol (name, block, (domain_enum) domain,
&is_a_field_of_this).symbol;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
checked_type = check_typedef (checked_type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (is_vector)
make_vector_type (array);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = lookup_pointer_type (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = lookup_lvalue_reference_type (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = make_cv_type (1, 0, type, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = make_cv_type (0, 1, type, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
type = make_cv_type (0, 0, type, NULL);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
check_typedef (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
{
align = type_align (type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
align = 0;
}
type = lookup_typename (python_language, python_gdbarch,
type_name, block, 0);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
break;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
/* Note -- this is not thread-safe. */
info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (TYPE_IS_REFERENCE (type))
type = check_typedef (TYPE_TARGET_TYPE (type));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
val = value_of_variable (sym, block);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
&type_print_raw_options);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
result = types_deeply_equal (type1, type2);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
/* If there is a GDB exception, a comparison is not capable
(or trusted), so exit. */
rc = 1;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
}
value_print (value, &stb, &opts);
stb.puts (")");
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
sp_str = core_addr_to_string_nz (get_frame_sp (frame));
pc_str = core_addr_to_string_nz (get_frame_pc (frame));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
"Cannot read register %d from frame.",
regnum);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
*addr = value_as_address (value_object_to_value (obj));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_SET_HANDLE_EXCEPTION (except);
}
res_val = value_ind (((value_object *) self)->value);
result = value_to_value_object (res_val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
result = value_to_value_object (res_val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
self_val = ((value_object *) self)->value;
result = value_to_value_object (value_ref (self_val, refcode));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
res_val = make_cv_value (1, 0, self_val);
result = value_to_value_object (res_val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
res_val = value_addr (val_obj->value);
val_obj->address = value_to_value_object (res_val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
val_obj->address = Py_None;
Py_INCREF (Py_None);
type = NULL;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
str_obj = gdbpy_create_lazy_string_object (addr, length, user_encoding,
type);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
common_val_print (((value_object *) self)->value, &stb, 0,
&opts, python_language);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
result = value_to_value_object (res_val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
else
has_field = 0;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_SET_HANDLE_EXCEPTION (except);
}
if (res_val)
result = value_to_value_object (res_val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
ftype = check_typedef (value_type (function));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
gdb::make_array_view (vargs, args_count));
result = value_to_value_object (return_value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
common_val_print (((value_object *) self)->value, &stb, 0,
&opts, python_language);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
opt = value_optimized_out (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
opt = value_lazy (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (value_lazy (value))
value_fetch_lazy (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
result = valpy_binop_throw (opcode, self, other);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
val = value_neg (((value_object *) self)->value);
result = value_to_value_object (val);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
if (value_less (value, value_zero (value_type (value), not_lval)))
isabs = 0;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
/* All other values are True. */
nonzero = 1;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
except = ex;
}
{
val = value_complement (((value_object *) self)->value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
result = valpy_richcompare_throw (self, other, op);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
l = value_as_long (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
l = value_as_long (value);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
else
error (_("Cannot convert value to float."));
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
PyString_AsString (PyObject_Str (obj)));
#endif
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
gdbpy_convert_exception (except);
return NULL;
{
res_val = access_value_history (i);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
res_val = NULL;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
set_internalvar (var, value);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
found = lookup_cmd_composition (newarg.c_str (), &alias, &prefix, &cmd);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
GDB_PY_HANDLE_EXCEPTION (ex);
}
/* Do any commands attached to breakpoint we stopped at. */
bpstat_do_actions ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
sals = def_sal;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* We know this will always throw. */
gdbpy_convert_exception (ex);
gdbpy_allow_threads allow_threads;
result = parse_and_eval (expr_str);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
fprintf_filtered (gdb_stdout, "%s", arg);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
{
begin_line ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
}
fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
type.get (), msg.get ());
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
}
{
btrace_enable (tp, &record_btrace_conf);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &error)
+ catch (const gdb_exception_error &error)
{
warning ("%s", error.what ());
}
{
ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
replay_memory_access = old;
throw_exception (except);
{
ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt, reason);
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
replay_memory_access = old;
throw_exception (except);
{
id = get_frame_id (get_current_frame ());
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
/* Restore the previous execution state. */
set_executing (inferior_ptid, executing);
if (upd_step_stack_frame_id)
tp->control.step_stack_frame_id = frame_id;
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
xfree (btinfo->replay);
btinfo->replay = NULL;
{
execute_command ("target record-btrace", from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
record_btrace_conf.format = BTRACE_FORMAT_NONE;
throw_exception (exception);
{
execute_command ("target record-btrace", from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
record_btrace_conf.format = BTRACE_FORMAT_NONE;
throw_exception (exception);
{
execute_command ("target record-btrace", from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
record_btrace_conf.format = BTRACE_FORMAT_BTS;
{
execute_command ("target record-btrace", from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
record_btrace_conf.format = BTRACE_FORMAT_NONE;
throw_exception (ex);
if (ret < 0)
error (_("Process record: failed to record execution log."));
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
record_full_list_release (record_full_arch_list_tail);
throw_exception (ex);
{
record_full_message (regcache, signal);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
return false;
else
status->value.sig = GDB_SIGNAL_TRAP;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
if (execution_direction == EXEC_REVERSE)
{
record_full_arch_list_add (rec);
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
record_full_list_release (record_full_arch_list_tail);
throw_exception (ex);
{
do_remote_fileio_request (remote, buf);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
if (ex.reason == RETURN_QUIT)
remote_fileio_reply (remote, -1, FILEIO_EINTR);
gdbarch_relocate_instruction (target_gdbarch (), &to, from);
relocated = 1;
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
if (ex.error == MEMORY_ERROR)
{
{
remote->start_remote (from_tty, extended_p);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Pop the partially set up target - unless something else did
already before throwing the exception. */
{
putpkt ("k");
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error == TARGET_CLOSE_ERROR)
{
{
p = remote_get_noisy_reply ();
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != TARGET_CLOSE_ERROR)
{
{
btrace_read_config (&tinfo->conf);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &err)
+ catch (const gdb_exception_error &err)
{
if (err.message != NULL)
warning ("%s", err.what ());
val = value_of_register (regnum, frame);
regtype = value_type (val);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* Handle failure to read a register without interrupting the entire
'info registers' flow. */
cache = riscv_frame_cache (this_frame, prologue_cache);
*this_id = cache->this_id;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* Ignore errors, this leaves the frame id as the predefined outer
frame id which terminates the backtrace at this point. */
{
pc = read_memory_unsigned_integer (addr, tdep->wordsize, byte_order);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
/* An error occured during reading. Probably a memory error
due to the section not being loaded yet. This address
cache->base = get_frame_register_unsigned
(this_frame, gdbarch_sp_regnum (gdbarch));
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
trad_frame_set_value (cache->saved_regs,
gdbarch_pc_regnum (gdbarch), lr);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
rust_lex_test_one (parser, input, DECIMAL_INTEGER);
SELF_CHECK (0);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
SELF_CHECK (strcmp (except.what (), err) == 0);
}
result = value_struct_elt (&lhs, NULL, field_name,
NULL, "structure");
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
error (_("Could not find field %s of struct variant %s::%s"),
field_name, TYPE_NAME (outer_type),
if (!s390_prologue_frame_unwind_cache (this_frame, info))
s390_backchain_frame_unwind_cache (this_frame, info);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (ex.error != NOT_AVAILABLE_ERROR)
throw_exception (ex);
function (gdbarch);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
pass = false;
exception_fprintf (gdb_stderr, ex,
{
tmp_bfd = solib_bfd_open (buf);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
}
{
tmp_bfd = solib_bfd_open (buf);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
}
link_ptr = &newobj->next;
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Ignore memory errors. */
switch (ex.error)
addr = read_memory_typed_address (info->debug_base + lmo->r_map_offset,
ptr_type);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_print (gdb_stderr, ex);
}
= read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset,
lmo->r_version_size, byte_order);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_print (gdb_stderr, ex);
}
{
probe_argc = pa->prob->get_argument_count (frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_print (gdb_stderr, ex);
probe_argc = 0;
{
val = pa->prob->evaluate_argument (1, frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_print (gdb_stderr, ex);
val = NULL;
{
val = pa->prob->evaluate_argument (2, frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_print (gdb_stderr, ex);
return;
{
tmp_bfd = solib_bfd_open (interp_name);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
}
so->symbols_loaded = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_fprintf (gdb_stderr, e, _("Error while reading shared"
" library symbols for %s:\n"),
{
ops->open_symbol_file_object (from_tty);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_fprintf (gdb_stderr, ex,
"Error reading attached "
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_fprintf (gdb_stderr, e,
_("Error while mapping shared "
solib_map_sections (so);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
exception_fprintf (gdb_stderr, e,
_("Error while mapping "
if (si_code >= SEGV_ACCADI && si_code <= SEGV_ADIPERR)
addr = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
}
- catch (const gdb_exception_RETURN_MASK_ALL &exception)
+ catch (const gdb_exception &exception)
{
return;
}
if (set_current_sal)
set_current_sal_from_frame (frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
}
}
common_val_print (arg->val, &stb, 2, &opts, language);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
stb.printf (_("<error reading variable: %s>"),
except.what ());
{
argp->val = read_var_value (sym, NULL, frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
argp->error = xstrdup (except.what ());
}
{
val = read_var_value (sym, NULL, frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
val_error = (char *) alloca (except.message->size () + 1);
strcpy (val_error, except.what ());
ops = SYMBOL_COMPUTED_OPS (sym);
entryval = ops->read_variable_at_entry (sym, frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (except.error != NO_ENTRY_VALUE_ERROR)
{
TYPE_LENGTH (type_deref)))
val_equal = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* If the dereferenced content could not be
fetched do not display anything. */
{
val = read_var_value (sym, NULL, frame);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
val_error = (char *) alloca (except.message->size () + 1);
strcpy (val_error, except.what ());
DISASSEMBLY_RAW_INSN, how_many,
low, high);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &exception)
+ catch (const gdb_exception_error &exception)
{
/* If an exception was thrown while doing the disassembly, print
the error message, to give the user a clue of what happened. */
{
print_frame_args (func, frame, numargs, gdb_stdout);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &e)
+ catch (const gdb_exception_error &e)
{
}
caller_pc = frame_unwind_caller_pc (fi);
caller_pc_p = 1;
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
switch (ex.error)
{
printf_filtered ("%s", cmd_result.c_str ());
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
fi = get_selected_frame (_("frame apply "
"unable to get selected frame."));
name,
0 /* from_tty */);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
print_symbol (gdbarch, sym, depth + 1, outfile);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
exception_fprintf (gdb_stderr, ex,
"Error printing symbol:\n");
}
/* If an error occurred, print TLS related messages here. Otherwise,
throw the error to some higher catcher. */
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
int objfile_is_library = (objfile->flags & OBJF_SHARED);
printf_filtered ("%s", cmd_result.c_str ());
}
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
if (!flags.silent)
{
disconnect_tracing ();
iterate_over_inferiors (kill_or_detach, &qt);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
pop_all_targets ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
gdb_safe_append_history ();
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
do_final_cleanups ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
if (trace_regblock_size == 0)
error (_("No register block size recorded in trace file"));
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
/* Remove the partially set up target. */
unpush_target (&tfile_ops);
tui_enable ();
}
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
type_print (type, "", &stb, -1);
return std::move (stb.string ());
}
- catch (const gdb_exception_RETURN_MASK_ALL &except)
+ catch (const gdb_exception &except)
{
}
minus_one.get_number ();
SELF_CHECK (false);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
SELF_CHECK (ex.reason == RETURN_ERROR);
SELF_CHECK (ex.error == GENERIC_ERROR);
&flags);
SELF_CHECK (false);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
SELF_CHECK (ex.reason == RETURN_ERROR);
SELF_CHECK (ex.error == GENERIC_ERROR);
{
ret = parse_connection_spec (c.connspec, &hint);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* If we caught an error, we should check if this connection
spec was supposed to fail. */
{
target = value_ind (v);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
if (except.error == MEMORY_ERROR)
{
{
ret = value_of_this (lang);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
}
stream, recurse, val,
&local_opts);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
fprintf_filtered (stream, _("<error reading variable>"));
}
{
value_fetch_lazy (value);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
/* Fall back to checking value->optimized_out. */
}
val = value_of_internalvar (gdbarch, var);
value_print (val, gdb_stdout, &opts);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &ex)
+ catch (const gdb_exception_error &ex)
{
fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.what ());
}
var->root->exp = parse_exp_1 (&p, pc, block, 0, &tracker);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
return NULL;
}
{
value = evaluate_expression (var->root->exp.get ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* Error getting the value. Try to at least get the
right type. */
value = evaluate_expression (exp.get ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* We cannot proceed without a valid expression. */
return false;
val = value_assign (var->value.get (), value);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
return false;
}
value_fetch_lazy (value);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
/* Set the value to NULL, so that for the next -var-update,
we don't try to compare the new value with this value,
{
new_val = evaluate_expression (var->root->exp.get ());
}
- catch (const gdb_exception_RETURN_MASK_ERROR &except)
+ catch (const gdb_exception_error &except)
{
}
}
{
func ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
{
tinfo = linux_enable_btrace (ptid, conf);
}
- catch (const gdb_exception_RETURN_MASK_ERROR &exception)
+ catch (const gdb_exception_error &exception)
{
error (_("Could not enable branch tracing for %s: %s"),
target_pid_to_str (ptid).c_str (), exception.what ());
{
parser->start_element (name, attrs);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
parser->set_error (ex);
}
{
parser->end_element (name);
}
- catch (const gdb_exception_RETURN_MASK_ALL &ex)
+ catch (const gdb_exception &ex)
{
parser->set_error (ex);
}
projects / deliverable / binutils-gdb.git / commitdiff
