From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 18769 invoked by alias); 17 Nov 2010 00:13:39 -0000 Received: (qmail 18752 invoked by uid 22791); 17 Nov 2010 00:13:37 -0000 X-SWARE-Spam-Status: No, hits=3.5 required=5.0 tests=AWL,BAYES_20,MIME_BASE64_BLANKS,RFC_ABUSE_POST,SPF_HELO_PASS,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mailout1.samsung.com (HELO mailout1.samsung.com) (203.254.224.24) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 17 Nov 2010 00:13:32 +0000 Received: from epms1.samsung.com (mailout1.samsung.com [203.254.224.24]) by mailout1.samsung.com (Oracle Communications Messaging Exchange Server 7u4-19.01 64bit (built Sep 7 2010)) with ESMTP id <0LC00084J5YESHC0@mailout1.samsung.com> for gdb-patches@sourceware.org; Wed, 17 Nov 2010 09:13:26 +0900 (KST) Received: from epv6spt1 ("port 21374"@[203.254.225.172]) by ms1.samsung.com (Sun Java(tm) System Messaging Server 7u3-15.01 64bit (built Feb 12 2010)) with ESMTP id <0LC0009DF5YD0X70@ms1.samsung.com> for gdb-patches@sourceware.org; Wed, 17 Nov 2010 09:13:26 +0900 (KST) Date: Wed, 17 Nov 2010 00:13:00 -0000 From: JuYoung Kim Subject: Re: Re: Re: [patch]change dwarf2_start_subfile() to adapt inappropriate dir name To: Joel Brobecker Cc: Eli Zaretskii , "gdb-patches@sourceware.org" Reply-to: j0.kim@samsung.com MIME-version: 1.0 X-MTR: 20101117000315499@j0.kim Msgkey: 20101117000315499@j0.kim X-EPLocale: ko_KR.utf-8 X-EPWebmail-Msg-Type: personal X-EPWebmail-Reply-Demand: 0 X-EPApproval-Locale: X-EPHeader: ML X-EPTrCode: X-EPTrName: X-MLAttribute: X-RootMTR: 20101117000315499@j0.kim X-ParentMTR: Content-transfer-encoding: base64 Content-type: text/plain; charset=utf-8 MIME-version: 1.0 Message-id: <21410336.44431289952805399.JavaMail.weblogic@epml19> X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2010-11/txt/msg00221.txt.bz2 PiBGb3IgcHJvcGVyIHN1Ym1pc3Npb24gb2YgcGF0Y2hlcyB0byB0aGUgR0RC IHByb2plY3QsIHBsZWFzZSB0YWtlIGEgbG9vawo+IGF0IHRoZSBmaWxlIG5h bWVkIGdkYi9DT05UUklCVVRFLiAgRm9yIHRoZSBwYXRjaCwgbW9zdCBvZiB1 cyBwcmVmZXIKPiB1bmlmaWVkIGRpZmZzICh1c2UgImRpZmYgLXUiIGFzIG9w cG9zZWQgdG8gImRpZmYgLWMiKS4KCj4gTGFzdCBxdWVzdGlvbjogSXMgeW91 ciBtYWlsZXIgY2FwYWJsZSBvZiBrZWVwaW5nIHRoZSBlbWFpbCB0aHJlYWRp bmcKPiBpbmZvcm1hdGlvbj8KCllvdSBjYW4gY2FsbCBtZSBKdVlvdW5nLiAK CkkgaGF2ZSB0cm91YmxlIHdpdGggdGhlIGN2cyBzZXJ2ZXIsIGJlY2F1c2Ug bXkgY29tcGFueSdzIGZpcmV3YWxsIGRvZXNuJ3QgYWxsb3cgbWUgdG8gY29u bmVjdCBpdC4KSW5zdGVhZCBvZiBtZSwgeW91IG9yIHNvbWVvbmUgY2FuIGNv bW1pdCB0aGlzIHBhdGNoLCBJIGhvcGUuCgpNeSBtYWlsZXIgZG9lc24ndCBz dXBwb3J0IHRoZSBlbWFpbCB0aHJlYWRpbmcuCk1heWJlIEknbGwgY2hhbmdl IG15IGVtYWlsIGFkZHJlc3MuCgpUaGFua3MuCg== >From gdb-patches-return-76465-listarch-gdb-patches=sources.redhat.com@sourceware.org Wed Nov 17 03:47:04 2010 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 21030 invoked by alias); 17 Nov 2010 03:47:03 -0000 Received: (qmail 21005 invoked by uid 22791); 17 Nov 2010 03:46:55 -0000 X-SWARE-Spam-Status: No, hits=-6.0 required=5.0 tests=AWL,BAYES_00,RCVD_IN_DNSWL_HI,SPF_HELO_PASS,TW_BJ,TW_BL,TW_CP,TW_GJ,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 17 Nov 2010 03:46:45 +0000 Received: from int-mx01.intmail.prod.int.phx2.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id oAH3kDmu029903 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Tue, 16 Nov 2010 22:46:13 -0500 Received: from host0.dyn.jankratochvil.net (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx01.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id oAH3k8At025392 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NO); Tue, 16 Nov 2010 22:46:12 -0500 Received: from host0.dyn.jankratochvil.net (localhost.localdomain [127.0.0.1]) by host0.dyn.jankratochvil.net (8.14.4/8.14.4) with ESMTP id oAH3k6eK025334; Wed, 17 Nov 2010 04:46:06 +0100 Received: (from jkratoch@localhost) by host0.dyn.jankratochvil.net (8.14.4/8.14.4/Submit) id oAH3juGE025333; Wed, 17 Nov 2010 04:45:56 +0100 Date: Wed, 17 Nov 2010 03:47:00 -0000 From: Jan Kratochvil To: Joel Brobecker Cc: Thiago Jung Bauermann , Pedro Alves , gdb-patches@sourceware.org Subject: [patch] renaming: bp_location: b->bl &co. [Re: [patch 1/2] Convert hardware watchpoints to use breakpoint_ops] Message-ID: <20101117034556.GA12159@host0.dyn.jankratochvil.net> References: <1282074071.2606.702.camel@hactar> <201010161843.43062.pedro@codesourcery.com> <1287534691.2686.17.camel@hactar> <20101116040625.GB19243@host0.dyn.jankratochvil.net> <20101116080721.GC4434@adacore.com> <20101116185101.GA32061@host0.dyn.jankratochvil.net> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20101116185101.GA32061@host0.dyn.jankratochvil.net> User-Agent: Mutt/1.5.21 (2010-09-15) X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org X-SW-Source: 2010-11/txt/msg00222.txt.bz2 Content-length: 47624 On Tue, 16 Nov 2010 19:51:01 +0100, Jan Kratochvil wrote: > On Tue, 16 Nov 2010 09:07:21 +0100, Joel Brobecker wrote: > > How about doing such a rename as a patch on its own? > > OK, going to send one today. I haven't written a ChangeLog entry but the change safety has been verified by stripped code differences. Still GDB compiles out line numbers and assert expressions so some of the differences were roughly checked in objdump -d they are safe. I will check it in after the Thiago's check-in. Regards, Jan gdb/ 2010-11-17 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. --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -1087,14 +1087,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) @@ -1109,12 +1110,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). @@ -1122,8 +1123,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; @@ -1133,34 +1136,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 @@ -1188,7 +1191,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); } } @@ -1533,15 +1536,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 @@ -1552,43 +1555,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 @@ -1606,7 +1609,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) { @@ -1619,11 +1622,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, _("\ @@ -1632,26 +1635,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 { @@ -1662,34 +1665,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 { @@ -1702,40 +1705,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)); @@ -1744,21 +1747,21 @@ 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 = bpt->owner->ops->insert (bpt); + val = bl->owner->ops->insert (bl); /* 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; @@ -1766,50 +1769,50 @@ 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) { - bpt->watchpoint_type = hw_access; - val = bpt->owner->ops->insert (bpt); + bl->watchpoint_type = hw_access; + val = bl->owner->ops->insert (bl); if (val) /* Back to the original value. */ - bpt->watchpoint_type = hw_read; + bl->watchpoint_type = hw_read; } } - bpt->inserted = (val == 0); + bl->inserted = (val == 0); } - else if (bpt->owner->type == bp_catchpoint) + else if (bl->owner->type == bp_catchpoint) { - gdb_assert (bpt->owner->ops != NULL && bpt->owner->ops->insert != NULL); + gdb_assert (bl->owner->ops != NULL && bl->owner->ops->insert != NULL); - val = bpt->owner->ops->insert (bpt); + val = bl->owner->ops->insert (bl); if (val) { - bpt->owner->enable_state = bp_disabled; + bl->owner->enable_state = bp_disabled; if (val == 1) warning (_("\ Inserting catchpoint %d: Your system does not support this type of catchpoint."), - bpt->owner->number); + bl->owner->number); else - warning (_("Error inserting catchpoint %d."), bpt->owner->number); + warning (_("Error inserting catchpoint %d."), bl->owner->number); } - bpt->inserted = (val == 0); + bl->inserted = (val == 0); /* We've already printed an error message if there was a problem inserting this catchpoint, and we've disabled the catchpoint, @@ -1894,7 +1897,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; @@ -1909,19 +1912,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 @@ -1931,8 +1934,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; @@ -1994,13 +1996,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; } @@ -2010,18 +2012,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; } @@ -2032,13 +2034,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; } @@ -2047,7 +2049,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; @@ -2065,16 +2067,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); @@ -2232,8 +2233,7 @@ create_std_terminate_master_breakpoint (const char *func_name) 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 @@ -2248,7 +2248,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; @@ -2352,7 +2352,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 (); @@ -2362,13 +2362,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. */ @@ -2378,30 +2378,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 @@ -2409,15 +2409,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 { @@ -2430,31 +2430,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; } @@ -2468,61 +2468,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); - b->owner->ops->remove (b); + bl->inserted = (is == mark_inserted); + bl->owner->ops->remove (bl); /* 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); + val = bl->owner->ops->remove (bl); 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; @@ -2533,11 +2533,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 @@ -2555,8 +2555,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; @@ -2565,15 +2565,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; @@ -2633,8 +2633,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); } @@ -2656,26 +2656,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; @@ -2709,21 +2709,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; @@ -2753,20 +2753,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; @@ -2819,51 +2819,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; @@ -5654,13 +5654,13 @@ make_breakpoint_permanent (struct breakpoint *b) void set_longjmp_breakpoint (int thread) { - struct breakpoint *b, *temp; + struct breakpoint *b, *b_tmp; /* 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) { @@ -5675,9 +5675,9 @@ set_longjmp_breakpoint (int thread) 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) { if (b->thread == thread) @@ -5718,9 +5718,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) { @@ -5733,9 +5733,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); } @@ -5760,9 +5760,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); @@ -5797,9 +5797,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); @@ -5903,7 +5903,7 @@ disable_breakpoints_in_unloaded_shlib (struct so_list *solib) /* Implement the "insert" breakpoint_ops method for fork catchpoints. */ static int -insert_catch_fork (struct bp_location *b) +insert_catch_fork (struct bp_location *bl) { return target_insert_fork_catchpoint (PIDGET (inferior_ptid)); } @@ -5911,7 +5911,7 @@ insert_catch_fork (struct bp_location *b) /* Implement the "remove" breakpoint_ops method for fork catchpoints. */ static int -remove_catch_fork (struct bp_location *b) +remove_catch_fork (struct bp_location *bl) { return target_remove_fork_catchpoint (PIDGET (inferior_ptid)); } @@ -5998,7 +5998,7 @@ static struct breakpoint_ops catch_fork_breakpoint_ops = /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */ static int -insert_catch_vfork (struct bp_location *b) +insert_catch_vfork (struct bp_location *bl) { return target_insert_vfork_catchpoint (PIDGET (inferior_ptid)); } @@ -6006,7 +6006,7 @@ insert_catch_vfork (struct bp_location *b) /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */ static int -remove_catch_vfork (struct bp_location *b) +remove_catch_vfork (struct bp_location *bl) { return target_remove_vfork_catchpoint (PIDGET (inferior_ptid)); } @@ -6093,19 +6093,19 @@ static struct breakpoint_ops catch_vfork_breakpoint_ops = catchpoints. */ static int -insert_catch_syscall (struct bp_location *b) +insert_catch_syscall (struct bp_location *bl) { struct inferior *inf = current_inferior (); ++inf->total_syscalls_count; - if (!b->owner->syscalls_to_be_caught) + if (!bl->owner->syscalls_to_be_caught) ++inf->any_syscall_count; else { int i, iter; for (i = 0; - VEC_iterate (int, b->owner->syscalls_to_be_caught, i, iter); + VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter); i++) { int elem; @@ -6137,19 +6137,19 @@ insert_catch_syscall (struct bp_location *b) catchpoints. */ static int -remove_catch_syscall (struct bp_location *b) +remove_catch_syscall (struct bp_location *bl) { struct inferior *inf = current_inferior (); --inf->total_syscalls_count; - if (!b->owner->syscalls_to_be_caught) + if (!bl->owner->syscalls_to_be_caught) --inf->any_syscall_count; else { int i, iter; for (i = 0; - VEC_iterate (int, b->owner->syscalls_to_be_caught, i, iter); + VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter); i++) { int elem; @@ -6452,13 +6452,13 @@ create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch, /* Exec catchpoints. */ static int -insert_catch_exec (struct bp_location *b) +insert_catch_exec (struct bp_location *bl) { return target_insert_exec_catchpoint (PIDGET (inferior_ptid)); } static int -remove_catch_exec (struct bp_location *b) +remove_catch_exec (struct bp_location *bl) { return target_remove_exec_catchpoint (PIDGET (inferior_ptid)); } @@ -8115,19 +8115,19 @@ watchpoint_exp_is_const (const struct expression *exp) /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */ static int -insert_watchpoint (struct bp_location *bpt) +insert_watchpoint (struct bp_location *bl) { - return target_insert_watchpoint (bpt->address, bpt->length, - bpt->watchpoint_type, bpt->owner->cond_exp); + return target_insert_watchpoint (bl->address, bl->length, + bl->watchpoint_type, bl->owner->cond_exp); } /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */ static int -remove_watchpoint (struct bp_location *bpt) +remove_watchpoint (struct bp_location *bl) { - return target_remove_watchpoint (bpt->address, bpt->length, - bpt->watchpoint_type, bpt->owner->cond_exp); + return target_remove_watchpoint (bl->address, bl->length, + bl->watchpoint_type, bl->owner->cond_exp); } /* The breakpoint_ops structure to be used in hardware watchpoints. */ @@ -8150,21 +8150,20 @@ static struct breakpoint_ops watchpoint_breakpoint_ops = ranged hardware watchpoints. */ static int -insert_ranged_watchpoint (struct bp_location *bpt) +insert_ranged_watchpoint (struct bp_location *bl) { - return target_insert_ranged_watchpoint (bpt->address, - bpt->length, - bpt->watchpoint_type); + return target_insert_ranged_watchpoint (bl->address, bl->length, + bl->watchpoint_type); } /* Implement the "remove" breakpoint_ops method for ranged hardware watchpoints. */ static int -remove_ranged_watchpoint (struct bp_location *bpt) +remove_ranged_watchpoint (struct bp_location *bl) { - return target_remove_ranged_watchpoint (bpt->address, bpt->length, - bpt->watchpoint_type); + return target_remove_ranged_watchpoint (bl->address, bl->length, + bl->watchpoint_type); } /* Implement the "extra_resources_needed" breakpoint_ops method for @@ -8295,20 +8294,20 @@ static struct breakpoint_ops ranged_watchpoint_breakpoint_ops = masked hardware watchpoints. */ static int -insert_masked_watchpoint (struct bp_location *bpt) +insert_masked_watchpoint (struct bp_location *bl) { - return target_insert_mask_watchpoint (bpt->address, bpt->owner->hw_wp_mask, - bpt->watchpoint_type); + return target_insert_mask_watchpoint (bl->address, bl->owner->hw_wp_mask, + bl->watchpoint_type); } /* Implement the "remove" breakpoint_ops method for masked hardware watchpoints. */ static int -remove_masked_watchpoint (struct bp_location *bpt) +remove_masked_watchpoint (struct bp_location *bl) { - return target_remove_mask_watchpoint (bpt->address, bpt->owner->hw_wp_mask, - bpt->watchpoint_type); + return target_remove_mask_watchpoint (bl->address, bl->owner->hw_wp_mask, + bl->watchpoint_type); } /* Implement the "extra_resources_needed" breakpoint_ops method for @@ -9842,7 +9841,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 @@ -9850,7 +9849,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); @@ -10401,7 +10400,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 (); @@ -10433,7 +10432,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 @@ -10938,7 +10937,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; @@ -10947,7 +10946,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: ", @@ -11837,7 +11836,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 (); @@ -11861,7 +11860,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) @@ -12279,9 +12278,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;