From: Thiago Jung Bauermann Date: Mon, 27 Dec 2010 13:49:45 +0000 (+0000) Subject: Code cleanup - renaming. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=35df450089f1876a8645a5ebf443a7c76367fcce;p=binutils-gdb.git Code cleanup - renaming. * breakpoint.c: Use bl for `*bp_location' variables, blp_tmp for `**bp_location' helper variables, b_tmp for `*breakpoint' helper variables. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 33f2d8f17be..51be0d254d3 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,12 @@ +2010-12-27 Jan Kratochvil + + Code cleanup - renaming. + * breakpoint.c: Use bl for `*bp_location' variables, blp_tmp for + `**bp_location' helper variables, b_tmp for `*breakpoint' helper + variables. + 2010-12-27 Kevin Buettner - Hui Zhu + Hui Zhu * mips-tedp.c (mips_register_name): Add comments. diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 6a51a3b3f6a..5736fbc0b63 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -1085,14 +1085,15 @@ bp_location_has_shadow (struct bp_location *bl) by replacing any memory breakpoints with their shadowed contents. The range of shadowed area by each bp_location is: - b->address - bp_location_placed_address_before_address_max - up to b->address + bp_location_shadow_len_after_address_max + bl->address - bp_location_placed_address_before_address_max + up to bl->address + bp_location_shadow_len_after_address_max The range we were requested to resolve shadows for is: memaddr ... memaddr + len Thus the safe cutoff boundaries for performance optimization are - memaddr + len <= b->address - bp_location_placed_address_before_address_max + memaddr + len <= (bl->address + - bp_location_placed_address_before_address_max) and: - b->address + bp_location_shadow_len_after_address_max <= memaddr */ + bl->address + bp_location_shadow_len_after_address_max <= memaddr */ void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len) @@ -1107,12 +1108,12 @@ breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len) bc_r = bp_location_count; while (bc_l + 1 < bc_r) { - struct bp_location *b; + struct bp_location *bl; bc = (bc_l + bc_r) / 2; - b = bp_location[bc]; + bl = bp_location[bc]; - /* Check first B->ADDRESS will not overflow due to the added constant. + /* Check first BL->ADDRESS will not overflow due to the added constant. Then advance the left boundary only if we are sure the BC element can in no way affect the BUF content (MEMADDR to MEMADDR + LEN range). @@ -1120,8 +1121,10 @@ breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len) we cannot miss a breakpoint with its shadow range tail still reaching MEMADDR. */ - if (b->address + bp_location_shadow_len_after_address_max >= b->address - && b->address + bp_location_shadow_len_after_address_max <= memaddr) + if ((bl->address + bp_location_shadow_len_after_address_max + >= bl->address) + && (bl->address + bp_location_shadow_len_after_address_max + <= memaddr)) bc_l = bc; else bc_r = bc; @@ -1131,34 +1134,34 @@ breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len) for (bc = bc_l; bc < bp_location_count; bc++) { - struct bp_location *b = bp_location[bc]; + struct bp_location *bl = bp_location[bc]; CORE_ADDR bp_addr = 0; int bp_size = 0; int bptoffset = 0; - /* bp_location array has B->OWNER always non-NULL. */ - if (b->owner->type == bp_none) + /* bp_location array has BL->OWNER always non-NULL. */ + if (bl->owner->type == bp_none) warning (_("reading through apparently deleted breakpoint #%d?"), - b->owner->number); + bl->owner->number); /* Performance optimization: any futher element can no longer affect BUF content. */ - if (b->address >= bp_location_placed_address_before_address_max - && memaddr + len <= b->address - - bp_location_placed_address_before_address_max) + if (bl->address >= bp_location_placed_address_before_address_max + && memaddr + len <= (bl->address + - bp_location_placed_address_before_address_max)) break; - if (!bp_location_has_shadow (b)) + if (!bp_location_has_shadow (bl)) continue; - if (!breakpoint_address_match (b->target_info.placed_address_space, 0, + if (!breakpoint_address_match (bl->target_info.placed_address_space, 0, current_program_space->aspace, 0)) continue; /* Addresses and length of the part of the breakpoint that we need to copy. */ - bp_addr = b->target_info.placed_address; - bp_size = b->target_info.shadow_len; + bp_addr = bl->target_info.placed_address; + bp_size = bl->target_info.shadow_len; if (bp_addr + bp_size <= memaddr) /* The breakpoint is entirely before the chunk of memory we @@ -1186,7 +1189,7 @@ breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len) } memcpy (buf + bp_addr - memaddr, - b->target_info.shadow_contents + bptoffset, bp_size); + bl->target_info.shadow_contents + bptoffset, bp_size); } } @@ -1518,15 +1521,15 @@ in which its expression is valid.\n"), /* Returns 1 iff breakpoint location should be inserted in the inferior. */ static int -should_be_inserted (struct bp_location *bpt) +should_be_inserted (struct bp_location *bl) { - if (bpt->owner == NULL || !breakpoint_enabled (bpt->owner)) + if (bl->owner == NULL || !breakpoint_enabled (bl->owner)) return 0; - if (bpt->owner->disposition == disp_del_at_next_stop) + if (bl->owner->disposition == disp_del_at_next_stop) return 0; - if (!bpt->enabled || bpt->shlib_disabled || bpt->duplicate) + if (!bl->enabled || bl->shlib_disabled || bl->duplicate) return 0; /* This is set for example, when we're attached to the parent of a @@ -1537,43 +1540,43 @@ should_be_inserted (struct bp_location *bpt) memory region, do not insert breakpoints in the parent, otherwise the child could still trip on the parent's breakpoints. Since the parent is blocked anyway, it won't miss any breakpoint. */ - if (bpt->pspace->breakpoints_not_allowed) + if (bl->pspace->breakpoints_not_allowed) return 0; /* Tracepoints are inserted by the target at a time of its choosing, not by us. */ - if (is_tracepoint (bpt->owner)) + if (is_tracepoint (bl->owner)) return 0; return 1; } -/* Insert a low-level "breakpoint" of some type. BPT is the breakpoint. - Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS, - and HW_BREAKPOINT_ERROR are used to report problems. +/* Insert a low-level "breakpoint" of some type. BL is the breakpoint + location. Any error messages are printed to TMP_ERROR_STREAM; and + DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems. NOTE drow/2003-09-09: This routine could be broken down to an object-style method for each breakpoint or catchpoint type. */ static int -insert_bp_location (struct bp_location *bpt, +insert_bp_location (struct bp_location *bl, struct ui_file *tmp_error_stream, int *disabled_breaks, int *hw_breakpoint_error) { int val = 0; - if (!should_be_inserted (bpt) || bpt->inserted) + if (!should_be_inserted (bl) || bl->inserted) return 0; /* Initialize the target-specific information. */ - memset (&bpt->target_info, 0, sizeof (bpt->target_info)); - bpt->target_info.placed_address = bpt->address; - bpt->target_info.placed_address_space = bpt->pspace->aspace; + memset (&bl->target_info, 0, sizeof (bl->target_info)); + bl->target_info.placed_address = bl->address; + bl->target_info.placed_address_space = bl->pspace->aspace; - if (bpt->loc_type == bp_loc_software_breakpoint - || bpt->loc_type == bp_loc_hardware_breakpoint) + if (bl->loc_type == bp_loc_software_breakpoint + || bl->loc_type == bp_loc_hardware_breakpoint) { - if (bpt->owner->type != bp_hardware_breakpoint) + if (bl->owner->type != bp_hardware_breakpoint) { /* If the explicitly specified breakpoint type is not hardware breakpoint, check the memory map to see @@ -1591,7 +1594,7 @@ insert_bp_location (struct bp_location *bpt, problem is that memory map has changed during running program, but it's not going to work anyway with current gdb. */ struct mem_region *mr - = lookup_mem_region (bpt->target_info.placed_address); + = lookup_mem_region (bl->target_info.placed_address); if (mr) { @@ -1604,11 +1607,11 @@ insert_bp_location (struct bp_location *bpt, else new_type = bp_loc_software_breakpoint; - if (new_type != bpt->loc_type) + if (new_type != bl->loc_type) { static int said = 0; - bpt->loc_type = new_type; + bl->loc_type = new_type; if (!said) { fprintf_filtered (gdb_stdout, _("\ @@ -1617,26 +1620,26 @@ Note: automatically using hardware breakpoints for read-only addresses.\n")); } } } - else if (bpt->loc_type == bp_loc_software_breakpoint + else if (bl->loc_type == bp_loc_software_breakpoint && mr->attrib.mode != MEM_RW) warning (_("cannot set software breakpoint at readonly address %s"), - paddress (bpt->gdbarch, bpt->address)); + paddress (bl->gdbarch, bl->address)); } } /* First check to see if we have to handle an overlay. */ if (overlay_debugging == ovly_off - || bpt->section == NULL - || !(section_is_overlay (bpt->section))) + || bl->section == NULL + || !(section_is_overlay (bl->section))) { /* No overlay handling: just set the breakpoint. */ - if (bpt->loc_type == bp_loc_hardware_breakpoint) - val = target_insert_hw_breakpoint (bpt->gdbarch, - &bpt->target_info); + if (bl->loc_type == bp_loc_hardware_breakpoint) + val = target_insert_hw_breakpoint (bl->gdbarch, + &bl->target_info); else - val = target_insert_breakpoint (bpt->gdbarch, - &bpt->target_info); + val = target_insert_breakpoint (bl->gdbarch, + &bl->target_info); } else { @@ -1647,34 +1650,34 @@ Note: automatically using hardware breakpoints for read-only addresses.\n")); /* Yes -- overlay event support is not active, so we must try to set a breakpoint at the LMA. This will not work for a hardware breakpoint. */ - if (bpt->loc_type == bp_loc_hardware_breakpoint) + if (bl->loc_type == bp_loc_hardware_breakpoint) warning (_("hardware breakpoint %d not supported in overlay!"), - bpt->owner->number); + bl->owner->number); else { - CORE_ADDR addr = overlay_unmapped_address (bpt->address, - bpt->section); + CORE_ADDR addr = overlay_unmapped_address (bl->address, + bl->section); /* Set a software (trap) breakpoint at the LMA. */ - bpt->overlay_target_info = bpt->target_info; - bpt->overlay_target_info.placed_address = addr; - val = target_insert_breakpoint (bpt->gdbarch, - &bpt->overlay_target_info); + bl->overlay_target_info = bl->target_info; + bl->overlay_target_info.placed_address = addr; + val = target_insert_breakpoint (bl->gdbarch, + &bl->overlay_target_info); if (val != 0) fprintf_unfiltered (tmp_error_stream, "Overlay breakpoint %d failed: in ROM?\n", - bpt->owner->number); + bl->owner->number); } } /* Shall we set a breakpoint at the VMA? */ - if (section_is_mapped (bpt->section)) + if (section_is_mapped (bl->section)) { /* Yes. This overlay section is mapped into memory. */ - if (bpt->loc_type == bp_loc_hardware_breakpoint) - val = target_insert_hw_breakpoint (bpt->gdbarch, - &bpt->target_info); + if (bl->loc_type == bp_loc_hardware_breakpoint) + val = target_insert_hw_breakpoint (bl->gdbarch, + &bl->target_info); else - val = target_insert_breakpoint (bpt->gdbarch, - &bpt->target_info); + val = target_insert_breakpoint (bl->gdbarch, + &bl->target_info); } else { @@ -1687,40 +1690,40 @@ Note: automatically using hardware breakpoints for read-only addresses.\n")); if (val) { /* Can't set the breakpoint. */ - if (solib_name_from_address (bpt->pspace, bpt->address)) + if (solib_name_from_address (bl->pspace, bl->address)) { /* See also: disable_breakpoints_in_shlibs. */ val = 0; - bpt->shlib_disabled = 1; + bl->shlib_disabled = 1; if (!*disabled_breaks) { fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", - bpt->owner->number); + bl->owner->number); fprintf_unfiltered (tmp_error_stream, "Temporarily disabling shared library breakpoints:\n"); } *disabled_breaks = 1; fprintf_unfiltered (tmp_error_stream, - "breakpoint #%d\n", bpt->owner->number); + "breakpoint #%d\n", bl->owner->number); } else { - if (bpt->loc_type == bp_loc_hardware_breakpoint) + if (bl->loc_type == bp_loc_hardware_breakpoint) { *hw_breakpoint_error = 1; fprintf_unfiltered (tmp_error_stream, "Cannot insert hardware breakpoint %d.\n", - bpt->owner->number); + bl->owner->number); } else { fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", - bpt->owner->number); + bl->owner->number); fprintf_filtered (tmp_error_stream, "Error accessing memory address "); - fputs_filtered (paddress (bpt->gdbarch, bpt->address), + fputs_filtered (paddress (bl->gdbarch, bl->address), tmp_error_stream); fprintf_filtered (tmp_error_stream, ": %s.\n", safe_strerror (val)); @@ -1729,24 +1732,24 @@ Note: automatically using hardware breakpoints for read-only addresses.\n")); } } else - bpt->inserted = 1; + bl->inserted = 1; return val; } - else if (bpt->loc_type == bp_loc_hardware_watchpoint + else if (bl->loc_type == bp_loc_hardware_watchpoint /* NOTE drow/2003-09-08: This state only exists for removing watchpoints. It's not clear that it's necessary... */ - && bpt->owner->disposition != disp_del_at_next_stop) + && bl->owner->disposition != disp_del_at_next_stop) { - val = target_insert_watchpoint (bpt->address, - bpt->length, - bpt->watchpoint_type, - bpt->owner->cond_exp); + val = target_insert_watchpoint (bl->address, + bl->length, + bl->watchpoint_type, + bl->owner->cond_exp); /* If trying to set a read-watchpoint, and it turns out it's not supported, try emulating one with an access watchpoint. */ - if (val == 1 && bpt->watchpoint_type == hw_read) + if (val == 1 && bl->watchpoint_type == hw_read) { struct bp_location *loc, **loc_temp; @@ -1754,42 +1757,42 @@ Note: automatically using hardware breakpoints for read-only addresses.\n")); hw_access location that would be considered a duplicate of this one. */ ALL_BP_LOCATIONS (loc, loc_temp) - if (loc != bpt + if (loc != bl && loc->watchpoint_type == hw_access - && watchpoint_locations_match (bpt, loc)) + && watchpoint_locations_match (bl, loc)) { - bpt->duplicate = 1; - bpt->inserted = 1; - bpt->target_info = loc->target_info; - bpt->watchpoint_type = hw_access; + bl->duplicate = 1; + bl->inserted = 1; + bl->target_info = loc->target_info; + bl->watchpoint_type = hw_access; val = 0; break; } if (val == 1) { - val = target_insert_watchpoint (bpt->address, - bpt->length, + val = target_insert_watchpoint (bl->address, + bl->length, hw_access, - bpt->owner->cond_exp); + bl->owner->cond_exp); if (val == 0) - bpt->watchpoint_type = hw_access; + bl->watchpoint_type = hw_access; } } - bpt->inserted = (val == 0); + bl->inserted = (val == 0); } - else if (bpt->owner->type == bp_catchpoint) + else if (bl->owner->type == bp_catchpoint) { struct gdb_exception e = catch_exception (uiout, insert_catchpoint, - bpt->owner, RETURN_MASK_ERROR); + bl->owner, RETURN_MASK_ERROR); exception_fprintf (gdb_stderr, e, "warning: inserting catchpoint %d: ", - bpt->owner->number); + bl->owner->number); if (e.reason < 0) - bpt->owner->enable_state = bp_disabled; + bl->owner->enable_state = bp_disabled; else - bpt->inserted = 1; + bl->inserted = 1; /* We've already printed an error message if there was a problem inserting this catchpoint, and we've disabled the catchpoint, @@ -1874,7 +1877,7 @@ static void insert_breakpoint_locations (void) { struct breakpoint *bpt; - struct bp_location *b, **bp_tmp; + struct bp_location *bl, **blp_tmp; int error = 0; int val = 0; int disabled_breaks = 0; @@ -1889,19 +1892,19 @@ insert_breakpoint_locations (void) save_current_space_and_thread (); - ALL_BP_LOCATIONS (b, bp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (!should_be_inserted (b) || b->inserted) + if (!should_be_inserted (bl) || bl->inserted) continue; /* There is no point inserting thread-specific breakpoints if the - thread no longer exists. ALL_BP_LOCATIONS bp_location has B->OWNER + thread no longer exists. ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */ - if (b->owner->thread != -1 - && !valid_thread_id (b->owner->thread)) + if (bl->owner->thread != -1 + && !valid_thread_id (bl->owner->thread)) continue; - switch_to_program_space_and_thread (b->pspace); + switch_to_program_space_and_thread (bl->pspace); /* For targets that support global breakpoints, there's no need to select an inferior to insert breakpoint to. In fact, even @@ -1911,8 +1914,7 @@ insert_breakpoint_locations (void) && ptid_equal (inferior_ptid, null_ptid)) continue; - val = insert_bp_location (b, tmp_error_stream, - &disabled_breaks, + val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks, &hw_breakpoint_error); if (val) error = val; @@ -1974,13 +1976,13 @@ You may have requested too many hardware breakpoints/watchpoints.\n"); int remove_breakpoints (void) { - struct bp_location *b, **bp_tmp; + struct bp_location *bl, **blp_tmp; int val = 0; - ALL_BP_LOCATIONS (b, bp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (b->inserted) - val |= remove_breakpoint (b, mark_uninserted); + if (bl->inserted) + val |= remove_breakpoint (bl, mark_uninserted); } return val; } @@ -1990,18 +1992,18 @@ remove_breakpoints (void) int remove_breakpoints_pid (int pid) { - struct bp_location *b, **b_tmp; + struct bp_location *bl, **blp_tmp; int val; struct inferior *inf = find_inferior_pid (pid); - ALL_BP_LOCATIONS (b, b_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (b->pspace != inf->pspace) + if (bl->pspace != inf->pspace) continue; - if (b->inserted) + if (bl->inserted) { - val = remove_breakpoint (b, mark_uninserted); + val = remove_breakpoint (bl, mark_uninserted); if (val != 0) return val; } @@ -2012,13 +2014,13 @@ remove_breakpoints_pid (int pid) int remove_hw_watchpoints (void) { - struct bp_location *b, **bp_tmp; + struct bp_location *bl, **blp_tmp; int val = 0; - ALL_BP_LOCATIONS (b, bp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint) - val |= remove_breakpoint (b, mark_uninserted); + if (bl->inserted && bl->loc_type == bp_loc_hardware_watchpoint) + val |= remove_breakpoint (bl, mark_uninserted); } return val; } @@ -2027,7 +2029,7 @@ int reattach_breakpoints (int pid) { struct cleanup *old_chain; - struct bp_location *b, **bp_tmp; + struct bp_location *bl, **blp_tmp; int val; struct ui_file *tmp_error_stream = mem_fileopen (); int dummy1 = 0, dummy2 = 0; @@ -2045,16 +2047,15 @@ reattach_breakpoints (int pid) make_cleanup_ui_file_delete (tmp_error_stream); - ALL_BP_LOCATIONS (b, bp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (b->pspace != inf->pspace) + if (bl->pspace != inf->pspace) continue; - if (b->inserted) + if (bl->inserted) { - b->inserted = 0; - val = insert_bp_location (b, tmp_error_stream, - &dummy1, &dummy2); + bl->inserted = 0; + val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2); if (val != 0) { do_cleanups (old_chain); @@ -2241,8 +2242,7 @@ create_exception_master_breakpoint (void) void update_breakpoints_after_exec (void) { - struct breakpoint *b; - struct breakpoint *temp; + struct breakpoint *b, *b_tmp; struct bp_location *bploc, **bplocp_tmp; /* We're about to delete breakpoints from GDB's lists. If the @@ -2257,7 +2257,7 @@ update_breakpoints_after_exec (void) if (bploc->pspace == current_program_space) gdb_assert (!bploc->inserted); - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { if (b->pspace != current_program_space) continue; @@ -2364,7 +2364,7 @@ update_breakpoints_after_exec (void) int detach_breakpoints (int pid) { - struct bp_location *b, **bp_tmp; + struct bp_location *bl, **blp_tmp; int val = 0; struct cleanup *old_chain = save_inferior_ptid (); struct inferior *inf = current_inferior (); @@ -2374,13 +2374,13 @@ detach_breakpoints (int pid) /* Set inferior_ptid; remove_breakpoint_1 uses this global. */ inferior_ptid = pid_to_ptid (pid); - ALL_BP_LOCATIONS (b, bp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (b->pspace != inf->pspace) + if (bl->pspace != inf->pspace) continue; - if (b->inserted) - val |= remove_breakpoint_1 (b, mark_inserted); + if (bl->inserted) + val |= remove_breakpoint_1 (bl, mark_inserted); } /* Detach single-step breakpoints as well. */ @@ -2390,30 +2390,30 @@ detach_breakpoints (int pid) return val; } -/* Remove the breakpoint location B from the current address space. +/* Remove the breakpoint location BL from the current address space. Note that this is used to detach breakpoints from a child fork. When we get here, the child isn't in the inferior list, and neither do we have objects to represent its address space --- we should - *not* look at b->pspace->aspace here. */ + *not* look at bl->pspace->aspace here. */ static int -remove_breakpoint_1 (struct bp_location *b, insertion_state_t is) +remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is) { int val; - /* B is never in moribund_locations by our callers. */ - gdb_assert (b->owner != NULL); + /* BL is never in moribund_locations by our callers. */ + gdb_assert (bl->owner != NULL); - if (b->owner->enable_state == bp_permanent) + if (bl->owner->enable_state == bp_permanent) /* Permanent breakpoints cannot be inserted or removed. */ return 0; /* The type of none suggests that owner is actually deleted. This should not ever happen. */ - gdb_assert (b->owner->type != bp_none); + gdb_assert (bl->owner->type != bp_none); - if (b->loc_type == bp_loc_software_breakpoint - || b->loc_type == bp_loc_hardware_breakpoint) + if (bl->loc_type == bp_loc_software_breakpoint + || bl->loc_type == bp_loc_hardware_breakpoint) { /* "Normal" instruction breakpoint: either the standard trap-instruction bp (bp_breakpoint), or a @@ -2421,15 +2421,15 @@ remove_breakpoint_1 (struct bp_location *b, insertion_state_t is) /* First check to see if we have to handle an overlay. */ if (overlay_debugging == ovly_off - || b->section == NULL - || !(section_is_overlay (b->section))) + || bl->section == NULL + || !(section_is_overlay (bl->section))) { /* No overlay handling: just remove the breakpoint. */ - if (b->loc_type == bp_loc_hardware_breakpoint) - val = target_remove_hw_breakpoint (b->gdbarch, &b->target_info); + if (bl->loc_type == bp_loc_hardware_breakpoint) + val = target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info); else - val = target_remove_breakpoint (b->gdbarch, &b->target_info); + val = target_remove_breakpoint (bl->gdbarch, &bl->target_info); } else { @@ -2442,31 +2442,31 @@ remove_breakpoint_1 (struct bp_location *b, insertion_state_t is) */ /* Ignore any failures: if the LMA is in ROM, we will have already warned when we failed to insert it. */ - if (b->loc_type == bp_loc_hardware_breakpoint) - target_remove_hw_breakpoint (b->gdbarch, - &b->overlay_target_info); + if (bl->loc_type == bp_loc_hardware_breakpoint) + target_remove_hw_breakpoint (bl->gdbarch, + &bl->overlay_target_info); else - target_remove_breakpoint (b->gdbarch, - &b->overlay_target_info); + target_remove_breakpoint (bl->gdbarch, + &bl->overlay_target_info); } /* Did we set a breakpoint at the VMA? If so, we will have marked the breakpoint 'inserted'. */ - if (b->inserted) + if (bl->inserted) { /* Yes -- remove it. Previously we did not bother to remove the breakpoint if the section had been unmapped, but let's not rely on that being safe. We don't know what the overlay manager might do. */ - if (b->loc_type == bp_loc_hardware_breakpoint) - val = target_remove_hw_breakpoint (b->gdbarch, - &b->target_info); + if (bl->loc_type == bp_loc_hardware_breakpoint) + val = target_remove_hw_breakpoint (bl->gdbarch, + &bl->target_info); /* However, we should remove *software* breakpoints only if the section is still mapped, or else we overwrite wrong code with the saved shadow contents. */ - else if (section_is_mapped (b->section)) - val = target_remove_breakpoint (b->gdbarch, - &b->target_info); + else if (section_is_mapped (bl->section)) + val = target_remove_breakpoint (bl->gdbarch, + &bl->target_info); else val = 0; } @@ -2480,61 +2480,61 @@ remove_breakpoint_1 (struct bp_location *b, insertion_state_t is) /* In some cases, we might not be able to remove a breakpoint in a shared library that has already been removed, but we have not yet processed the shlib unload event. */ - if (val && solib_name_from_address (b->pspace, b->address)) + if (val && solib_name_from_address (bl->pspace, bl->address)) val = 0; if (val) return val; - b->inserted = (is == mark_inserted); + bl->inserted = (is == mark_inserted); } - else if (b->loc_type == bp_loc_hardware_watchpoint) + else if (bl->loc_type == bp_loc_hardware_watchpoint) { - b->inserted = (is == mark_inserted); - val = target_remove_watchpoint (b->address, b->length, - b->watchpoint_type, b->owner->cond_exp); + bl->inserted = (is == mark_inserted); + val = target_remove_watchpoint (bl->address, bl->length, + bl->watchpoint_type, bl->owner->cond_exp); /* Failure to remove any of the hardware watchpoints comes here. */ - if ((is == mark_uninserted) && (b->inserted)) + if ((is == mark_uninserted) && (bl->inserted)) warning (_("Could not remove hardware watchpoint %d."), - b->owner->number); + bl->owner->number); } - else if (b->owner->type == bp_catchpoint - && breakpoint_enabled (b->owner) - && !b->duplicate) + else if (bl->owner->type == bp_catchpoint + && breakpoint_enabled (bl->owner) + && !bl->duplicate) { - gdb_assert (b->owner->ops != NULL && b->owner->ops->remove != NULL); + gdb_assert (bl->owner->ops != NULL && bl->owner->ops->remove != NULL); - val = b->owner->ops->remove (b->owner); + val = bl->owner->ops->remove (bl->owner); if (val) return val; - b->inserted = (is == mark_inserted); + bl->inserted = (is == mark_inserted); } return 0; } static int -remove_breakpoint (struct bp_location *b, insertion_state_t is) +remove_breakpoint (struct bp_location *bl, insertion_state_t is) { int ret; struct cleanup *old_chain; - /* B is never in moribund_locations by our callers. */ - gdb_assert (b->owner != NULL); + /* BL is never in moribund_locations by our callers. */ + gdb_assert (bl->owner != NULL); - if (b->owner->enable_state == bp_permanent) + if (bl->owner->enable_state == bp_permanent) /* Permanent breakpoints cannot be inserted or removed. */ return 0; /* The type of none suggests that owner is actually deleted. This should not ever happen. */ - gdb_assert (b->owner->type != bp_none); + gdb_assert (bl->owner->type != bp_none); old_chain = save_current_space_and_thread (); - switch_to_program_space_and_thread (b->pspace); + switch_to_program_space_and_thread (bl->pspace); - ret = remove_breakpoint_1 (b, is); + ret = remove_breakpoint_1 (bl, is); do_cleanups (old_chain); return ret; @@ -2545,11 +2545,11 @@ remove_breakpoint (struct bp_location *b, insertion_state_t is) void mark_breakpoints_out (void) { - struct bp_location *bpt, **bptp_tmp; + struct bp_location *bl, **blp_tmp; - ALL_BP_LOCATIONS (bpt, bptp_tmp) - if (bpt->pspace == current_program_space) - bpt->inserted = 0; + ALL_BP_LOCATIONS (bl, blp_tmp) + if (bl->pspace == current_program_space) + bl->inserted = 0; } /* Clear the "inserted" flag in all breakpoints and delete any @@ -2567,8 +2567,8 @@ mark_breakpoints_out (void) void breakpoint_init_inferior (enum inf_context context) { - struct breakpoint *b, *temp; - struct bp_location *bpt, **bptp_tmp; + struct breakpoint *b, *b_tmp; + struct bp_location *bl, **blp_tmp; int ix; struct program_space *pspace = current_program_space; @@ -2577,15 +2577,15 @@ breakpoint_init_inferior (enum inf_context context) if (gdbarch_has_global_breakpoints (target_gdbarch)) return; - ALL_BP_LOCATIONS (bpt, bptp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */ - if (bpt->pspace == pspace - && bpt->owner->enable_state != bp_permanent) - bpt->inserted = 0; + /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */ + if (bl->pspace == pspace + && bl->owner->enable_state != bp_permanent) + bl->inserted = 0; } - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { if (b->loc && b->loc->pspace != pspace) continue; @@ -2645,8 +2645,8 @@ breakpoint_init_inferior (enum inf_context context) } /* Get rid of the moribund locations. */ - for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bpt); ++ix) - decref_bp_location (&bpt); + for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix) + decref_bp_location (&bl); VEC_free (bp_location_p, moribund_locations); } @@ -2668,26 +2668,26 @@ breakpoint_init_inferior (enum inf_context context) enum breakpoint_here breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc) { - struct bp_location *bpt, **bptp_tmp; + struct bp_location *bl, **blp_tmp; int any_breakpoint_here = 0; - ALL_BP_LOCATIONS (bpt, bptp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (bpt->loc_type != bp_loc_software_breakpoint - && bpt->loc_type != bp_loc_hardware_breakpoint) + if (bl->loc_type != bp_loc_software_breakpoint + && bl->loc_type != bp_loc_hardware_breakpoint) continue; - /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */ - if ((breakpoint_enabled (bpt->owner) - || bpt->owner->enable_state == bp_permanent) - && breakpoint_address_match (bpt->pspace->aspace, bpt->address, + /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */ + if ((breakpoint_enabled (bl->owner) + || bl->owner->enable_state == bp_permanent) + && breakpoint_address_match (bl->pspace->aspace, bl->address, aspace, pc)) { if (overlay_debugging - && section_is_overlay (bpt->section) - && !section_is_mapped (bpt->section)) + && section_is_overlay (bl->section) + && !section_is_mapped (bl->section)) continue; /* unmapped overlay -- can't be a match */ - else if (bpt->owner->enable_state == bp_permanent) + else if (bl->owner->enable_state == bp_permanent) return permanent_breakpoint_here; else any_breakpoint_here = 1; @@ -2721,21 +2721,21 @@ moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc) int regular_breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc) { - struct bp_location *bpt, **bptp_tmp; + struct bp_location *bl, **blp_tmp; - ALL_BP_LOCATIONS (bpt, bptp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (bpt->loc_type != bp_loc_software_breakpoint - && bpt->loc_type != bp_loc_hardware_breakpoint) + if (bl->loc_type != bp_loc_software_breakpoint + && bl->loc_type != bp_loc_hardware_breakpoint) continue; - if (bpt->inserted - && breakpoint_address_match (bpt->pspace->aspace, bpt->address, + if (bl->inserted + && breakpoint_address_match (bl->pspace->aspace, bl->address, aspace, pc)) { if (overlay_debugging - && section_is_overlay (bpt->section) - && !section_is_mapped (bpt->section)) + && section_is_overlay (bl->section) + && !section_is_mapped (bl->section)) continue; /* unmapped overlay -- can't be a match */ else return 1; @@ -2765,20 +2765,20 @@ breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc) int software_breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc) { - struct bp_location *bpt, **bptp_tmp; + struct bp_location *bl, **blp_tmp; - ALL_BP_LOCATIONS (bpt, bptp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (bpt->loc_type != bp_loc_software_breakpoint) + if (bl->loc_type != bp_loc_software_breakpoint) continue; - if (bpt->inserted - && breakpoint_address_match (bpt->pspace->aspace, bpt->address, + if (bl->inserted + && breakpoint_address_match (bl->pspace->aspace, bl->address, aspace, pc)) { if (overlay_debugging - && section_is_overlay (bpt->section) - && !section_is_mapped (bpt->section)) + && section_is_overlay (bl->section) + && !section_is_mapped (bl->section)) continue; /* unmapped overlay -- can't be a match */ else return 1; @@ -2831,51 +2831,51 @@ int breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc, ptid_t ptid) { - struct bp_location *bpt, **bptp_tmp; + struct bp_location *bl, **blp_tmp; /* The thread and task IDs associated to PTID, computed lazily. */ int thread = -1; int task = 0; - ALL_BP_LOCATIONS (bpt, bptp_tmp) + ALL_BP_LOCATIONS (bl, blp_tmp) { - if (bpt->loc_type != bp_loc_software_breakpoint - && bpt->loc_type != bp_loc_hardware_breakpoint) + if (bl->loc_type != bp_loc_software_breakpoint + && bl->loc_type != bp_loc_hardware_breakpoint) continue; - /* ALL_BP_LOCATIONS bp_location has BPT->OWNER always non-NULL. */ - if (!breakpoint_enabled (bpt->owner) - && bpt->owner->enable_state != bp_permanent) + /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */ + if (!breakpoint_enabled (bl->owner) + && bl->owner->enable_state != bp_permanent) continue; - if (!breakpoint_address_match (bpt->pspace->aspace, bpt->address, + if (!breakpoint_address_match (bl->pspace->aspace, bl->address, aspace, pc)) continue; - if (bpt->owner->thread != -1) + if (bl->owner->thread != -1) { /* This is a thread-specific breakpoint. Check that ptid matches that thread. If thread hasn't been computed yet, it is now time to do so. */ if (thread == -1) thread = pid_to_thread_id (ptid); - if (bpt->owner->thread != thread) + if (bl->owner->thread != thread) continue; } - if (bpt->owner->task != 0) + if (bl->owner->task != 0) { /* This is a task-specific breakpoint. Check that ptid matches that task. If task hasn't been computed yet, it is now time to do so. */ if (task == 0) task = ada_get_task_number (ptid); - if (bpt->owner->task != task) + if (bl->owner->task != task) continue; } if (overlay_debugging - && section_is_overlay (bpt->section) - && !section_is_mapped (bpt->section)) + && section_is_overlay (bl->section) + && !section_is_mapped (bl->section)) continue; /* unmapped overlay -- can't be a match */ return 1; @@ -3745,7 +3745,7 @@ bpstat_check_location (const struct bp_location *bl, aspace, bp_addr)) return 0; if (overlay_debugging /* unmapped overlay section */ - && section_is_overlay (bl->section) + && section_is_overlay (bl->section) && !section_is_mapped (bl->section)) return 0; } @@ -3766,7 +3766,7 @@ bpstat_check_location (const struct bp_location *bl, if (bl->address != bp_addr) return 0; if (overlay_debugging /* unmapped overlay section */ - && section_is_overlay (bl->section) + && section_is_overlay (bl->section) && !section_is_mapped (bl->section)) return 0; } @@ -5667,14 +5667,14 @@ make_breakpoint_permanent (struct breakpoint *b) void set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; int thread = tp->num; /* To avoid having to rescan all objfile symbols at every step, we maintain a list of continually-inserted but always disabled longjmp "master" breakpoints. Here, we simply create momentary clones of those and enable them for the requested thread. */ - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) if (b->pspace == current_program_space && (b->type == bp_longjmp_master || b->type == bp_exception_master)) @@ -5692,9 +5692,9 @@ set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame) void delete_longjmp_breakpoint (int thread) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) if (b->type == bp_longjmp || b->type == bp_exception) { if (b->thread == thread) @@ -5735,9 +5735,9 @@ disable_overlay_breakpoints (void) void set_std_terminate_breakpoint (void) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) if (b->pspace == current_program_space && b->type == bp_std_terminate_master) { @@ -5750,9 +5750,9 @@ set_std_terminate_breakpoint (void) void delete_std_terminate_breakpoint (void) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) if (b->type == bp_std_terminate) delete_breakpoint (b); } @@ -5777,9 +5777,9 @@ create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address) void remove_thread_event_breakpoints (void) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) if (b->type == bp_thread_event && b->loc->pspace == current_program_space) delete_breakpoint (b); @@ -5814,9 +5814,9 @@ create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address) void remove_solib_event_breakpoints (void) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) if (b->type == bp_shlib_event && b->loc->pspace == current_program_space) delete_breakpoint (b); @@ -9314,7 +9314,7 @@ clear_command (char *arg, int from_tty) void breakpoint_auto_delete (bpstat bs) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; for (; bs; bs = bs->next) if (bs->breakpoint_at @@ -9322,7 +9322,7 @@ breakpoint_auto_delete (bpstat bs) && bs->stop) delete_breakpoint (bs->breakpoint_at); - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { if (b->disposition == disp_del_at_next_stop) delete_breakpoint (b); @@ -9873,7 +9873,7 @@ do_delete_breakpoint (struct breakpoint *b, void *ignore) void delete_command (char *arg, int from_tty) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; dont_repeat (); @@ -9906,7 +9906,7 @@ delete_command (char *arg, int from_tty) if (!from_tty || (breaks_to_delete && query (_("Delete all breakpoints? ")))) { - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { if (b->type != bp_call_dummy && b->type != bp_std_terminate @@ -10415,7 +10415,7 @@ breakpoint_re_set_one (void *bint) void breakpoint_re_set (void) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; enum language save_language; int save_input_radix; struct cleanup *old_chain; @@ -10424,7 +10424,7 @@ breakpoint_re_set (void) save_input_radix = input_radix; old_chain = save_current_program_space (); - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { /* Format possible error msg */ char *message = xstrprintf ("Error in re-setting breakpoint %d: ", @@ -11315,7 +11315,7 @@ disable_trace_command (char *args, int from_tty) static void delete_trace_command (char *arg, int from_tty) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; dont_repeat (); @@ -11339,7 +11339,7 @@ delete_trace_command (char *arg, int from_tty) if (!from_tty || (breaks_to_delete && query (_("Delete all tracepoints? ")))) { - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { if (is_tracepoint (b) && b->number >= 0) @@ -11757,9 +11757,9 @@ struct breakpoint * iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *), void *data) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; - ALL_BREAKPOINTS_SAFE (b, temp) + ALL_BREAKPOINTS_SAFE (b, b_tmp) { if ((*callback) (b, data)) return b;