--- a/breakpoint.c +++ b/breakpoint.c @@ -9493,32 +9493,27 @@ decode_static_tracepoint_spec (char **ar return sals; } +/* Initialize all the element of CB to its default value. */ + +void +create_breakpoint_init (struct create_breakpoint_s *cb) +{ + memset (cb, '\0', sizeof (*cb)); + cb->type_wanted = bp_breakpoint; + cb->pending_break_support = AUTO_BOOLEAN_TRUE; + cb->enabled = 1; +} + /* Set a breakpoint. This function is shared between CLI and MI - functions for setting a breakpoint. This function has two major - modes of operations, selected by the PARSE_CONDITION_AND_THREAD - parameter. If non-zero, the function will parse arg, extracting - breakpoint location, address and thread. Otherwise, ARG is just - the location of breakpoint, with condition and thread specified by - the COND_STRING and THREAD parameters. If INTERNAL is non-zero, - the breakpoint number will be allocated from the internal - breakpoint count. Returns true if any breakpoint was created; - false otherwise. */ + functions for setting a breakpoint. + Returns true if any breakpoint was created; false otherwise. */ int -create_breakpoint (struct gdbarch *gdbarch, - char *arg, char *cond_string, - int thread, char *extra_string, - int parse_condition_and_thread, - int tempflag, enum bptype type_wanted, - int ignore_count, - enum auto_boolean pending_break_support, - const struct breakpoint_ops *ops, - int from_tty, int enabled, int internal, - unsigned flags) +create_breakpoint (struct create_breakpoint_s *cb) { volatile struct gdb_exception e; char *copy_arg = NULL; - char *addr_start = arg; + char *addr_start = cb->arg; struct linespec_result canonical; struct cleanup *old_chain; struct cleanup *bkpt_chain = NULL; @@ -9526,14 +9521,15 @@ create_breakpoint (struct gdbarch *gdbar int task = 0; int prev_bkpt_count = breakpoint_count; - gdb_assert (ops != NULL); + gdb_assert (cb->ops != NULL); init_linespec_result (&canonical); TRY_CATCH (e, RETURN_MASK_ALL) { - ops->create_sals_from_address (&arg, &canonical, type_wanted, - addr_start, ©_arg); + cb->ops->create_sals_from_address (&cb->arg, &canonical, + cb->type_wanted, + addr_start, ©_arg); } /* If caller is interested in rc value from parse, set value. */ @@ -9551,16 +9547,16 @@ create_breakpoint (struct gdbarch *gdbar /* If pending breakpoint support is turned off, throw error. */ - if (pending_break_support == AUTO_BOOLEAN_FALSE) + if (cb->pending_break_support == AUTO_BOOLEAN_FALSE) throw_exception (e); exception_print (gdb_stderr, e); /* If pending breakpoint support is auto query and the user selects no, then simply return the error code. */ - if (pending_break_support == AUTO_BOOLEAN_AUTO + if (cb->pending_break_support == AUTO_BOOLEAN_AUTO && !nquery (_("Make %s pending on future shared library load? "), - bptype_string (type_wanted))) + bptype_string (cb->type_wanted))) return 0; /* At this point, either the user was queried about setting @@ -9608,13 +9604,13 @@ create_breakpoint (struct gdbarch *gdbar } /* Fast tracepoints may have additional restrictions on location. */ - if (!pending && type_wanted == bp_fast_tracepoint) + if (!pending && cb->type_wanted == bp_fast_tracepoint) { int ix; struct linespec_sals *iter; for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix) - check_fast_tracepoint_sals (gdbarch, &iter->sals); + check_fast_tracepoint_sals (cb->gdbarch, &iter->sals); } /* Verify that condition can be parsed, before setting any @@ -9626,7 +9622,7 @@ create_breakpoint (struct gdbarch *gdbar lsal = VEC_index (linespec_sals, canonical.sals, 0); - if (parse_condition_and_thread) + if (cb->parse_condition_and_thread) { char *rest; /* Here we only parse 'arg' to separate condition @@ -9634,36 +9630,40 @@ create_breakpoint (struct gdbarch *gdbar sal is OK. When setting the breakpoint we'll re-parse it in context of each sal. */ - find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string, - &thread, &task, &rest); - if (cond_string) - make_cleanup (xfree, cond_string); + find_condition_and_thread (cb->arg, lsal->sals.sals[0].pc, + &cb->cond_string, + &cb->thread, &task, &rest); + if (cb->cond_string) + make_cleanup (xfree, cb->cond_string); if (rest) make_cleanup (xfree, rest); if (rest) - extra_string = rest; + cb->extra_string = rest; } else { /* Create a private copy of condition string. */ - if (cond_string) + if (cb->cond_string) { - cond_string = xstrdup (cond_string); - make_cleanup (xfree, cond_string); + cb->cond_string = xstrdup (cb->cond_string); + make_cleanup (xfree, cb->cond_string); } /* Create a private copy of any extra string. */ - if (extra_string) + if (cb->extra_string) { - extra_string = xstrdup (extra_string); - make_cleanup (xfree, extra_string); + cb->extra_string = xstrdup (cb->extra_string); + make_cleanup (xfree, cb->extra_string); } } - ops->create_breakpoints_sal (gdbarch, &canonical, lsal, - cond_string, extra_string, type_wanted, - tempflag ? disp_del : disp_donttouch, - thread, task, ignore_count, ops, - from_tty, enabled, internal, flags); + cb->ops->create_breakpoints_sal (cb->gdbarch, &canonical, lsal, + cb->cond_string, cb->extra_string, + cb->type_wanted, + cb->tempflag ? disp_del + : disp_donttouch, + cb->thread, task, cb->ignore_count, + cb->ops, cb->from_tty, cb->enabled, + cb->internal, cb->flags); } else { @@ -9671,7 +9671,7 @@ create_breakpoint (struct gdbarch *gdbar make_cleanup (xfree, copy_arg); - if (is_tracepoint_type (type_wanted)) + if (is_tracepoint_type (cb->type_wanted)) { struct tracepoint *t; @@ -9681,31 +9681,32 @@ create_breakpoint (struct gdbarch *gdbar else b = XNEW (struct breakpoint); - init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops); + init_raw_breakpoint_without_location (b, cb->gdbarch, cb->type_wanted, + cb->ops); b->addr_string = copy_arg; - if (parse_condition_and_thread) + if (cb->parse_condition_and_thread) b->cond_string = NULL; else { /* Create a private copy of condition string. */ - if (cond_string) + if (cb->cond_string) { - cond_string = xstrdup (cond_string); - make_cleanup (xfree, cond_string); + cb->cond_string = xstrdup (cb->cond_string); + make_cleanup (xfree, cb->cond_string); } - b->cond_string = cond_string; + b->cond_string = cb->cond_string; } b->extra_string = NULL; - b->ignore_count = ignore_count; - b->disposition = tempflag ? disp_del : disp_donttouch; + b->ignore_count = cb->ignore_count; + b->disposition = cb->tempflag ? disp_del : disp_donttouch; b->condition_not_parsed = 1; - b->enable_state = enabled ? bp_enabled : bp_disabled; - if ((type_wanted != bp_breakpoint - && type_wanted != bp_hardware_breakpoint) || thread != -1) + b->enable_state = cb->enabled ? bp_enabled : bp_disabled; + if ((cb->type_wanted != bp_breakpoint + && cb->type_wanted != bp_hardware_breakpoint) || cb->thread != -1) b->pspace = current_program_space; - install_breakpoint (internal, b, 0); + install_breakpoint (cb->internal, b, 0); } if (VEC_length (linespec_sals, canonical.sals) > 1) @@ -9743,6 +9744,7 @@ break_command_1 (char *arg, int flag, in : bp_breakpoint); struct breakpoint_ops *ops; const char *arg_cp = arg; + struct create_breakpoint_s cb; /* Matching breakpoints on probes. */ if (arg && probe_linespec_to_ops (&arg_cp) != NULL) @@ -9750,17 +9752,16 @@ break_command_1 (char *arg, int flag, in else ops = &bkpt_breakpoint_ops; - create_breakpoint (get_current_arch (), - arg, - NULL, 0, NULL, 1 /* parse arg */, - tempflag, type_wanted, - 0 /* Ignore count */, - pending_break_support, - ops, - from_tty, - 1 /* enabled */, - 0 /* internal */, - 0); + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = arg; + cb.parse_condition_and_thread = 1; + cb.tempflag = tempflag; + cb.type_wanted = type_wanted; + cb.pending_break_support = pending_break_support; + cb.ops = ops; + cb.from_tty = from_tty; + create_breakpoint (&cb); } /* Helper function for break_command_1 and disassemble_command. */ @@ -9925,17 +9926,17 @@ stopat_command (char *arg, int from_tty) static void dprintf_command (char *arg, int from_tty) { - create_breakpoint (get_current_arch (), - arg, - NULL, 0, NULL, 1 /* parse arg */, - 0, bp_dprintf, - 0 /* Ignore count */, - pending_break_support, - &dprintf_breakpoint_ops, - from_tty, - 1 /* enabled */, - 0 /* internal */, - 0); + struct create_breakpoint_s cb; + + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = arg; + cb.parse_condition_and_thread = 1; + cb.type_wanted = bp_dprintf; + cb.pending_break_support = pending_break_support; + cb.ops = &dprintf_breakpoint_ops; + cb.from_tty = from_tty; + create_breakpoint (&cb); } static void @@ -11650,22 +11651,22 @@ handle_gnu_v3_exceptions (int tempflag, enum exception_event_kind ex_event, int from_tty) { char *trigger_func_name; + struct create_breakpoint_s cb; if (ex_event == EX_EVENT_CATCH) trigger_func_name = "__cxa_begin_catch"; else trigger_func_name = "__cxa_throw"; - create_breakpoint (get_current_arch (), - trigger_func_name, cond_string, -1, NULL, - 0 /* condition and thread are valid. */, - tempflag, bp_breakpoint, - 0, - AUTO_BOOLEAN_TRUE /* pending */, - &gnu_v3_exception_catchpoint_ops, from_tty, - 1 /* enabled */, - 0 /* internal */, - 0); + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = trigger_func_name; + cb.cond_string = cond_string; + cb.thread = -1; + cb.tempflag = tempflag; + cb.ops = &gnu_v3_exception_catchpoint_ops; + cb.from_tty = from_tty; + create_breakpoint (&cb); return 1; } @@ -15098,39 +15099,38 @@ trace_command (char *arg, int from_tty) { struct breakpoint_ops *ops; const char *arg_cp = arg; + struct create_breakpoint_s cb; if (arg && probe_linespec_to_ops (&arg_cp)) ops = &tracepoint_probe_breakpoint_ops; else ops = &tracepoint_breakpoint_ops; - create_breakpoint (get_current_arch (), - arg, - NULL, 0, NULL, 1 /* parse arg */, - 0 /* tempflag */, - bp_tracepoint /* type_wanted */, - 0 /* Ignore count */, - pending_break_support, - ops, - from_tty, - 1 /* enabled */, - 0 /* internal */, 0); + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = arg; + cb.parse_condition_and_thread = 1; + cb.type_wanted = bp_tracepoint; + cb.pending_break_support = pending_break_support; + cb.ops = ops; + cb.from_tty = from_tty; + create_breakpoint (&cb); } static void ftrace_command (char *arg, int from_tty) { - create_breakpoint (get_current_arch (), - arg, - NULL, 0, NULL, 1 /* parse arg */, - 0 /* tempflag */, - bp_fast_tracepoint /* type_wanted */, - 0 /* Ignore count */, - pending_break_support, - &tracepoint_breakpoint_ops, - from_tty, - 1 /* enabled */, - 0 /* internal */, 0); + struct create_breakpoint_s cb; + + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = arg; + cb.parse_condition_and_thread = 1; + cb.type_wanted = bp_fast_tracepoint; + cb.pending_break_support = pending_break_support; + cb.ops = &tracepoint_breakpoint_ops; + cb.from_tty = from_tty; + create_breakpoint (&cb); } /* strace command implementation. Creates a static tracepoint. */ @@ -15139,6 +15139,7 @@ static void strace_command (char *arg, int from_tty) { struct breakpoint_ops *ops; + struct create_breakpoint_s cb; /* Decide if we are dealing with a static tracepoint marker (`-m'), or with a normal static tracepoint. */ @@ -15147,17 +15148,15 @@ strace_command (char *arg, int from_tty) else ops = &tracepoint_breakpoint_ops; - create_breakpoint (get_current_arch (), - arg, - NULL, 0, NULL, 1 /* parse arg */, - 0 /* tempflag */, - bp_static_tracepoint /* type_wanted */, - 0 /* Ignore count */, - pending_break_support, - ops, - from_tty, - 1 /* enabled */, - 0 /* internal */, 0); + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = arg; + cb.parse_condition_and_thread = 1; + cb.type_wanted = bp_static_tracepoint; + cb.pending_break_support = pending_break_support; + cb.ops = ops; + cb.from_tty = from_tty; + create_breakpoint (&cb); } /* Set up a fake reader function that gets command lines from a linked @@ -15189,6 +15188,7 @@ create_tracepoint_from_upload (struct up { char *addr_str, small_buf[100]; struct tracepoint *tp; + struct create_breakpoint_s cb; if (utp->at_string) addr_str = utp->at_string; @@ -15210,20 +15210,17 @@ create_tracepoint_from_upload (struct up warning (_("Uploaded tracepoint %d condition " "has no source form, ignoring it"), utp->number); - - if (!create_breakpoint (get_current_arch (), - addr_str, - utp->cond_string, -1, NULL, - 0 /* parse cond/thread */, - 0 /* tempflag */, - utp->type /* type_wanted */, - 0 /* Ignore count */, - pending_break_support, - &tracepoint_breakpoint_ops, - 0 /* from_tty */, - utp->enabled /* enabled */, - 0 /* internal */, - CREATE_BREAKPOINT_FLAGS_INSERTED)) + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = addr_str; + cb.cond_string = utp->cond_string; + cb.thread = -1; + cb.type_wanted = utp->type; + cb.pending_break_support = pending_break_support; + cb.ops = &tracepoint_breakpoint_ops; + cb.enabled = utp->enabled; + cb.flags = CREATE_BREAKPOINT_FLAGS_INSERTED; + if (!create_breakpoint (&cb)) return NULL; /* Get the tracepoint we just created. */ --- a/breakpoint.h +++ b/breakpoint.h @@ -1265,17 +1265,79 @@ enum breakpoint_create_flags CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0 }; -extern int create_breakpoint (struct gdbarch *gdbarch, char *arg, - char *cond_string, int thread, - char *extra_string, - int parse_condition_and_thread, - int tempflag, enum bptype wanted_type, - int ignore_count, - enum auto_boolean pending_break_support, - const struct breakpoint_ops *ops, - int from_tty, - int enabled, - int internal, unsigned flags); +/* This argument struct for function CREATE_BREAKPOINT. */ + +struct create_breakpoint_s +{ + /* GDBARCH will be initialized to NULL in + function CREATE_BREAKPOINT_INIT. */ + struct gdbarch *gdbarch; + + /* ARG will be initialized to NULL in function CREATE_BREAKPOINT_INIT. */ + char *arg; + + /* COND_STRING will be initialized to NULL in function + CREATE_BREAKPOINT_INIT. */ + char *cond_string; + + /* THREAD will be initialized to 0 in function CREATE_BREAKPOINT_INIT. */ + int thread; + + /* EXTRA_STRING will be initialized to NULL in function + CREATE_BREAKPOINT_INIT. */ + char *extra_string; + + /* Function CREATE_BREAKPOINT has two major modes of operations, + selected by the PARSE_CONDITION_AND_THREAD parameter. + If non-zero, the function will parse arg, extracting + breakpoint location, address and thread. + Otherwise, ARG is just the location of breakpoint, + with condition and thread specified by + the COND_STRING and THREAD parameters. + It will be initialized to 0 in function CREATE_BREAKPOINT_INIT. */ + int parse_condition_and_thread; + + /* TEMPFLAG will be initialized to 0 in + function CREATE_BREAKPOINT_INIT. */ + int tempflag; + + /* WANTED_TYPE will be initialized to bp_breakpoint in + function CREATE_BREAKPOINT_INIT. */ + enum bptype type_wanted; + + /* IGNORE_COUNT will be initialized to 0 in + function CREATE_BREAKPOINT_INIT. */ + int ignore_count; + + /* PENDING_BREAK_SUPPORT will be initialized to AUTO_BOOLEAN_TRUE in + function CREATE_BREAKPOINT_INIT. */ + enum auto_boolean pending_break_support; + + /* OPS will be initialized to NULL in + function CREATE_BREAKPOINT_INIT. */ + const struct breakpoint_ops *ops; + + /* FROM_TTY will be initialized to 0 in + function CREATE_BREAKPOINT_INIT. */ + int from_tty; + + /* ENABLED will be initialized to 1 in + function CREATE_BREAKPOINT_INIT. */ + int enabled; + + /* If INTERNAL is non-zero, the breakpoint number will be allocated + from the internal breakpoint count. + It will be initialized to 0 in function CREATE_BREAKPOINT_INIT. */ + int internal; + + /* FLAGS will be initialized to 0 in + function CREATE_BREAKPOINT_INIT. */ + unsigned flags; +}; + +extern void create_breakpoint_init (struct create_breakpoint_s *cb); + +extern int create_breakpoint (struct create_breakpoint_s *cb); extern void insert_breakpoints (void); --- a/mi/mi-cmd-break.c +++ b/mi/mi-cmd-break.c @@ -100,8 +100,7 @@ mi_cmd_break_insert (char *command, char int enabled = 1; int tracepoint = 0; struct cleanup *back_to; - enum bptype type_wanted; - struct breakpoint_ops *ops; + struct create_breakpoint_s cb; enum opt { @@ -178,20 +177,21 @@ mi_cmd_break_insert (char *command, char "fast" is a misnomer, actually, "jump" would be more appropriate. A simulator or an emulator could conceivably implement fast regular non-jump based tracepoints. */ - type_wanted = (tracepoint - ? (hardware ? bp_fast_tracepoint : bp_tracepoint) - : (hardware ? bp_hardware_breakpoint : bp_breakpoint)); - ops = tracepoint ? &tracepoint_breakpoint_ops : &bkpt_breakpoint_ops; - - create_breakpoint (get_current_arch (), address, condition, thread, - NULL, - 0 /* condition and thread are valid. */, - temp_p, type_wanted, - ignore_count, - pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE, - ops, 0, enabled, 0, 0); + create_breakpoint_init (&cb); + cb.gdbarch = get_current_arch (); + cb.arg = address; + cb.cond_string = condition; + cb.thread = thread; + cb.tempflag = temp_p; + cb.type_wanted = (tracepoint + ? (hardware ? bp_fast_tracepoint : bp_tracepoint) + : (hardware ? bp_hardware_breakpoint : bp_breakpoint)); + cb.ignore_count = ignore_count; + cb.pending_break_support = pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE; + cb.ops = tracepoint ? &tracepoint_breakpoint_ops : &bkpt_breakpoint_ops; + cb.enabled = enabled; + create_breakpoint (&cb); do_cleanups (back_to); - } enum wp_type --- a/python/py-breakpoint.c +++ b/python/py-breakpoint.c @@ -621,14 +621,15 @@ bppy_init (PyObject *self, PyObject *arg { case bp_breakpoint: { - create_breakpoint (python_gdbarch, - copy, NULL, -1, NULL, - 0, - 0, bp_breakpoint, - 0, - AUTO_BOOLEAN_TRUE, - &bkpt_breakpoint_ops, - 0, 1, internal_bp, 0); + struct create_breakpoint_s cb; + + create_breakpoint_init (&cb); + cb.gdbarch = python_gdbarch; + cb.arg = copy; + cb.thread = -1; + cb.ops = &bkpt_breakpoint_ops; + cb.internal = internal_bp; + create_breakpoint (&cb); break; } case bp_watchpoint: --- a/python/py-finishbreakpoint.c +++ b/python/py-finishbreakpoint.c @@ -281,20 +281,19 @@ bpfinishpy_init (PyObject *self, PyObjec TRY_CATCH (except, RETURN_MASK_ALL) { + struct create_breakpoint_s cb; /* Set a breakpoint on the return address. */ finish_pc = get_frame_pc (prev_frame); xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (finish_pc)); - addr_str = small_buf; - create_breakpoint (python_gdbarch, - addr_str, NULL, thread, NULL, - 0, - 1 /*temp_flag*/, - bp_breakpoint, - 0, - AUTO_BOOLEAN_TRUE, - &bkpt_breakpoint_ops, - 0, 1, internal_bp, 0); + create_breakpoint_init (&cb); + cb.gdbarch = python_gdbarch; + cb.arg = small_buf; + cb.thread = thread; + cb.tempflag = 1; + cb.ops = &bkpt_breakpoint_ops; + cb.internal = internal_bp; + create_breakpoint (&cb); } GDB_PY_SET_HANDLE_EXCEPTION (except); --- a/spu-tdep.c +++ b/spu-tdep.c @@ -1898,6 +1898,7 @@ spu_catch_start (struct objfile *objfile struct symtab *symtab; CORE_ADDR pc; char buf[32]; + struct create_breakpoint_s cb; /* Do this only if requested by "set spu stop-on-load on". */ if (!spu_stop_on_load_p) @@ -1940,15 +1941,14 @@ spu_catch_start (struct objfile *objfile /* Use a numerical address for the set_breakpoint command to avoid having the breakpoint re-set incorrectly. */ xsnprintf (buf, sizeof buf, "*%s", core_addr_to_string (pc)); - create_breakpoint (get_objfile_arch (objfile), buf /* arg */, - NULL /* cond_string */, -1 /* thread */, - NULL /* extra_string */, - 0 /* parse_condition_and_thread */, 1 /* tempflag */, - bp_breakpoint /* type_wanted */, - 0 /* ignore_count */, - AUTO_BOOLEAN_FALSE /* pending_break_support */, - &bkpt_breakpoint_ops /* ops */, 0 /* from_tty */, - 1 /* enabled */, 0 /* internal */, 0); + create_breakpoint_init (&cb); + cb.gdbarch = get_objfile_arch (objfile); + cb.arg = buf; + cb.thread = -1; + cb.tempflag = 1; + cb.pending_break_support = AUTO_BOOLEAN_FALSE; + cb.ops = &bkpt_breakpoint_ops; + create_breakpoint (&cb); }