From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9708 invoked by alias); 6 Nov 2007 12:05:04 -0000 Received: (qmail 9660 invoked by uid 22791); 6 Nov 2007 12:05:02 -0000 X-Spam-Check-By: sourceware.org Received: from mtagate3.de.ibm.com (HELO mtagate3.de.ibm.com) (195.212.29.152) by sourceware.org (qpsmtpd/0.31) with ESMTP; Tue, 06 Nov 2007 12:04:58 +0000 Received: from d12nrmr1607.megacenter.de.ibm.com (d12nrmr1607.megacenter.de.ibm.com [9.149.167.49]) by mtagate3.de.ibm.com (8.13.8/8.13.8) with ESMTP id lA6C4si4044692 for ; Tue, 6 Nov 2007 12:04:54 GMT Received: from d12av02.megacenter.de.ibm.com (d12av02.megacenter.de.ibm.com [9.149.165.228]) by d12nrmr1607.megacenter.de.ibm.com (8.13.8/8.13.8/NCO v8.6) with ESMTP id lA6C4sAK2179162 for ; Tue, 6 Nov 2007 13:04:54 +0100 Received: from d12av02.megacenter.de.ibm.com (loopback [127.0.0.1]) by d12av02.megacenter.de.ibm.com (8.12.11.20060308/8.13.3) with ESMTP id lA6C4rrT021617 for ; Tue, 6 Nov 2007 13:04:54 +0100 Received: from bbkeks.boeblingen.de.ibm.com (dyn-9-152-248-41.boeblingen.de.ibm.com [9.152.248.41]) by d12av02.megacenter.de.ibm.com (8.12.11.20060308/8.12.11) with ESMTP id lA6C4qPU021566 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NO); Tue, 6 Nov 2007 13:04:53 +0100 Message-ID: <473057FA.9080806@de.ibm.com> Date: Tue, 06 Nov 2007 12:05:00 -0000 From: Markus Deuling User-Agent: Thunderbird 2.0.0.6 (X11/20070728) MIME-Version: 1.0 To: Ulrich Weigand CC: GDB Patches Subject: Re: [rfc] [08/09] Get rid of current_gdbarch (infcall) References: <200711051633.lA5GXRTe027727@d12av02.megacenter.de.ibm.com> In-Reply-To: <200711051633.lA5GXRTe027727@d12av02.megacenter.de.ibm.com> Content-Type: multipart/mixed; boundary="------------040909010703050900000505" 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: 2007-11/txt/msg00092.txt.bz2 This is a multi-part message in MIME format. --------------040909010703050900000505 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 814 Ulrich Weigand schrieb: > Markus Deuling wrote: > >> * infcall.c (call_function_by_hand): Use get_frame_arch to get at the >> current architecture by frame_info. > > This part is fine. > > is defined for, determined at the time the value is generated. > > If we can make that happen, there will be no need to pass an additional > gdbarch parameter to find_function_addr. Thus, I'd prefer to defer this > interface change until we have resolved that question. Ok, then I withdraw this part of the patch. Attached is a new version with only the upper part. Tested by running testsuite on x86. Ok to commit? ChangeLog: * infcall.c (call_function_by_hand): Use get_frame_arch to get at the current architecture by frame_info. -- Markus Deuling GNU Toolchain for Linux on Cell BE deuling@de.ibm.com --------------040909010703050900000505 Content-Type: text/plain; name="diff-infcall" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="diff-infcall" Content-length: 8169 diff -urpN src/gdb/infcall.c dev/gdb/infcall.c --- src/gdb/infcall.c 2007-10-12 17:34:45.000000000 +0200 +++ dev/gdb/infcall.c 2007-11-06 10:23:52.000000000 +0100 @@ -354,6 +354,8 @@ call_function_by_hand (struct value *fun struct cleanup *caller_regcache_cleanup; struct frame_id dummy_id; struct cleanup *args_cleanup; + struct frame_info *frame; + struct gdbarch *gdbarch; if (TYPE_CODE (ftype) == TYPE_CODE_PTR) ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); @@ -361,14 +363,17 @@ call_function_by_hand (struct value *fun if (!target_has_execution) noprocess (); - if (!gdbarch_push_dummy_call_p (current_gdbarch)) + frame = get_current_frame (); + gdbarch = get_frame_arch (frame); + + if (!gdbarch_push_dummy_call_p (gdbarch)) error (_("This target does not support function calls")); /* Create a cleanup chain that contains the retbuf (buffer containing the register values). This chain is create BEFORE the inf_status chain so that the inferior status can cleaned up (restored or discarded) without having the retbuf freed. */ - retbuf = regcache_xmalloc (current_gdbarch); + retbuf = regcache_xmalloc (gdbarch); retbuf_cleanup = make_cleanup_regcache_xfree (retbuf); /* A cleanup for the inferior status. Create this AFTER the retbuf @@ -381,26 +386,26 @@ call_function_by_hand (struct value *fun callee returns. To allow nested calls the registers are (further down) pushed onto a dummy frame stack. Include a cleanup (which is tossed once the regcache has been pushed). */ - caller_regcache = frame_save_as_regcache (get_current_frame ()); + caller_regcache = frame_save_as_regcache (frame); caller_regcache_cleanup = make_cleanup_regcache_xfree (caller_regcache); /* Ensure that the initial SP is correctly aligned. */ { - CORE_ADDR old_sp = get_frame_sp (get_current_frame ()); - if (gdbarch_frame_align_p (current_gdbarch)) + CORE_ADDR old_sp = get_frame_sp (frame); + if (gdbarch_frame_align_p (gdbarch)) { - sp = gdbarch_frame_align (current_gdbarch, old_sp); + sp = gdbarch_frame_align (gdbarch, old_sp); /* NOTE: cagney/2003-08-13: Skip the "red zone". For some ABIs, a function can use memory beyond the inner most stack address. AMD64 called that region the "red zone". Skip at least the "red zone" size before allocating any space on the stack. */ - if (gdbarch_inner_than (current_gdbarch, 1, 2)) - sp -= gdbarch_frame_red_zone_size (current_gdbarch); + if (gdbarch_inner_than (gdbarch, 1, 2)) + sp -= gdbarch_frame_red_zone_size (gdbarch); else - sp += gdbarch_frame_red_zone_size (current_gdbarch); + sp += gdbarch_frame_red_zone_size (gdbarch); /* Still aligned? */ - gdb_assert (sp == gdbarch_frame_align (current_gdbarch, sp)); + gdb_assert (sp == gdbarch_frame_align (gdbarch, sp)); /* NOTE: cagney/2002-09-18: On a RISC architecture, a void parameterless generic dummy @@ -423,16 +428,16 @@ call_function_by_hand (struct value *fun to pay :-). */ if (sp == old_sp) { - if (gdbarch_inner_than (current_gdbarch, 1, 2)) + if (gdbarch_inner_than (gdbarch, 1, 2)) /* Stack grows down. */ - sp = gdbarch_frame_align (current_gdbarch, old_sp - 1); + sp = gdbarch_frame_align (gdbarch, old_sp - 1); else /* Stack grows up. */ - sp = gdbarch_frame_align (current_gdbarch, old_sp + 1); + sp = gdbarch_frame_align (gdbarch, old_sp + 1); } - gdb_assert ((gdbarch_inner_than (current_gdbarch, 1, 2) + gdb_assert ((gdbarch_inner_than (gdbarch, 1, 2) && sp <= old_sp) - || (gdbarch_inner_than (current_gdbarch, 2, 1) + || (gdbarch_inner_than (gdbarch, 2, 1) && sp >= old_sp)); } else @@ -488,14 +493,14 @@ call_function_by_hand (struct value *fun /* The actual breakpoint (at BP_ADDR) is inserted separatly so there is no need to write that out. */ - switch (gdbarch_call_dummy_location (current_gdbarch)) + switch (gdbarch_call_dummy_location (gdbarch)) { case ON_STACK: /* "dummy_addr" is here just to keep old targets happy. New targets return that same information via "sp" and "bp_addr". */ - if (gdbarch_inner_than (current_gdbarch, 1, 2)) + if (gdbarch_inner_than (gdbarch, 1, 2)) { - sp = push_dummy_code (current_gdbarch, sp, funaddr, + sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs, target_values_type, &real_pc, &bp_addr, get_current_regcache ()); dummy_addr = sp; @@ -503,7 +508,7 @@ call_function_by_hand (struct value *fun else { dummy_addr = sp; - sp = push_dummy_code (current_gdbarch, sp, funaddr, + sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs, target_values_type, &real_pc, &bp_addr, get_current_regcache ()); } @@ -513,7 +518,7 @@ call_function_by_hand (struct value *fun dummy_addr = entry_point_address (); /* Make certain that the address points at real code, and not a function descriptor. */ - dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, + dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, dummy_addr, ¤t_target); /* A call dummy always consists of just a single breakpoint, so @@ -536,7 +541,7 @@ call_function_by_hand (struct value *fun dummy_addr = entry_point_address (); /* Make certain that the address points at real code, and not a function descriptor. */ - dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, + dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, dummy_addr, ¤t_target); /* A call dummy always consists of just a single breakpoint, @@ -586,25 +591,25 @@ call_function_by_hand (struct value *fun if (struct_return || lang_struct_return) { int len = TYPE_LENGTH (values_type); - if (gdbarch_inner_than (current_gdbarch, 1, 2)) + if (gdbarch_inner_than (gdbarch, 1, 2)) { /* Stack grows downward. Align STRUCT_ADDR and SP after making space for the return value. */ sp -= len; - if (gdbarch_frame_align_p (current_gdbarch)) - sp = gdbarch_frame_align (current_gdbarch, sp); + if (gdbarch_frame_align_p (gdbarch)) + sp = gdbarch_frame_align (gdbarch, sp); struct_addr = sp; } else { /* Stack grows upward. Align the frame, allocate space, and then again, re-align the frame??? */ - if (gdbarch_frame_align_p (current_gdbarch)) - sp = gdbarch_frame_align (current_gdbarch, sp); + if (gdbarch_frame_align_p (gdbarch)) + sp = gdbarch_frame_align (gdbarch, sp); struct_addr = sp; sp += len; - if (gdbarch_frame_align_p (current_gdbarch)) - sp = gdbarch_frame_align (current_gdbarch, sp); + if (gdbarch_frame_align_p (gdbarch)) + sp = gdbarch_frame_align (gdbarch, sp); } } @@ -627,8 +632,8 @@ call_function_by_hand (struct value *fun /* Create the dummy stack frame. Pass in the call dummy address as, presumably, the ABI code knows where, in the call dummy, the return address should be pointed. */ - sp = gdbarch_push_dummy_call (current_gdbarch, function, - get_current_regcache (), bp_addr, nargs, args, + sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (), + bp_addr, nargs, args, sp, struct_return, struct_addr); do_cleanups (args_cleanup); @@ -834,15 +839,14 @@ the function call)."), name); } else { - struct gdbarch *arch = current_gdbarch; - - switch (gdbarch_return_value (arch, target_values_type, NULL, NULL, NULL)) + switch (gdbarch_return_value (gdbarch, target_values_type, + NULL, NULL, NULL)) { case RETURN_VALUE_REGISTER_CONVENTION: case RETURN_VALUE_ABI_RETURNS_ADDRESS: case RETURN_VALUE_ABI_PRESERVES_ADDRESS: retval = allocate_value (values_type); - gdbarch_return_value (current_gdbarch, values_type, retbuf, + gdbarch_return_value (gdbarch, values_type, retbuf, value_contents_raw (retval), NULL); break; case RETURN_VALUE_STRUCT_CONVENTION: --------------040909010703050900000505--