struct event_location * string_to_event_location (char **stringp, const struct language_defn *language) { struct event_location *location; const char *arg, *orig; /* Try an explicit location. */ orig = arg = *stringp; location = string_to_explicit_location (&arg, language, 0); if (location != NULL) { /* It was a valid explicit location. Advance STRINGP to the end of input. */ *stringp += arg - orig; } else { /* Everything else is a "basic" linespec, address, or probe location. */ location = string_to_event_location_basic (stringp, language); } return location; }
event_location_up string_to_event_location (const char **stringp, const struct language_defn *language, symbol_name_match_type match_type) { const char *arg, *orig; /* Try an explicit location. */ orig = arg = *stringp; event_location_up location = string_to_explicit_location (&arg, language, NULL); if (location != NULL) { /* It was a valid explicit location. Advance STRINGP to the end of input. */ *stringp += arg - orig; /* If the user really specified a location, then we're done. */ if (!event_location_empty_p (location.get ())) return location; /* Otherwise, the user _only_ specified optional flags like "-qualified", otherwise string_to_explicit_location would have thrown an error. Save the flags for "basic" linespec parsing below and discard the explicit location. */ match_type = EL_EXPLICIT (location)->func_name_match_type; } /* Everything else is a "basic" linespec, address, or probe location. */ return string_to_event_location_basic (stringp, language, match_type); }
static void mi_cmd_break_insert_1 (int dprintf, char *command, char **argv, int argc) { char *address = NULL; int hardware = 0; int temp_p = 0; int thread = -1; int ignore_count = 0; char *condition = NULL; int pending = 0; int enabled = 1; int tracepoint = 0; struct cleanup *back_to = make_cleanup (null_cleanup, NULL); enum bptype type_wanted; struct event_location *location; struct breakpoint_ops *ops; int is_explicit = 0; struct explicit_location explicit_loc; char *extra_string = NULL; enum opt { HARDWARE_OPT, TEMP_OPT, CONDITION_OPT, IGNORE_COUNT_OPT, THREAD_OPT, PENDING_OPT, DISABLE_OPT, TRACEPOINT_OPT, EXPLICIT_SOURCE_OPT, EXPLICIT_FUNC_OPT, EXPLICIT_LABEL_OPT, EXPLICIT_LINE_OPT }; static const struct mi_opt opts[] = { {"h", HARDWARE_OPT, 0}, {"t", TEMP_OPT, 0}, {"c", CONDITION_OPT, 1}, {"i", IGNORE_COUNT_OPT, 1}, {"p", THREAD_OPT, 1}, {"f", PENDING_OPT, 0}, {"d", DISABLE_OPT, 0}, {"a", TRACEPOINT_OPT, 0}, {"-source" , EXPLICIT_SOURCE_OPT, 1}, {"-function", EXPLICIT_FUNC_OPT, 1}, {"-label", EXPLICIT_LABEL_OPT, 1}, {"-line", EXPLICIT_LINE_OPT, 1}, { 0, 0, 0 } }; /* Parse arguments. It could be -r or -h or -t, <location> or ``--'' to denote the end of the option list. */ int oind = 0; char *oarg; initialize_explicit_location (&explicit_loc); while (1) { int opt = mi_getopt ("-break-insert", argc, argv, opts, &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case TEMP_OPT: temp_p = 1; break; case HARDWARE_OPT: hardware = 1; break; case CONDITION_OPT: condition = oarg; break; case IGNORE_COUNT_OPT: ignore_count = atol (oarg); break; case THREAD_OPT: thread = atol (oarg); break; case PENDING_OPT: pending = 1; break; case DISABLE_OPT: enabled = 0; break; case TRACEPOINT_OPT: tracepoint = 1; break; case EXPLICIT_SOURCE_OPT: is_explicit = 1; explicit_loc.source_filename = oarg; break; case EXPLICIT_FUNC_OPT: is_explicit = 1; explicit_loc.function_name = oarg; break; case EXPLICIT_LABEL_OPT: is_explicit = 1; explicit_loc.label_name = oarg; break; case EXPLICIT_LINE_OPT: is_explicit = 1; explicit_loc.line_offset = linespec_parse_line_offset (oarg); break; } } if (oind >= argc && !is_explicit) error (_("-%s-insert: Missing <location>"), dprintf ? "dprintf" : "break"); if (dprintf) { int format_num = is_explicit ? oind : oind + 1; if (hardware || tracepoint) error (_("-dprintf-insert: does not support -h or -a")); if (format_num >= argc) error (_("-dprintf-insert: Missing <format>")); extra_string = mi_argv_to_format (argv + format_num, argc - format_num); make_cleanup (xfree, extra_string); address = argv[oind]; } else { if (is_explicit) { if (oind < argc) error (_("-break-insert: Garbage following explicit location")); } else { if (oind < argc - 1) error (_("-break-insert: Garbage following <location>")); address = argv[oind]; } } /* Now we have what we need, let's insert the breakpoint! */ setup_breakpoint_reporting (); if (tracepoint) { /* Note that to request a fast tracepoint, the client uses the "hardware" flag, although there's nothing of hardware related to fast tracepoints -- one can implement slow tracepoints with hardware breakpoints, but fast tracepoints are always software. "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 = hardware ? bp_fast_tracepoint : bp_tracepoint; ops = &tracepoint_breakpoint_ops; } else if (dprintf) { type_wanted = bp_dprintf; ops = &dprintf_breakpoint_ops; } else { type_wanted = hardware ? bp_hardware_breakpoint : bp_breakpoint; ops = &bkpt_breakpoint_ops; } if (is_explicit) { /* Error check -- we must have one of the other parameters specified. */ if (explicit_loc.source_filename != NULL && explicit_loc.function_name == NULL && explicit_loc.label_name == NULL && explicit_loc.line_offset.sign == LINE_OFFSET_UNKNOWN) error (_("-%s-insert: --source option requires --function, --label," " or --line"), dprintf ? "dprintf" : "break"); location = new_explicit_location (&explicit_loc); } else { location = string_to_event_location_basic (&address, current_language); if (*address) { delete_event_location (location); error (_("Garbage '%s' at end of location"), address); } } make_cleanup_delete_event_location (location); create_breakpoint (get_current_arch (), location, condition, thread, extra_string, 0 /* condition and thread are valid. */, temp_p, type_wanted, ignore_count, pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE, ops, 0, enabled, 0, 0); do_cleanups (back_to); }
static SCM gdbscm_register_breakpoint_x (SCM self) { breakpoint_smob *bp_smob = bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME); struct gdb_exception except = exception_none; char *location, *copy; /* We only support registering breakpoints created with make-breakpoint. */ if (!bp_smob->is_scheme_bkpt) scm_misc_error (FUNC_NAME, _("not a Scheme breakpoint"), SCM_EOL); if (bpscm_is_valid (bp_smob)) scm_misc_error (FUNC_NAME, _("breakpoint is already registered"), SCM_EOL); pending_breakpoint_scm = self; location = bp_smob->spec.location; copy = skip_spaces (location); event_location_up eloc = string_to_event_location_basic (©, current_language); TRY { int internal = bp_smob->spec.is_internal; switch (bp_smob->spec.type) { case bp_breakpoint: { create_breakpoint (get_current_arch (), eloc.get (), NULL, -1, NULL, 0, 0, bp_breakpoint, 0, AUTO_BOOLEAN_TRUE, &bkpt_breakpoint_ops, 0, 1, internal, 0); break; } case bp_watchpoint: { enum target_hw_bp_type access_type = bp_smob->spec.access_type; if (access_type == hw_write) watch_command_wrapper (location, 0, internal); else if (access_type == hw_access) awatch_command_wrapper (location, 0, internal); else if (access_type == hw_read) rwatch_command_wrapper (location, 0, internal); else gdb_assert_not_reached ("invalid access type"); break; } default: gdb_assert_not_reached ("invalid breakpoint type"); } } CATCH (ex, RETURN_MASK_ALL) { except = ex; } END_CATCH /* Ensure this gets reset, even if there's an error. */ pending_breakpoint_scm = SCM_BOOL_F; GDBSCM_HANDLE_GDB_EXCEPTION (except); return SCM_UNSPECIFIED; }