This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.
Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
---|---|---|
Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |
Other format: | [Raw text] |
On Saturday 08 September 2007 16:25:49 Eli Zaretskii wrote: > > From: Vladimir Prus <vladimir@codesourcery.com> > > Date: Sat, 8 Sep 2007 15:43:45 +0400 > > Cc: gdb-patches@sources.redhat.com > > > > On Saturday 08 September 2007 15:26:36 Eli Zaretskii wrote: > > > > From: Vladimir Prus <vladimir@codesourcery.com> > > > > Date: Sat, 8 Sep 2007 01:50:04 +0400 > > > > > > > > @@ -5422,12 +5355,9 @@ break_command_1 (char *arg, int flag, in > > > > } > > > > else > > > > { > > > > - struct symtab_and_line sal; > > > > + struct symtab_and_line sal = {}; > > > > > > Is this a valid initializer in ISO C? I think it isn't; at least > > > under -pedantic, GCC says: > > > > > > ttt.c: In function `foo': > > > ttt.c:6: warning: ISO C forbids empty initializer braces > > > > Ehm. Then do I have to resort to 'memset' to initialize it? > > Yes, something like that. The attached patch uses {0}, as suggested by Andreas. > > > > - breakpoints_changed (); > > > > + /* We surely don't want to warn about the same breakpoint > > > > + 10 times. > > > > > > Why not? They are different breakpoints. > > > > What are "they"? > > The several locations for the same breakpoint. This is what we are > talking about here, right? Sorry if I again misunderstood the code. > > > Say you've set a breakpoint. The you've changed the > > program and restarted it, so that breakpoint is not longer valid. > > I do expect an error to be printed, but I don't expect that error > > to be printed each time a new shared library is loaded. > > I thought you were talking printing the warning for each of the > several locations of the same breakpoint. In that case, only some of > them could be affected by a library load. No, this is for breakpoints. So, if a breakpoint has "foobar" as address string, and we totally fail to find anything named "foobar", we tell the user the first time, but won't tell him later. Do you have any further concerns? I attach the current patch just in case. - Volodya
Attachment:
7.ChangeLog
Description: Text document
--- gdb/solib-osf.c (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/solib-osf.c (/work/mb_mainline/7_pending) (revision 4829) @@ -336,9 +336,6 @@ osf_solib_create_inferior_hook (void) suppresses the warning. */ solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add); stop_soon = NO_STOP_QUIETLY; - - /* Enable breakpoints disabled (unnecessarily) by clear_solib(). */ - re_enable_breakpoints_in_shlibs (); } /* target_so_ops callback. Do additional symbol handling, lookup, etc. after --- gdb/breakpoint.c (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/breakpoint.c (/work/mb_mainline/7_pending) (revision 4829) @@ -203,6 +203,8 @@ static void ep_skip_leading_whitespace ( static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc); +static void free_bp_location (struct bp_location *loc); + /* Prototypes for exported functions. */ /* If FALSE, gdb will not use hardware support for watchpoints, even @@ -4140,6 +4142,13 @@ allocate_bp_location (struct breakpoint return loc; } +static void free_bp_location (struct bp_location *loc) +{ + if (loc->cond) + xfree (loc->cond); + xfree (loc); +} + /* set_raw_breakpoint() is a low level routine for allocating and partially initializing a breakpoint of type BPTYPE. The newly created breakpoint's address, section, source file name, and line @@ -4396,51 +4405,6 @@ struct lang_and_radix int radix; }; -/* Cleanup helper routine to restore the current language and - input radix. */ -static void -do_restore_lang_radix_cleanup (void *old) -{ - struct lang_and_radix *p = old; - set_language (p->lang); - input_radix = p->radix; -} - -/* Try and resolve a pending breakpoint. */ -static int -resolve_pending_breakpoint (struct breakpoint *b) -{ - /* Try and reparse the breakpoint in case the shared library - is now loaded. */ - struct symtabs_and_lines sals; - struct symtab_and_line pending_sal; - char **cond_string = (char **) NULL; - char *copy_arg = b->addr_string; - char **addr_string; - char *errmsg; - int rc; - int not_found = 0; - struct ui_file *old_gdb_stderr; - struct lang_and_radix old_lr; - struct cleanup *old_chain; - - /* Set language, input-radix, then reissue breakpoint command. - Ensure the language and input-radix are restored afterwards. */ - old_lr.lang = current_language->la_language; - old_lr.radix = input_radix; - old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr); - - set_language (b->language); - input_radix = b->input_radix; - rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b); - - if (rc == GDB_RC_OK) - /* Pending breakpoint has been resolved. */ - printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b->addr_string); - - do_cleanups (old_chain); - return rc; -} void remove_solib_event_breakpoints (void) @@ -4523,37 +4487,6 @@ disable_breakpoints_in_unloaded_shlib (s } } -/* Try to reenable any breakpoints in shared libraries. */ -void -re_enable_breakpoints_in_shlibs (void) -{ - struct breakpoint *b, *tmp; - - ALL_BREAKPOINTS_SAFE (b, tmp) - { - if (b->enable_state == bp_shlib_disabled) - { - gdb_byte buf[1]; - char *lib; - - /* Do not reenable the breakpoint if the shared library is - still not mapped in. */ -#ifdef PC_SOLIB - lib = PC_SOLIB (b->loc->address); -#else - lib = solib_address (b->loc->address); -#endif - if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0) - b->enable_state = bp_enabled; - } - else if (b->pending && (b->enable_state == bp_enabled)) - { - if (resolve_pending_breakpoint (b) == GDB_RC_OK) - delete_breakpoint (b); - } - } -} - static void solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname, char *cond_string, enum bptype bp_kind) @@ -5422,12 +5355,9 @@ break_command_1 (char *arg, int flag, in } else { - struct symtab_and_line sal; + struct symtab_and_line sal = {0}; struct breakpoint *b; - sal.symtab = NULL; - sal.pc = 0; - make_cleanup (xfree, copy_arg); b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint @@ -7153,6 +7083,97 @@ delete_command (char *arg, int from_tty) map_breakpoint_numbers (arg, delete_breakpoint); } +static void +unlink_locations_from_global_list (struct breakpoint *bpt) + /* Remove locations of this breakpoint from the list of + all breakpoint locations. */ +{ + struct bp_location **tmp = &bp_location_chain; + struct bp_location *here = bpt->loc; + + if (here == NULL) + return; + + for (; *tmp && *tmp != here; tmp = &((*tmp)->next)); + gdb_assert (*tmp); + + *tmp = here->next; +} + + +static void +update_breakpoint_location (struct breakpoint *b, + struct symtabs_and_lines sals) +{ + int i; + char *s; + /* FIXME: memleak. */ + struct bp_location *existing = b->loc; + struct bp_location *loc; + struct symtab_and_line sal; + + if (b->enable_state == bp_shlib_disabled && sals.nelts == 0) + return; + + unlink_locations_from_global_list (b); + b->loc = NULL; + + gdb_assert (sals.nelts == 0 || sals.nelts == 1); + if (sals.nelts == 0) + return; + sal = sals.sals[0]; + + loc = allocate_bp_location (b, b->type); + loc->requested_address = sal.pc; + loc->address = adjust_breakpoint_address (loc->requested_address, + b->type); + loc->section = sal.section; + b->loc = loc; + + /* Reparse conditions, they might contain references to the + old symtab. */ + if (b->cond_string != NULL) + { + struct gdb_exception e; + + s = b->cond_string; + TRY_CATCH (e, RETURN_MASK_ERROR) + { + loc->cond = parse_exp_1 (&s, block_for_pc (sal.pc), + 0); + } + if (e.reason < 0) + { + warning (_("failed to reevaluate condition for breakpoint %d: %s"), + b->number, e.message); + b->enable_state = bp_disabled; + } + } + + if (b->source_file != NULL) + xfree (b->source_file); + if (sal.symtab == NULL) + b->source_file = NULL; + else + b->source_file = + savestring (sal.symtab->filename, + strlen (sal.symtab->filename)); + + if (b->line_number == 0) + b->line_number = sal.line; + + if (b->enable_state == bp_shlib_disabled) + b->enable_state = bp_enabled; + + b->pending = 0; + + check_duplicates (b); + + if (existing) + free_bp_location (existing); +} + + /* Reset a breakpoint given it's struct breakpoint * BINT. The value we return ends up being the return value from catch_errors. Unused in this case. */ @@ -7164,11 +7185,13 @@ breakpoint_re_set_one (void *bint) struct breakpoint *b = (struct breakpoint *) bint; struct value *mark; int i; - int not_found; - int *not_found_ptr = NULL; - struct symtabs_and_lines sals; + int not_found = 0; + int *not_found_ptr = ¬_found; + struct symtabs_and_lines sals = {}; char *s; enum enable_state save_enable; + struct gdb_exception e; + switch (b->type) { @@ -7186,115 +7209,59 @@ breakpoint_re_set_one (void *bint) delete_breakpoint (b); return 0; } - /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote: - - ``And a hack it is, although Apple's Darwin version of GDB - contains an almost identical hack to implement a "future - break" command. It seems to work in many real world cases, - but it is easy to come up with a test case where the patch - doesn't help at all.'' - - ``It seems that the way GDB implements breakpoints - in - - shared - libraries was designed for a.out shared library - systems (SunOS 4) where shared libraries were loaded at a - fixed address in memory. Since ELF shared libraries can (and - will) be loaded at any address in memory, things break. - Fixing this is not trivial. Therefore, I'm not sure whether - we should add this hack to the branch only. I cannot - guarantee that things will be fixed on the trunk in the near - future.'' - - In case we have a problem, disable this breakpoint. We'll - restore its status if we succeed. Don't disable a - shlib_disabled breakpoint though. There's a fair chance we - can't re-set it if the shared library it's in hasn't been - loaded yet. */ - - if (b->pending) - break; - - save_enable = b->enable_state; - if (b->enable_state != bp_shlib_disabled) - b->enable_state = bp_disabled; - else - /* If resetting a shlib-disabled breakpoint, we don't want to - see an error message if it is not found since we will expect - this to occur until the shared library is finally reloaded. - We accomplish this by giving decode_line_1 a pointer to use - for silent notification that the symbol is not found. */ - not_found_ptr = ¬_found; set_language (b->language); input_radix = b->input_radix; s = b->addr_string; - sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, - not_found_ptr); - for (i = 0; i < sals.nelts; i++) - { - resolve_sal_pc (&sals.sals[i]); - - /* Reparse conditions, they might contain references to the - old symtab. */ - if (b->cond_string != NULL) - { - s = b->cond_string; - if (b->loc->cond) - { - xfree (b->loc->cond); - /* Avoid re-freeing b->exp if an error during the call - to parse_exp_1. */ - b->loc->cond = NULL; - } - b->loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0); - } + TRY_CATCH (e, RETURN_MASK_ERROR) + { + sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, + not_found_ptr); + } + if (e.reason < 0) + { + int not_found_and_ok = 0; + /* For pending breakpoints, it's expected that parsing + will fail until the right shared library is loaded. + User has already told to create pending breakpoints and + don't need extra messages. If breakpoint is in bp_shlib_disabled + state, then user already saw the message about that breakpoint + being disabled, and don't want to see more errors. */ + if (not_found && (b->pending || b->enable_state == bp_shlib_disabled + || b->enable_state == bp_disabled)) + not_found_and_ok = 1; - /* We need to re-set the breakpoint if the address changes... */ - if (b->loc->address != sals.sals[i].pc - /* ...or new and old breakpoints both have source files, and - the source file name or the line number changes... */ - || (b->source_file != NULL - && sals.sals[i].symtab != NULL - && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0 - || b->line_number != sals.sals[i].line) - ) - /* ...or we switch between having a source file and not having - one. */ - || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL)) - ) + if (!not_found_and_ok) { - if (b->source_file != NULL) - xfree (b->source_file); - if (sals.sals[i].symtab == NULL) - b->source_file = NULL; - else - b->source_file = - savestring (sals.sals[i].symtab->filename, - strlen (sals.sals[i].symtab->filename)); - b->line_number = sals.sals[i].line; - b->loc->requested_address = sals.sals[i].pc; - b->loc->address - = adjust_breakpoint_address (b->loc->requested_address, - b->type); - - /* Used to check for duplicates here, but that can - cause trouble, as it doesn't check for disabled - breakpoints. */ - - mention (b); - - /* Might be better to do this just once per breakpoint_re_set, - rather than once for every breakpoint. */ - breakpoints_changed (); + /* We surely don't want to warn about the same breakpoint + 10 times. One solution, implemented here, is disable + the breakpoint on error. Another solution would be to + have separate 'warning emitted' flag. Since this + happens only when a binary has changed, I don't know + which approach is better. */ + b->enable_state = bp_disabled; + throw_exception (e); } - b->loc->section = sals.sals[i].section; - b->enable_state = save_enable; /* Restore it, this worked. */ + } + if (not_found) + break; + + gdb_assert (sals.nelts == 1); + resolve_sal_pc (&sals.sals[0]); + if (b->pending && s && s[0]) + { + char *cond_string = 0; + int thread = -1; + find_condition_and_thread (s, sals.sals[0].pc, + &cond_string, &thread); + if (cond_string) + b->cond_string = cond_string; + b->thread = thread; + } - /* Now that this is re-enabled, check_duplicates - can be used. */ - check_duplicates (b); + update_breakpoint_location (b, sals); - } xfree (sals.sals); break; @@ -7408,7 +7375,7 @@ breakpoint_re_set (void) ALL_BREAKPOINTS_SAFE (b, temp) { /* Format possible error msg */ - char *message = xstrprintf ("Error in re-setting breakpoint %d:\n", + char *message = xstrprintf ("Error in re-setting breakpoint %d: ", b->number); struct cleanup *cleanups = make_cleanup (xfree, message); catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL); @@ -7635,88 +7602,68 @@ do_enable_breakpoint (struct breakpoint error (_("Hardware breakpoints used exceeds limit.")); } - if (bpt->pending) + if (bpt->enable_state != bp_permanent) + bpt->enable_state = bp_enabled; + bpt->disposition = disposition; + check_duplicates (bpt); + breakpoints_changed (); + + if (bpt->type == bp_watchpoint || + bpt->type == bp_hardware_watchpoint || + bpt->type == bp_read_watchpoint || + bpt->type == bp_access_watchpoint) { - if (bpt->enable_state != bp_enabled) + struct frame_id saved_frame_id; + + saved_frame_id = get_frame_id (get_selected_frame (NULL)); + if (bpt->exp_valid_block != NULL) { - /* When enabling a pending breakpoint, we need to check if the breakpoint - is resolvable since shared libraries could have been loaded - after the breakpoint was disabled. */ - breakpoints_changed (); - if (resolve_pending_breakpoint (bpt) == GDB_RC_OK) + struct frame_info *fr = + fr = frame_find_by_id (bpt->watchpoint_frame); + if (fr == NULL) { - delete_breakpoint (bpt); + printf_filtered (_("\ +Cannot enable watchpoint %d because the block in which its expression\n\ +is valid is not currently in scope.\n"), bpt->number); + bpt->enable_state = bp_disabled; return; } - bpt->enable_state = bp_enabled; - bpt->disposition = disposition; + select_frame (fr); } - } - else /* Not a pending breakpoint. */ - { - if (bpt->enable_state != bp_permanent) - bpt->enable_state = bp_enabled; - bpt->disposition = disposition; - check_duplicates (bpt); - breakpoints_changed (); - if (bpt->type == bp_watchpoint || - bpt->type == bp_hardware_watchpoint || - bpt->type == bp_read_watchpoint || + value_free (bpt->val); + mark = value_mark (); + bpt->val = evaluate_expression (bpt->exp); + release_value (bpt->val); + if (value_lazy (bpt->val)) + value_fetch_lazy (bpt->val); + + if (bpt->type == bp_hardware_watchpoint || + bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint) { - struct frame_id saved_frame_id; - - saved_frame_id = get_frame_id (get_selected_frame (NULL)); - if (bpt->exp_valid_block != NULL) - { - struct frame_info *fr = - fr = frame_find_by_id (bpt->watchpoint_frame); - if (fr == NULL) - { - printf_filtered (_("\ -Cannot enable watchpoint %d because the block in which its expression\n\ -is valid is not currently in scope.\n"), bpt->number); - bpt->enable_state = bp_disabled; - return; - } - select_frame (fr); - } - - value_free (bpt->val); - mark = value_mark (); - bpt->val = evaluate_expression (bpt->exp); - release_value (bpt->val); - if (value_lazy (bpt->val)) - value_fetch_lazy (bpt->val); + int i = hw_watchpoint_used_count (bpt->type, &other_type_used); + int mem_cnt = can_use_hardware_watchpoint (bpt->val); - if (bpt->type == bp_hardware_watchpoint || - bpt->type == bp_read_watchpoint || - bpt->type == bp_access_watchpoint) + /* Hack around 'unused var' error for some targets here */ + (void) mem_cnt, (void) i; + target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT ( + bpt->type, i + mem_cnt, other_type_used); + /* we can consider of type is bp_hardware_watchpoint, convert to + bp_watchpoint in the following condition */ + if (target_resources_ok < 0) { - int i = hw_watchpoint_used_count (bpt->type, &other_type_used); - int mem_cnt = can_use_hardware_watchpoint (bpt->val); - - /* Hack around 'unused var' error for some targets here */ - (void) mem_cnt, (void) i; - target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT ( - bpt->type, i + mem_cnt, other_type_used); - /* we can consider of type is bp_hardware_watchpoint, convert to - bp_watchpoint in the following condition */ - if (target_resources_ok < 0) - { - printf_filtered (_("\ + printf_filtered (_("\ Cannot enable watchpoint %d because target watch resources\n\ have been allocated for other watchpoints.\n"), bpt->number); - bpt->enable_state = bp_disabled; - value_free_to_mark (mark); - return; - } + bpt->enable_state = bp_disabled; + value_free_to_mark (mark); + return; } - - select_frame (frame_find_by_id (saved_frame_id)); - value_free_to_mark (mark); } + + select_frame (frame_find_by_id (saved_frame_id)); + value_free_to_mark (mark); } if (deprecated_modify_breakpoint_hook) @@ -7724,6 +7671,7 @@ have been allocated for other watchpoint breakpoint_modify_event (bpt->number); } + void enable_breakpoint (struct breakpoint *bpt) { --- gdb/breakpoint.h (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/breakpoint.h (/work/mb_mainline/7_pending) (revision 4829) @@ -799,8 +799,6 @@ extern void remove_thread_event_breakpoi extern void disable_breakpoints_in_shlibs (void); -extern void re_enable_breakpoints_in_shlibs (void); - extern void create_solib_load_event_breakpoint (char *, int, char *, char *); extern void create_solib_unload_event_breakpoint (char *, int, --- gdb/testsuite/gdb.base/pending.exp (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/testsuite/gdb.base/pending.exp (/work/mb_mainline/7_pending) (revision 4829) @@ -194,9 +194,7 @@ gdb_test "info break" \ gdb_run_cmd gdb_test "" \ -"Breakpoint.*at.* -Pending breakpoint \"pendshr.c:$bp2_loc if x > 3\" resolved.* -Breakpoint.*, main.*$mainline.*" \ +".*Breakpoint.*, main.*$mainline.*" \ "running to main" # @@ -204,8 +202,7 @@ Breakpoint.*, main.*$mainline.*" \ # gdb_test "enable 1" \ -"Breakpoint.*at.* -Pending breakpoint \"pendfunc1.* resolved.*" \ +"" \ "re-enabling pending breakpoint that can resolve instantly" # --- gdb/testsuite/gdb.base/chng-syms.exp (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/testsuite/gdb.base/chng-syms.exp (/work/mb_mainline/7_pending) (revision 4829) @@ -105,10 +105,10 @@ if { [gdb_compile "${srcdir}/${subdir}/ gdb_run_cmd gdb_expect { - -re "Error in re-setting .*No symbol .var1..*Program exited normally.*$gdb_prompt $" { + -re ".*No symbol .var1..*Program exited normally.*$gdb_prompt $" { pass "running with invalidated bpt condition after executable changes" } - -re "Error in re-setting .*No symbol .var1..*Breakpoint .*,( 0x.* in)? (\[^ \]*)exit .*$gdb_prompt $" { + -re "No symbol .var1..*Breakpoint .*,( 0x.* in)? (\[^ \]*)exit .*$gdb_prompt $" { pass "running with invalidated bpt condition after executable changes" } -re "$gdb_prompt $" { --- gdb/testsuite/gdb.base/unload.exp (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/testsuite/gdb.base/unload.exp (/work/mb_mainline/7_pending) (revision 4829) @@ -89,9 +89,7 @@ set unloadshr_line [gdb_get_line_number gdb_run_cmd gdb_test "" \ -"Breakpoint.*at.* -Pending breakpoint \"shrfunc1\" resolved.* -Breakpoint.*, shrfunc1 \\\(x=3\\\).*unloadshr.c:$unloadshr_line.*" \ +".*Breakpoint.*, shrfunc1 \\\(x=3\\\).*unloadshr.c:$unloadshr_line.*" \ "running program" gdb_test "continue" \ --- gdb/solib-irix.c (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/solib-irix.c (/work/mb_mainline/7_pending) (revision 4829) @@ -457,7 +457,6 @@ irix_solib_create_inferior_hook (void) suppresses the warning. */ solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add); stop_soon = NO_STOP_QUIETLY; - re_enable_breakpoints_in_shlibs (); } /* LOCAL FUNCTION --- gdb/infcmd.c (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/infcmd.c (/work/mb_mainline/7_pending) (revision 4829) @@ -433,10 +433,6 @@ post_create_inferior (struct target_ops #else solib_create_inferior_hook (); #endif - - /* Enable any breakpoints which were disabled when the - underlying shared library was deleted. */ - re_enable_breakpoints_in_shlibs (); } observer_notify_inferior_created (target, from_tty); --- gdb/infrun.c (/work/mb_mainline/6_create_breakpoints_refactoring) (revision 4829) +++ gdb/infrun.c (/work/mb_mainline/7_pending) (revision 4829) @@ -1337,10 +1337,6 @@ handle_inferior_event (struct execution_ #endif target_terminal_inferior (); - /* Try to reenable shared library breakpoints, additional - code segments in shared libraries might be mapped in now. */ - re_enable_breakpoints_in_shlibs (); - /* If requested, stop when the dynamic linker notifies gdb of events. This allows the user to get control and place breakpoints in initializer routines for @@ -2276,10 +2272,6 @@ process_event_stop_test: #endif target_terminal_inferior (); - /* Try to reenable shared library breakpoints, additional - code segments in shared libraries might be mapped in now. */ - re_enable_breakpoints_in_shlibs (); - /* If requested, stop when the dynamic linker notifies gdb of events. This allows the user to get control and place breakpoints in initializer routines for Property changes on: ___________________________________________________________________ Name: svk:merge d48a11ec-ee1c-0410-b3f5-c20844f99675:/work/mb_mainline/4_bpstat_owner:4823 d48a11ec-ee1c-0410-b3f5-c20844f99675:/work/mb_mainline/5_per_loc_cond:4824 +d48a11ec-ee1c-0410-b3f5-c20844f99675:/work/mb_mainline/6_create_breakpoints_refactoring:4825 e7755896-6108-0410-9592-8049d3e74e28:/mirrors/gdb/trunk:182811
Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
---|---|---|
Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |