From patchwork Wed Dec 17 17:33:50 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: "Wei-cheng, Wang" X-Patchwork-Id: 4306 Received: (qmail 23491 invoked by alias); 17 Dec 2014 17:33:59 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 23481 invoked by uid 89); 17 Dec 2014 17:33:58 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.8 required=5.0 tests=AWL, BAYES_00, FREEMAIL_ENVFROM_END_DIGIT, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-pd0-f174.google.com Received: from mail-pd0-f174.google.com (HELO mail-pd0-f174.google.com) (209.85.192.174) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Wed, 17 Dec 2014 17:33:56 +0000 Received: by mail-pd0-f174.google.com with SMTP id fp1so16439135pdb.5 for ; Wed, 17 Dec 2014 09:33:54 -0800 (PST) X-Received: by 10.70.94.197 with SMTP id de5mr71265519pdb.161.1418837634430; Wed, 17 Dec 2014 09:33:54 -0800 (PST) Received: from [192.168.2.3] ([123.110.214.155]) by mx.google.com with ESMTPSA id nx1sm4419511pdb.85.2014.12.17.09.33.52 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 17 Dec 2014 09:33:53 -0800 (PST) Message-ID: <5491BE7E.2060708@gmail.com> Date: Thu, 18 Dec 2014 01:33:50 +0800 From: Wei-cheng Wang User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Thunderbird/31.3.0 MIME-Version: 1.0 To: Ulrich Weigand CC: gdb-patches@sourceware.org Subject: Re: [PATCH 3/3 v2] Process record support for PowerPC References: <201412081913.sB8JDOfU003481@d03av02.boulder.ibm.com> In-Reply-To: <201412081913.sB8JDOfU003481@d03av02.boulder.ibm.com> On 2014/12/9 上午 03:13, Ulrich Weigand wrote: > Wei-cheng Wang wrote: >> * ppc-linux-tdep.c (powerpc_linux_in_dynsym_resolve_code): >> Scan PLT stub backward for reverse debugging. >> (ppc_linux_init_abi): set powerpc_linux_in_dynsym_resolve_code >> for both 32-bit and 64-bit. > > As I said in the reply to the 0/3 mail, I really think it would be > better to handle this within the PPC skip_trampoline_code implementation, > instead of having in_dynsym_resolve_code suddenly also cover the > trampolines ... Hi, See the new patch, I moved the for-loop into skip_trampoline_code, and removed in_dynsym_resolve_code. > It seems odd to have in_dynsym_resolve_code call into > skip_trampoline_code. Is there a reason why the skip_trampoline_code > implementation cannot accept a PC in the middle of the sequence? I thought skip-trampoline is used to find the target address for inserting step-resume breakpoint, so it doesn't make sense for reverse-stepping, because we are just stepping from the target address. And for forward-stepping, when we reach the very first instruction of trampoline code, we can just skip the resolving code by inserting a step-resume breakpoint, so we don't have to step through the resolving code and check whether we are in the middle of trampoline code. in_dynsym_resolve_code is used to check whether we are in (the middle of) the resolving code, so we can keep going to step though the resolving code. Therefor I thought in_dynsym_resolve_code is the proper place to implement. Since skip-trampoline-code had implemented the plt-stub pattern-match code we need, by calling it in in-dynsym-resolve-code, we don't need to have duplicate pattern-match code in both functions. Wei-cheng, Thanks --- 2014-12-06 Wei-cheng Wang * ppc-linux-tdep.c (ppc_skip_trampoline_code): Scan PLT stub backward for reverse debugging. * ppc64-tdep.c (ppc64_skip_trampoline_code): Likewise. --- gdb/ppc-linux-tdep.c | 58 ++++++++++++++++++++++------------ gdb/ppc64-tdep.c | 88 +++++++++++++++++++++++++++++++++++----------------- 2 files changed, 99 insertions(+), 47 deletions(-) diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c index fa41d34..b57f41d 100644 --- a/gdb/ppc-linux-tdep.c +++ b/gdb/ppc-linux-tdep.c @@ -51,6 +51,7 @@ #include "linux-tdep.h" #include "linux-record.h" #include "record-full.h" +#include "infrun.h" #include "stap-probe.h" #include "ax.h" @@ -314,31 +315,50 @@ ppc_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR target = 0; + int scan_limit, i; - if (ppc_insns_match_pattern (frame, pc, powerpc32_plt_stub, insnbuf)) - { - /* Insn pattern is - lis r11, xxxx - lwz r11, xxxx(r11) - Branch target is in r11. */ - - target = (ppc_insn_d_field (insnbuf[0]) << 16) - | ppc_insn_d_field (insnbuf[1]); - target = read_memory_unsigned_integer (target, 4, byte_order); - } + scan_limit = 1; + /* When reverse-debugging, scan backward to check whether we are + in the middle of trampoline code. */ + if (execution_direction == EXEC_REVERSE) + scan_limit = 4; /* At more 4 instructions. */ - if (ppc_insns_match_pattern (frame, pc, powerpc32_plt_stub_so, insnbuf)) + for (i = 0; i < scan_limit; i++) { - /* Insn pattern is - lwz r11, xxxx(r30) - Branch target is in r11. */ + if (ppc_insns_match_pattern (frame, pc, powerpc32_plt_stub, insnbuf)) + { + /* Insn pattern is + lis r11, xxxx + lwz r11, xxxx(r11) + Branch target is in r11. */ + + target = (ppc_insn_d_field (insnbuf[0]) << 16) + | ppc_insn_d_field (insnbuf[1]); + target = read_memory_unsigned_integer (target, 4, byte_order); + } + else if (ppc_insns_match_pattern (frame, pc, powerpc32_plt_stub_so, + insnbuf)) + { + /* Insn pattern is + lwz r11, xxxx(r30) + Branch target is in r11. */ + + target = get_frame_register_unsigned (frame, + tdep->ppc_gp0_regnum + 30) + + ppc_insn_d_field (insnbuf[0]); + target = read_memory_unsigned_integer (target, 4, byte_order); + } + else + { + /* Scan backward one more instructions if doesn't match. */ + pc -= 4; + continue; + } - target = get_frame_register_unsigned (frame, tdep->ppc_gp0_regnum + 30) - + ppc_insn_d_field (insnbuf[0]); - target = read_memory_unsigned_integer (target, 4, byte_order); + return target; } - return target; + return 0; } /* Wrappers to handle Linux-only registers. */ diff --git a/gdb/ppc64-tdep.c b/gdb/ppc64-tdep.c index 8acd754..25a0816 100644 --- a/gdb/ppc64-tdep.c +++ b/gdb/ppc64-tdep.c @@ -20,6 +20,7 @@ #include "defs.h" #include "frame.h" #include "gdbcore.h" +#include "infrun.h" #include "ppc-tdep.h" #include "ppc64-tdep.h" #include "elf-bfd.h" @@ -464,35 +465,66 @@ ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) ARRAY_SIZE (ppc64_standard_linkage8)))) - 1]; CORE_ADDR target; + int scan_limit, i; - if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage8, insns)) - pc = ppc64_standard_linkage4_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage7, insns)) - pc = ppc64_standard_linkage3_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage6, insns)) - pc = ppc64_standard_linkage4_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage5, insns) - && (insns[8] != 0 || insns[9] != 0)) - pc = ppc64_standard_linkage3_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage4, insns) - && (insns[9] != 0 || insns[10] != 0)) - pc = ppc64_standard_linkage4_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage3, insns) - && (insns[8] != 0 || insns[9] != 0)) - pc = ppc64_standard_linkage3_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage2, insns) - && (insns[10] != 0 || insns[11] != 0)) - pc = ppc64_standard_linkage2_target (frame, pc, insns); - else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage1, insns)) - pc = ppc64_standard_linkage1_target (frame, pc, insns); - else - return 0; - - /* The PLT descriptor will either point to the already resolved target - address, or else to a glink stub. As the latter carry synthetic @plt - symbols, find_solib_trampoline_target should be able to resolve them. */ - target = find_solib_trampoline_target (frame, pc); - return target ? target : pc; + scan_limit = 1; + /* When reverse-debugging, scan backward to check whether we are + in the middle of trampoline code. */ + if (execution_direction == EXEC_REVERSE) + scan_limit = ARRAY_SIZE (insns) - 1; + + for (i = 0; i < scan_limit; i++) + { + if (i < ARRAY_SIZE (ppc64_standard_linkage8) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage8, insns)) + pc = ppc64_standard_linkage4_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage7) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage7, + insns)) + pc = ppc64_standard_linkage3_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage6) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage6, + insns)) + pc = ppc64_standard_linkage4_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage5) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage5, + insns) + && (insns[8] != 0 || insns[9] != 0)) + pc = ppc64_standard_linkage3_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage4) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage4, + insns) + && (insns[9] != 0 || insns[10] != 0)) + pc = ppc64_standard_linkage4_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage3) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage3, + insns) + && (insns[8] != 0 || insns[9] != 0)) + pc = ppc64_standard_linkage3_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage2) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage2, + insns) + && (insns[10] != 0 || insns[11] != 0)) + pc = ppc64_standard_linkage2_target (frame, pc, insns); + else if (i < ARRAY_SIZE (ppc64_standard_linkage1) - 1 + && ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage1, + insns)) + pc = ppc64_standard_linkage1_target (frame, pc, insns); + else + { + /* Scan backward one more instructions if doesn't match. */ + pc -= 4; + continue; + } + + /* The PLT descriptor will either point to the already resolved target + address, or else to a glink stub. As the latter carry synthetic @plt + symbols, find_solib_trampoline_target should be able to resolve them. */ + target = find_solib_trampoline_target (frame, pc); + return target ? target : pc; + } + + return 0; } /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64