From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id VlotOMjB2WeNKRQAWB0awg (envelope-from ) for ; Tue, 18 Mar 2025 14:56:08 -0400 Authentication-Results: simark.ca; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=cOnBFoWz; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id D52031E100; Tue, 18 Mar 2025 14:56:08 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-5.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=ham autolearn_force=no version=4.0.1 Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 049C11E0C0 for ; Tue, 18 Mar 2025 14:56:06 -0400 (EDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5AFD53858404 for ; Tue, 18 Mar 2025 18:56:05 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5AFD53858404 Authentication-Results: sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=cOnBFoWz Received: from mail-lf1-x12c.google.com (mail-lf1-x12c.google.com [IPv6:2a00:1450:4864:20::12c]) by sourceware.org (Postfix) with ESMTPS id E4A193858CD9 for ; Tue, 18 Mar 2025 18:50:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org E4A193858CD9 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org E4A193858CD9 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::12c ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1742323825; cv=none; b=LGWH/NS8P25ag7gNVTqj2t+aJM64ePEI9jdxqGBmCPS4sMiIiEO8Q8TfjQCYQVPAt2QzRvi+tAgamjHtf/mBSqhFo8vC4OS7RTvLX2llwZvXd/2UXSLGU1TNke9mpVvEM6EVqgfWfcNuGhFdFs7v5ymigzd1frqwmMlkzOfZhfk= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1742323825; c=relaxed/simple; bh=ZhGLUlCbXbiA/Aq677lcT8SXpNux1Of6IPrrxkWRzDo=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=jNBmGvmopQIbTZTU1T4o2/QELG0qeRsG7N7pycwjdNRDiDsHuBpKdP6FHV3pL9/49G/ENm182o52R6dnh43PFLuuKrjIxoSxL8wkT1oOHnXiZErwU3aU6eYkjUptMzNfQOvwlmAn95ugaXzXXAOexF9/1yA5BufnawWkPMxGvjE= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-lf1-x12c.google.com with SMTP id 2adb3069b0e04-5497e7bf2e0so6847748e87.3 for ; Tue, 18 Mar 2025 11:50:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742323793; x=1742928593; darn=sourceware.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=GDqWO/KhL4Lm9tNNUcXo6hkAA6b029dGexFu3KOveJ8=; b=cOnBFoWz69MguXxOFM25zTM6BfxDPCWQkxG3e0bVkqNsFjgsAbNhVTIaKH1bKPMyO7 DcYG/G1JYNDwptpZDZWBfwbjC4uRJZnHO3pNiw1hUB2aSPNVP/IYpctKJ3YkGaSP/79v dwBmqWvn1IFvad5UdoZKgirLWZZmcfgwHkA6IHb2S+5RBjEvBSxcDnvu15cmBs5f67hu dDSTy5z901h+yAC4N5hJ7m2UVaTplzPpStHUlVJz1O4OzyULZzy5lby7eg5Vd1zvD2Cy aCZMBV8UBQX05HKcbnadwERSuRRSmNdlguRZLKlbPGdJq87xdMSaPSiz/jodE5yw8klN QIBw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742323793; x=1742928593; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=GDqWO/KhL4Lm9tNNUcXo6hkAA6b029dGexFu3KOveJ8=; b=mBS5EBiSk0C2mCh5Z4/W8lWSzhHoHGRg03n5JgsQ1jcVt2MKj/9qOX3te8G5lTQSGk Lcv8FMCo/rhwLrQFguNWFultnMF3T/LFWh9hUSdkXkzuN9y6voD0W3df5EROnydsKLN0 DvO786y/BTQeMRneH1+lboyLihLPyjROH3kh42xpXRqd73RDvpZkC8BHWSxgdO4cJKrP BTP+mP9fR0sxo2qKAwaylOlUwidkMudSTFddaEJtyPYfdTgfvUgye3IuQVimTxg7P3gc K02UBhorY8dMmm07K+aWyIKc7isaIP2b3ePtNXmjUR4v6LMb/oIdldAqTYaXt72zAq5j XCgA== X-Gm-Message-State: AOJu0Yw0HnZ9UfmXZA3lSMNb4lT5VfWAMrkY6PfFlxy//6gLlH1Ji/7N LuT2tUOT5U9WJntjaVHD2B5MM7VWn/K9ZoOBFfzYBBkSPsz3voblUEmkn//BFOU= X-Gm-Gg: ASbGncvGZWW81qtwnGiQRLSjRYOtGhu0UYycNrJ0LapQVOEXPDbfifOAxyjq5QAmjVl gdfgFyJC1UXXnNiQLOLUHsyodI87OJZkT6PtQfla3A4v0W6piykX7Gd4kPL09F1lv25G/Aj9WTi 4WCcja94xE5l+p5WElblZx4eqXcU4VoYfdipPVUKpY9/B2GmuU6sZOCAN0KeTWvGvEZp1c5sfLj cNpXVVsw6lQD7gDC3pRV1dg2+naFBEOhCEn2Kh6rFHTFWVej8NXMyuV7I6DUh9I8e+SQj9cyHF4 Wyvo3ZQStfgdohTLqdwIuJ7BXuOlX/bF7Ajw7zyRmOtNagtb57RcDtlUQY6C95rJ9cVMz2Z6UzX cV9m69fayhG27ARXrY9v3lErI1jTGDmRZhfMATS8= X-Google-Smtp-Source: AGHT+IHTWw+Kewva3tP2ClTU5aobuwUo47y3MqI5TjAECkGmFLHR84eHM2fnIVS+GxLO19h90Ww4rA== X-Received: by 2002:a05:6512:1052:b0:549:8ed4:fb4c with SMTP id 2adb3069b0e04-54a03ba6631mr3602629e87.24.1742323791822; Tue, 18 Mar 2025 11:49:51 -0700 (PDT) Received: from timur-HP-ProBook-440-14-inch-G9-Notebook-PC.yadro.com (avpn01.yadro.com. [89.207.88.243]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-549ba8a92e7sm1713031e87.241.2025.03.18.11.49.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 18 Mar 2025 11:49:51 -0700 (PDT) From: Timur To: gdb-patches@sourceware.org, aburgess@redhat.com Cc: guinevere@redhat.com, Timur Subject: [PATCH v8] This commit adds record full support for rv64gc instruction set Date: Tue, 18 Mar 2025 21:49:44 +0300 Message-Id: <20250318184944.351874-1-timurgol007@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <87ikodx9a8.fsf@redhat.com> References: <87ikodx9a8.fsf@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~public-inbox=simark.ca@sourceware.org It includes changes to the following files: - gdb/riscv-linux-tdep.c, gdb/riscv-linux-tdep.h: adds facilities to record syscalls. - gdb/riscv-tdep.c, gdb/riscv-tdep.h: adds facilities to record execution of rv64gc instructions. - gdb/configure.tgt: adds new files for compilation. - gdb/testsuite/lib/gdb.exp: enables testing of full record mode for RISC-V targets. - gdb/syscalls/riscv-canonicalize-syscall-gen.py: a script to generate function that canonicalizes RISC-V syscall. This script can simplify support for syscalls on rv32 and rv64 system (currently support only for rv64). To use this script you need to pass a path to a file with syscalls description from riscv-glibc (example is in the help message). The script produces a mapping from syscall names to gdb_syscall enum. - gdb/riscv-canonicalize-syscall.c: the file generated by the previous script. - gdb/doc/gdb.texinfo: notification that record mode is enabled in RISC-V. - gdb/NEWS: notification of new functionality. Approved-By: Guinevere Larsen Hi! First, big gratitude for review! >> + { >> + warning (_ ("Process record and replay target doesn't " > > Unfortunately, the '_' function is the one function which breaks the > space before '(' rule. All uses should be just '_('. There are a > couple of incorrect uses of '_ (' in the code, but the majority don't > include the space. Addressed >> +/* Initialize the riscv64_linux_record_tdep. */ >> +/* These values are the size of the type that will be used in a system >> + call. They are obtained from Linux Kernel source. */ > > There comments should be merged into one please. Or maybe just drop the > second part? It is repeated in the function body, and, honestly, the > comment above the function confused me initially, I thought "These > values..." was referring to the function arguments. In the function > body it is much clearer what you are referencing. Addressed >> + >> + /* Initialize the riscv_linux_record_tdep. */ >> + /* These values are the size of the type that will be used in a system >> + call. They are obtained from Linux Kernel source. */ > > I've not checked any of these values. I figure bugs will be ironed out > in the future. I agree with you. I checked the part that was possible by running Linux under gdb and using the command "print sizeof()" >> + riscv_linux_record_tdep.arg3 = RISCV_A2_REGNUM; >> + riscv_linux_record_tdep.arg4 = RISCV_A3_REGNUM; >> + riscv_linux_record_tdep.arg5 = RISCV_A4_REGNUM; >> + riscv_linux_record_tdep.arg6 = RISCV_A5_REGNUM; >> + riscv_linux_record_tdep.arg7 = RISCV_A7_REGNUM; > > This really puzzled me, I even went and checked the ABI documentation. > But, doesn't the 7th argument go into a6? I have a comment related to > this on the definition of RISCV_A7_REGNUM. Addressed. As in RISC-V ecall there can be maximum 6 arguments, I deleted the seventh. >> index 00000000000..8e48ab8e1fd >> --- /dev/null >> +++ b/gdb/riscv-linux-tdep.h >> @@ -0,0 +1,29 @@ >> +/* Copyright (C) 2024 Free Software Foundation, Inc. > > When you update, remember to update all the dates to 2024-2025. >> +static bool >> +try_read (struct regcache *regcache, int regnum, ULONGEST &addr) >> +{ >> + gdb_assert (regcache != nullptr); >> + >> + if (regcache->raw_read (regnum, &addr) > > Is the type name needed here? This is the only raw_read call in GDB > that needs the '', other uses seem to get by with type > inference. Addressed >> +/* Helper class to record instruction. */ >> + >> +class riscv_recorded_insn final >> +{ >> +public: >> + using regnum_type = int; >> + using memory_type = std::pair; > > Ideally all member types and variables should have a comment. That rule > is (I think, unfortunately) not strictly enforced, but for > e.g. memory_type, a comment would be useful. I can guess that the 'int' > is a length, but it would be nice to have this spelled out. Addressed >> + using mem_addr = decltype (std::declval ().first); >> + using mem_len = decltype (std::declval ().second); >> + >> + record_type m_record_type = record_type::UNKNOWN; >> + >> + bool m_error_occured = false; >> + >> + recorded_regs m_regs; >> + recorded_mems m_mems; > > As with the types, comments on these to indicate their intended usage > would be great. Addressed >> + >> + int m_xlen = int{}; > > I know that the '{}' style is recommended in some places, but its use is > not common in GDB, and (personally) the more explicit 'int m_xlen = 0;' > seems far clearer. Please could you change the two uses of '{}' to use > value initialisation. Addressed >> + >> + /* Helper for decode 16-bit instruction RS1. */ > > Unfortunately, GNU style dictates two spaces after a '.', both at the > end of a comment, and at the end of a sentence within a comment. I > understand this is going to be a pain to fix up, but consistent style > helps make the code base easier to read. Addressed >> + bool >> + save_reg (regnum_type regnum) noexcept >> + { >> + try >> + { >> + m_regs.emplace_back (regnum); >> + return true; >> + } >> + catch (const std::bad_alloc &ex) >> + { >> + warning (_ ("Exception was caught during reverse execution: %s"), >> + ex.what ()); >> + return set_error (); >> + } > > Maybe I'm wrong, but I'm pretty sure that `warning` also tries to > allocate memory, so might throw an exception. I think my point is that, > if trying to allocate such a small memory block triggers an exception, > then we're pretty much dead anyway. > > As such, I wonder if we might as well just drop the try/catch, and rely > on the noexcept triggering an abort() if an exception is thrown? > > I also notice that this appears to be the only place in GDB where we are > catching std::bad_alloc, which makes me a little wonder if this is > necessary or not. Addressed >> + /* Returns true if instruction needs only saving pc. */ >> + static bool >> + need_save_pc (ULONGEST ival) noexcept >> + { >> + return is_beq_insn (ival) || is_bne_insn (ival) || is_blt_insn (ival) >> + || is_bge_insn (ival) || is_bltu_insn (ival) || is_bgeu_insn (ival) >> + || is_fence_insn (ival) || is_pause_insn (ival) >> + || is_fence_i_insn (ival); > > GNU style is that multi-line return expressions should be wrapped > with ( ... ), which helps some editors better align the code. Addressed >> + return !save_reg (decode_rd (ival)) >> + || !save_reg (RISCV_FIRST_CSR_REGNUM + decode_csr (ival)) >> + || set_ordinary_record_type (); >> + } >> + >> + /* If return value is > 0, instruction needs only saving pc and >> + memory chunk of appropriate length. */ > > Can you reword this comment please. You should explain that the return > value indicates the size of memory block that needs saving. There are a > couple of places where the comments above a function are a bit vague, > not really explaining all possible return values, or what happens when > an error occurs. Addressed >> + if (is_sh_insn (ival)) >> + return 2; >> + if (is_sw_insn (ival) || is_fsw_insn (ival)) >> + return 4; >> + if (is_sd_insn (ival) || is_fsd_insn (ival)) >> + return 8; >> + return 0; >> + } >> + >> + /* Returns true if instruction is classified. Needs error checking after. */ > > What does 'Needs error checking after' mean? I guess it means a call to > has_error()? I think the comment should say something like 'This > function can set m_error_occured.' But also, what is the return value > if an error is set? Yes, you were right. Error does not influence on the return value. Addressed >> + >> + warning (_ ("Currently this instruction with len 4(%lx) is unsupported"), >> + ival); >> + return false; >> + } >> + >> + /* Returns true if instruction is successfully recorder. >> + Else returns false. */ > > Comments on functions like this should explain the prerequisites, > e.g. in this case, the instruction must be of length 2. At least, I > assume that is a prerequisite, based on how the function is used. Addressed >> + >> +/* A helper function to record instruction using record API. */ >> + >> +static int >> +riscv_make_record_process (struct gdbarch *gdbarch, struct regcache *regcache, >> + const riscv_recorded_insn &insn) > > Just a little thing, but this function name doesn't make sense to me. > Is this really making a record process? It seems like a better name > might be `riscv_record_insn_details` or some such, isn't that what it's > doing? Yes, this is internal function. The idea was that regardless the place where an error occurred, we will be able to call record_full_arch_list_add_end at the end of the recording. Without creating confusing blocks of if's. Addressed >> RISCV_FP_REGNUM = 8, /* Frame Pointer. */ >> RISCV_A0_REGNUM = 10, /* First argument. */ >> RISCV_A1_REGNUM = 11, /* Second argument. */ >> + RISCV_A2_REGNUM = 12, /* Third argument. */ >> + RISCV_A3_REGNUM = 13, /* Forth argument. */ >> + RISCV_A4_REGNUM = 14, /* Fifth argument. */ >> + RISCV_A5_REGNUM = 15, /* Sixth argument. */ >> RISCV_A7_REGNUM = 17, /* Seventh argument. */ > > Is the comment on RISCV_A7_REGNUM correct? I suspect this was a mistake > in the commit e843807b2df9f99b8172bfaf4daa3a42461cdbfa. Changed comment as this register is used to pass number of syscall. Addressed >> +# This program is distributed in the hope that it will be useful, >> +# but WITHOUT ANY WARRANTY; without even the implied warranty of >> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> +# GNU General Public License for more details. >> + >> +# You should have received a copy of the GNU General Public License >> +# along with this program. If not, see . >> + > > I know there's a brief help message included with this script, but even > reading that, it's not clear to me how I'd use this script. > > But, most importantly, I think you should have a comment here, after the > copyright, but before the code, that explains (ideally) how to use the > script, or, at a minimum, says, "Run the script with the --help option > for usage instructions.", or similar. Addressed Thanks for the review again, waiting for your reply. --- gdb/NEWS | 2 + gdb/configure.tgt | 5 +- gdb/doc/gdb.texinfo | 2 +- gdb/riscv-canonicalize-syscall-gen.c | 342 +++++++++ gdb/riscv-linux-tdep.c | 258 ++++++- gdb/riscv-linux-tdep.h | 29 + gdb/riscv-tdep.c | 688 +++++++++++++++++- gdb/riscv-tdep.h | 16 +- .../riscv-canonicalize-syscall-gen.py | 163 +++++ gdb/testsuite/lib/gdb.exp | 3 +- 10 files changed, 1496 insertions(+), 12 deletions(-) create mode 100644 gdb/riscv-canonicalize-syscall-gen.c create mode 100644 gdb/riscv-linux-tdep.h create mode 100755 gdb/syscalls/riscv-canonicalize-syscall-gen.py diff --git a/gdb/NEWS b/gdb/NEWS index 964183910dc..20fdb571047 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -9581,3 +9581,5 @@ GDB now handles cross debugging. If you are remotely debugging between two different machines, type ``./configure host -target=targ''. Host is the machine where GDB will run; targ is the machine where the program that you are debugging will run. + + * Add record full support for rv64gc architectures diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 62df71b13fa..0cd5c509695 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -545,8 +545,9 @@ riscv*-*-freebsd*) riscv*-*-linux*) # Target: Linux/RISC-V - gdb_target_obs="riscv-linux-tdep.o glibc-tdep.o \ - linux-tdep.o solib-svr4.o symfile-mem.o linux-record.o" + gdb_target_obs="riscv-linux-tdep.o riscv-canonicalize-syscall-gen.o \ + glibc-tdep.o linux-tdep.o solib-svr4.o symfile-mem.o \ + linux-record.o" ;; riscv*-*-*) diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 99720f1206e..d5b989d681e 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -7759,7 +7759,7 @@ previous instruction; otherwise, it will work in record mode, if the platform supports reverse execution, or stop if not. Currently, process record and replay is supported on ARM, Aarch64, -Moxie, PowerPC, PowerPC64, S/390, and x86 (i386/amd64) running +Moxie, PowerPC, PowerPC64, S/390, RISC-V and x86 (i386/amd64) running GNU/Linux. Process record and replay can be used both when native debugging, and when remote debugging via @code{gdbserver}. diff --git a/gdb/riscv-canonicalize-syscall-gen.c b/gdb/riscv-canonicalize-syscall-gen.c new file mode 100644 index 00000000000..3749fc32f33 --- /dev/null +++ b/gdb/riscv-canonicalize-syscall-gen.c @@ -0,0 +1,342 @@ +/* DO NOT EDIT: Autogenerated by riscv-canonicalize-syscall-gen.py + + Copyright (C) 2024-2025 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "defs.h" +#include "riscv-linux-tdep.h" + +/* riscv64_canonicalize_syscall maps from the native riscv 64 Linux set + of syscall ids into a canonical set of syscall ids used by + process record. */ + +enum gdb_syscall +riscv64_canonicalize_syscall (int syscall) +{ + switch (syscall) + { + case 0: return gdb_sys_io_setup; + case 1: return gdb_sys_io_destroy; + case 2: return gdb_sys_io_submit; + case 3: return gdb_sys_io_cancel; + case 4: return gdb_sys_io_getevents; + case 5: return gdb_sys_setxattr; + case 6: return gdb_sys_lsetxattr; + case 7: return gdb_sys_fsetxattr; + case 8: return gdb_sys_getxattr; + case 9: return gdb_sys_lgetxattr; + case 10: return gdb_sys_fgetxattr; + case 11: return gdb_sys_listxattr; + case 12: return gdb_sys_llistxattr; + case 13: return gdb_sys_flistxattr; + case 14: return gdb_sys_removexattr; + case 15: return gdb_sys_lremovexattr; + case 16: return gdb_sys_fremovexattr; + case 17: return gdb_sys_getcwd; + case 18: return gdb_sys_lookup_dcookie; + case 19: return gdb_sys_eventfd2; + case 20: return gdb_sys_epoll_create1; + case 21: return gdb_sys_epoll_ctl; + case 22: return gdb_sys_epoll_pwait; + case 23: return gdb_sys_dup; + case 24: return gdb_sys_dup3; + case 25: return gdb_sys_fcntl; + case 26: return gdb_sys_inotify_init1; + case 27: return gdb_sys_inotify_add_watch; + case 28: return gdb_sys_inotify_rm_watch; + case 29: return gdb_sys_ioctl; + case 30: return gdb_sys_ioprio_set; + case 31: return gdb_sys_ioprio_get; + case 32: return gdb_sys_flock; + case 33: return gdb_sys_mknodat; + case 34: return gdb_sys_mkdirat; + case 35: return gdb_sys_unlinkat; + case 36: return gdb_sys_symlinkat; + case 37: return gdb_sys_linkat; + /* case 39: return gdb_sys_umount2; */ + case 40: return gdb_sys_mount; + case 41: return gdb_sys_pivot_root; + case 42: return gdb_sys_nfsservctl; + case 43: return gdb_sys_statfs; + case 44: return gdb_sys_fstatfs; + case 45: return gdb_sys_truncate; + case 46: return gdb_sys_ftruncate; + case 47: return gdb_sys_fallocate; + case 48: return gdb_sys_faccessat; + case 49: return gdb_sys_chdir; + case 50: return gdb_sys_fchdir; + case 51: return gdb_sys_chroot; + case 52: return gdb_sys_fchmod; + case 53: return gdb_sys_fchmodat; + case 54: return gdb_sys_fchownat; + case 55: return gdb_sys_fchown; + case 56: return gdb_sys_openat; + case 57: return gdb_sys_close; + case 58: return gdb_sys_vhangup; + case 59: return gdb_sys_pipe2; + case 60: return gdb_sys_quotactl; + case 61: return gdb_sys_getdents64; + case 62: return gdb_sys_lseek; + case 63: return gdb_sys_read; + case 64: return gdb_sys_write; + case 65: return gdb_sys_readv; + case 66: return gdb_sys_writev; + case 67: return gdb_sys_pread64; + case 68: return gdb_sys_pwrite64; + /* case 69: return gdb_sys_preadv; */ + /* case 70: return gdb_sys_pwritev; */ + case 71: return gdb_sys_sendfile; + case 72: return gdb_sys_pselect6; + case 73: return gdb_sys_ppoll; + /* case 74: return gdb_sys_signalfd4; */ + case 75: return gdb_sys_vmsplice; + case 76: return gdb_sys_splice; + case 77: return gdb_sys_tee; + case 78: return gdb_sys_readlinkat; + case 79: return gdb_sys_newfstatat; + case 80: return gdb_sys_fstat; + case 81: return gdb_sys_sync; + case 82: return gdb_sys_fsync; + case 83: return gdb_sys_fdatasync; + case 84: return gdb_sys_sync_file_range; + /* case 85: return gdb_sys_timerfd_create; */ + /* case 86: return gdb_sys_timerfd_settime; */ + /* case 87: return gdb_sys_timerfd_gettime; */ + /* case 88: return gdb_sys_utimensat; */ + case 89: return gdb_sys_acct; + case 90: return gdb_sys_capget; + case 91: return gdb_sys_capset; + case 92: return gdb_sys_personality; + case 93: return gdb_sys_exit; + case 94: return gdb_sys_exit_group; + case 95: return gdb_sys_waitid; + case 96: return gdb_sys_set_tid_address; + case 97: return gdb_sys_unshare; + case 98: return gdb_sys_futex; + case 99: return gdb_sys_set_robust_list; + case 100: return gdb_sys_get_robust_list; + case 101: return gdb_sys_nanosleep; + case 102: return gdb_sys_getitimer; + case 103: return gdb_sys_setitimer; + case 104: return gdb_sys_kexec_load; + case 105: return gdb_sys_init_module; + case 106: return gdb_sys_delete_module; + case 107: return gdb_sys_timer_create; + case 108: return gdb_sys_timer_gettime; + case 109: return gdb_sys_timer_getoverrun; + case 110: return gdb_sys_timer_settime; + case 111: return gdb_sys_timer_delete; + case 112: return gdb_sys_clock_settime; + case 113: return gdb_sys_clock_gettime; + case 114: return gdb_sys_clock_getres; + case 115: return gdb_sys_clock_nanosleep; + case 116: return gdb_sys_syslog; + case 117: return gdb_sys_ptrace; + case 118: return gdb_sys_sched_setparam; + case 119: return gdb_sys_sched_setscheduler; + case 120: return gdb_sys_sched_getscheduler; + case 121: return gdb_sys_sched_getparam; + case 122: return gdb_sys_sched_setaffinity; + case 123: return gdb_sys_sched_getaffinity; + case 124: return gdb_sys_sched_yield; + case 125: return gdb_sys_sched_get_priority_max; + case 126: return gdb_sys_sched_get_priority_min; + case 127: return gdb_sys_sched_rr_get_interval; + case 128: return gdb_sys_restart_syscall; + case 129: return gdb_sys_kill; + case 130: return gdb_sys_tkill; + case 131: return gdb_sys_tgkill; + case 132: return gdb_sys_sigaltstack; + case 133: return gdb_sys_rt_sigsuspend; + case 134: return gdb_sys_rt_sigaction; + case 135: return gdb_sys_rt_sigprocmask; + case 136: return gdb_sys_rt_sigpending; + case 137: return gdb_sys_rt_sigtimedwait; + case 138: return gdb_sys_rt_sigqueueinfo; + case 139: return gdb_sys_rt_sigreturn; + case 140: return gdb_sys_setpriority; + case 141: return gdb_sys_getpriority; + case 142: return gdb_sys_reboot; + case 143: return gdb_sys_setregid; + case 144: return gdb_sys_setgid; + case 145: return gdb_sys_setreuid; + case 146: return gdb_sys_setuid; + case 147: return gdb_sys_setresuid; + case 148: return gdb_sys_getresuid; + case 149: return gdb_sys_setresgid; + case 150: return gdb_sys_getresgid; + case 151: return gdb_sys_setfsuid; + case 152: return gdb_sys_setfsgid; + case 153: return gdb_sys_times; + case 154: return gdb_sys_setpgid; + case 155: return gdb_sys_getpgid; + case 156: return gdb_sys_getsid; + case 157: return gdb_sys_setsid; + case 158: return gdb_sys_getgroups; + case 159: return gdb_sys_setgroups; + case 160: return gdb_sys_uname; + case 161: return gdb_sys_sethostname; + case 162: return gdb_sys_setdomainname; + case 163: return gdb_sys_getrlimit; + case 164: return gdb_sys_setrlimit; + case 165: return gdb_sys_getrusage; + case 166: return gdb_sys_umask; + case 167: return gdb_sys_prctl; + case 168: return gdb_sys_getcpu; + case 169: return gdb_sys_gettimeofday; + case 170: return gdb_sys_settimeofday; + case 171: return gdb_sys_adjtimex; + case 172: return gdb_sys_getpid; + case 173: return gdb_sys_getppid; + case 174: return gdb_sys_getuid; + case 175: return gdb_sys_geteuid; + case 176: return gdb_sys_getgid; + case 177: return gdb_sys_getegid; + case 178: return gdb_sys_gettid; + case 179: return gdb_sys_sysinfo; + case 180: return gdb_sys_mq_open; + case 181: return gdb_sys_mq_unlink; + case 182: return gdb_sys_mq_timedsend; + case 183: return gdb_sys_mq_timedreceive; + case 184: return gdb_sys_mq_notify; + case 185: return gdb_sys_mq_getsetattr; + case 186: return gdb_sys_msgget; + case 187: return gdb_sys_msgctl; + case 188: return gdb_sys_msgrcv; + case 189: return gdb_sys_msgsnd; + case 190: return gdb_sys_semget; + case 191: return gdb_sys_semctl; + case 192: return gdb_sys_semtimedop; + case 193: return gdb_sys_semop; + case 194: return gdb_sys_shmget; + case 195: return gdb_sys_shmctl; + case 196: return gdb_sys_shmat; + case 197: return gdb_sys_shmdt; + case 198: return gdb_sys_socket; + case 199: return gdb_sys_socketpair; + case 200: return gdb_sys_bind; + case 201: return gdb_sys_listen; + case 202: return gdb_sys_accept; + case 203: return gdb_sys_connect; + case 204: return gdb_sys_getsockname; + case 205: return gdb_sys_getpeername; + case 206: return gdb_sys_sendto; + case 207: return gdb_sys_recvfrom; + case 208: return gdb_sys_setsockopt; + case 209: return gdb_sys_getsockopt; + case 210: return gdb_sys_shutdown; + case 211: return gdb_sys_sendmsg; + case 212: return gdb_sys_recvmsg; + case 213: return gdb_sys_readahead; + case 214: return gdb_sys_brk; + case 215: return gdb_sys_munmap; + case 216: return gdb_sys_mremap; + case 217: return gdb_sys_add_key; + case 218: return gdb_sys_request_key; + case 219: return gdb_sys_keyctl; + case 220: return gdb_sys_clone; + case 221: return gdb_sys_execve; + case 222: return gdb_old_mmap; + case 223: return gdb_sys_fadvise64; + case 224: return gdb_sys_swapon; + case 225: return gdb_sys_swapoff; + case 226: return gdb_sys_mprotect; + case 227: return gdb_sys_msync; + case 228: return gdb_sys_mlock; + case 229: return gdb_sys_munlock; + case 230: return gdb_sys_mlockall; + case 231: return gdb_sys_munlockall; + case 232: return gdb_sys_mincore; + case 233: return gdb_sys_madvise; + case 234: return gdb_sys_remap_file_pages; + case 235: return gdb_sys_mbind; + case 236: return gdb_sys_get_mempolicy; + case 237: return gdb_sys_set_mempolicy; + case 238: return gdb_sys_migrate_pages; + case 239: return gdb_sys_move_pages; + /* case 240: return gdb_sys_rt_tgsigqueueinfo; */ + /* case 241: return gdb_sys_perf_event_open; */ + /* case 242: return gdb_sys_accept4; */ + /* case 243: return gdb_sys_recvmmsg; */ + /* case 258: return gdb_sys_riscv_hwprobe; */ + /* case 259: return gdb_sys_riscv_flush_icache; */ + case 260: return gdb_sys_wait4; + /* case 261: return gdb_sys_prlimit64; */ + /* case 262: return gdb_sys_fanotify_init; */ + /* case 263: return gdb_sys_fanotify_mark; */ + /* case 264: return gdb_sys_name_to_handle_at; */ + /* case 265: return gdb_sys_open_by_handle_at; */ + /* case 266: return gdb_sys_clock_adjtime; */ + /* case 267: return gdb_sys_syncfs; */ + /* case 268: return gdb_sys_setns; */ + /* case 269: return gdb_sys_sendmmsg; */ + /* case 270: return gdb_sys_process_vm_readv; */ + /* case 271: return gdb_sys_process_vm_writev; */ + /* case 272: return gdb_sys_kcmp; */ + /* case 273: return gdb_sys_finit_module; */ + /* case 274: return gdb_sys_sched_setattr; */ + /* case 275: return gdb_sys_sched_getattr; */ + /* case 276: return gdb_sys_renameat2; */ + /* case 277: return gdb_sys_seccomp; */ + case 278: return gdb_sys_getrandom; + /* case 279: return gdb_sys_memfd_create; */ + /* case 280: return gdb_sys_bpf; */ + /* case 281: return gdb_sys_execveat; */ + /* case 282: return gdb_sys_userfaultfd; */ + /* case 283: return gdb_sys_membarrier; */ + /* case 284: return gdb_sys_mlock2; */ + /* case 285: return gdb_sys_copy_file_range; */ + /* case 286: return gdb_sys_preadv2; */ + /* case 287: return gdb_sys_pwritev2; */ + /* case 288: return gdb_sys_pkey_mprotect; */ + /* case 289: return gdb_sys_pkey_alloc; */ + /* case 290: return gdb_sys_pkey_free; */ + case 291: return gdb_sys_statx; + /* case 292: return gdb_sys_io_pgetevents; */ + /* case 293: return gdb_sys_rseq; */ + /* case 294: return gdb_sys_kexec_file_load; */ + /* case 424: return gdb_sys_pidfd_send_signal; */ + /* case 425: return gdb_sys_io_uring_setup; */ + /* case 426: return gdb_sys_io_uring_enter; */ + /* case 427: return gdb_sys_io_uring_register; */ + /* case 428: return gdb_sys_open_tree; */ + /* case 429: return gdb_sys_move_mount; */ + /* case 430: return gdb_sys_fsopen; */ + /* case 431: return gdb_sys_fsconfig; */ + /* case 432: return gdb_sys_fsmount; */ + /* case 433: return gdb_sys_fspick; */ + /* case 434: return gdb_sys_pidfd_open; */ + /* case 435: return gdb_sys_clone3; */ + /* case 436: return gdb_sys_close_range; */ + /* case 437: return gdb_sys_openat2; */ + /* case 438: return gdb_sys_pidfd_getfd; */ + /* case 439: return gdb_sys_faccessat2; */ + /* case 440: return gdb_sys_process_madvise; */ + /* case 441: return gdb_sys_epoll_pwait2; */ + /* case 442: return gdb_sys_mount_setattr; */ + /* case 443: return gdb_sys_quotactl_fd; */ + /* case 444: return gdb_sys_landlock_create_ruleset; */ + /* case 445: return gdb_sys_landlock_add_rule; */ + /* case 446: return gdb_sys_landlock_restrict_self; */ + /* case 447: return gdb_sys_memfd_secret; */ + /* case 448: return gdb_sys_process_mrelease; */ + /* case 449: return gdb_sys_futex_waitv; */ + /* case 450: return gdb_sys_set_mempolicy_home_node; */ + default: + return gdb_sys_no_syscall; + } +} diff --git a/gdb/riscv-linux-tdep.c b/gdb/riscv-linux-tdep.c index ff478cf4c28..f21039a613c 100644 --- a/gdb/riscv-linux-tdep.c +++ b/gdb/riscv-linux-tdep.c @@ -1,5 +1,5 @@ /* Target-dependent code for GNU/Linux on RISC-V processors. - Copyright (C) 2018-2024 Free Software Foundation, Inc. + Copyright (C) 2018-2025 Free Software Foundation, Inc. This file is part of GDB. @@ -25,6 +25,11 @@ #include "tramp-frame.h" #include "trad-frame.h" #include "gdbarch.h" +#include "record-full.h" +#include "linux-record.h" +#include "riscv-linux-tdep.h" + +extern unsigned int record_debug; /* The following value is derived from __NR_rt_sigreturn in from the Linux source tree. */ @@ -173,6 +178,254 @@ riscv_linux_syscall_next_pc (const frame_info_ptr &frame) return pc + 4 /* Length of the ECALL insn. */; } +/* RISC-V process record-replay constructs: syscall, signal etc. */ + +static linux_record_tdep riscv_linux_record_tdep; + +using regnum_type = int; + +/* Record registers from first to last for process-record. */ + +static bool +save_registers (struct regcache *regcache, regnum_type first, regnum_type last) +{ + gdb_assert (regcache != nullptr); + + for (regnum_type i = first; i != last; ++i) + if (record_full_arch_list_add_reg (regcache, i)) + return false; + return true; +}; + +/* Record all registers but PC register for process-record. */ + +static bool +riscv_all_but_pc_registers_record (struct regcache *regcache) +{ + gdb_assert (regcache != nullptr); + + struct gdbarch *gdbarch = regcache->arch (); + riscv_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + const struct riscv_gdbarch_features &features = tdep->isa_features; + + if (!save_registers (regcache, RISCV_ZERO_REGNUM + 1, RISCV_PC_REGNUM)) + return false; + + if (features.flen + && !save_registers (regcache, RISCV_FIRST_FP_REGNUM, + RISCV_LAST_FP_REGNUM + 1)) + return false; + + return true; +} + +/* Handler for riscv system call instruction recording. */ + +static int +riscv_linux_syscall_record (struct regcache *regcache, + unsigned long svc_number) +{ + gdb_assert (regcache != nullptr); + + enum gdb_syscall syscall_gdb = riscv64_canonicalize_syscall (svc_number); + + if (record_debug > 1) + gdb_printf (gdb_stdlog, "Made syscall %s.\n", plongest (svc_number)); + + if (syscall_gdb == gdb_sys_no_syscall) + { + warning (_("Process record and replay target doesn't " + "support syscall number %s\n"), plongest (svc_number)); + return -1; + } + + if (syscall_gdb == gdb_sys_sigreturn || syscall_gdb == gdb_sys_rt_sigreturn) + { + if (!riscv_all_but_pc_registers_record (regcache)) + return -1; + return 0; + } + + int ret = record_linux_system_call (syscall_gdb, regcache, + &riscv_linux_record_tdep); + if (ret != 0) + return ret; + + /* Record the return value of the system call. */ + if (record_full_arch_list_add_reg (regcache, RISCV_A0_REGNUM)) + return -1; + + return 0; +} + +/* Initialize the riscv64_linux_record_tdep. */ + +static void +riscv64_linux_record_tdep_init (struct gdbarch *gdbarch, + struct linux_record_tdep & + riscv_linux_record_tdep) +{ + gdb_assert (gdbarch != nullptr); + + /* These values are the size of the type that + will be used in a system call. */ + riscv_linux_record_tdep.size_pointer + = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT; + riscv_linux_record_tdep.size__old_kernel_stat = 48; + riscv_linux_record_tdep.size_tms = 32; + riscv_linux_record_tdep.size_loff_t = 8; + riscv_linux_record_tdep.size_flock = 32; + riscv_linux_record_tdep.size_oldold_utsname = 45; + riscv_linux_record_tdep.size_ustat = 32; + riscv_linux_record_tdep.size_old_sigaction = 32; + riscv_linux_record_tdep.size_old_sigset_t = 8; + riscv_linux_record_tdep.size_rlimit = 16; + riscv_linux_record_tdep.size_rusage = 144; + riscv_linux_record_tdep.size_timeval = 8; + riscv_linux_record_tdep.size_timezone = 8; + riscv_linux_record_tdep.size_old_gid_t = 2; + riscv_linux_record_tdep.size_old_uid_t = 2; + riscv_linux_record_tdep.size_fd_set = 128; + riscv_linux_record_tdep.size_old_dirent = 268; + riscv_linux_record_tdep.size_statfs = 120; + riscv_linux_record_tdep.size_statfs64 = 120; + riscv_linux_record_tdep.size_sockaddr = 16; + riscv_linux_record_tdep.size_int + = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; + riscv_linux_record_tdep.size_long + = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; + riscv_linux_record_tdep.size_ulong + = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; + riscv_linux_record_tdep.size_msghdr = 104; + riscv_linux_record_tdep.size_itimerval = 16; + riscv_linux_record_tdep.size_stat = 128; + riscv_linux_record_tdep.size_old_utsname = 325; + riscv_linux_record_tdep.size_sysinfo = 112; + riscv_linux_record_tdep.size_msqid_ds = 104; + riscv_linux_record_tdep.size_shmid_ds = 88; + riscv_linux_record_tdep.size_new_utsname = 390; + riscv_linux_record_tdep.size_timex = 188; + riscv_linux_record_tdep.size_mem_dqinfo = 72; + riscv_linux_record_tdep.size_if_dqblk = 68; + riscv_linux_record_tdep.size_fs_quota_stat = 64; + riscv_linux_record_tdep.size_timespec = 16; + riscv_linux_record_tdep.size_pollfd = 8; + riscv_linux_record_tdep.size_NFS_FHSIZE = 32; + riscv_linux_record_tdep.size_knfsd_fh = 36; + riscv_linux_record_tdep.size_TASK_COMM_LEN = 4; + riscv_linux_record_tdep.size_sigaction = 24; + riscv_linux_record_tdep.size_sigset_t = 8; + riscv_linux_record_tdep.size_siginfo_t = 128; + riscv_linux_record_tdep.size_cap_user_data_t = 8; + riscv_linux_record_tdep.size_stack_t = 24; + riscv_linux_record_tdep.size_off_t = riscv_linux_record_tdep.size_long; + riscv_linux_record_tdep.size_stat64 = 136; + riscv_linux_record_tdep.size_gid_t = 4; + riscv_linux_record_tdep.size_uid_t = 4; + riscv_linux_record_tdep.size_PAGE_SIZE = 4096; + riscv_linux_record_tdep.size_flock64 = 32; + riscv_linux_record_tdep.size_user_desc = 37; + riscv_linux_record_tdep.size_io_event = 32; + riscv_linux_record_tdep.size_iocb = 64; + riscv_linux_record_tdep.size_epoll_event = 16; + riscv_linux_record_tdep.size_itimerspec + = riscv_linux_record_tdep.size_timespec * 2; + riscv_linux_record_tdep.size_mq_attr = 64; + riscv_linux_record_tdep.size_termios = 36; + riscv_linux_record_tdep.size_termios2 = 44; + riscv_linux_record_tdep.size_pid_t = 4; + riscv_linux_record_tdep.size_winsize = 8; + riscv_linux_record_tdep.size_serial_struct = 72; + riscv_linux_record_tdep.size_serial_icounter_struct = 80; + riscv_linux_record_tdep.size_hayes_esp_config = 12; + riscv_linux_record_tdep.size_size_t = 8; + riscv_linux_record_tdep.size_iovec = 16; + riscv_linux_record_tdep.size_time_t = 8; + + /* These values are the second argument of system call "sys_ioctl". + They are obtained from Linux Kernel source. */ + riscv_linux_record_tdep.ioctl_TCGETS = 0x5401; + riscv_linux_record_tdep.ioctl_TCSETS = 0x5402; + riscv_linux_record_tdep.ioctl_TCSETSW = 0x5403; + riscv_linux_record_tdep.ioctl_TCSETSF = 0x5404; + riscv_linux_record_tdep.ioctl_TCGETA = 0x5405; + riscv_linux_record_tdep.ioctl_TCSETA = 0x5406; + riscv_linux_record_tdep.ioctl_TCSETAW = 0x5407; + riscv_linux_record_tdep.ioctl_TCSETAF = 0x5408; + riscv_linux_record_tdep.ioctl_TCSBRK = 0x5409; + riscv_linux_record_tdep.ioctl_TCXONC = 0x540a; + riscv_linux_record_tdep.ioctl_TCFLSH = 0x540b; + riscv_linux_record_tdep.ioctl_TIOCEXCL = 0x540c; + riscv_linux_record_tdep.ioctl_TIOCNXCL = 0x540d; + riscv_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e; + riscv_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f; + riscv_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410; + riscv_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411; + riscv_linux_record_tdep.ioctl_TIOCSTI = 0x5412; + riscv_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413; + riscv_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414; + riscv_linux_record_tdep.ioctl_TIOCMGET = 0x5415; + riscv_linux_record_tdep.ioctl_TIOCMBIS = 0x5416; + riscv_linux_record_tdep.ioctl_TIOCMBIC = 0x5417; + riscv_linux_record_tdep.ioctl_TIOCMSET = 0x5418; + riscv_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419; + riscv_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a; + riscv_linux_record_tdep.ioctl_FIONREAD = 0x541b; + riscv_linux_record_tdep.ioctl_TIOCINQ + = riscv_linux_record_tdep.ioctl_FIONREAD; + riscv_linux_record_tdep.ioctl_TIOCLINUX = 0x541c; + riscv_linux_record_tdep.ioctl_TIOCCONS = 0x541d; + riscv_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e; + riscv_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f; + riscv_linux_record_tdep.ioctl_TIOCPKT = 0x5420; + riscv_linux_record_tdep.ioctl_FIONBIO = 0x5421; + riscv_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422; + riscv_linux_record_tdep.ioctl_TIOCSETD = 0x5423; + riscv_linux_record_tdep.ioctl_TIOCGETD = 0x5424; + riscv_linux_record_tdep.ioctl_TCSBRKP = 0x5425; + riscv_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426; + riscv_linux_record_tdep.ioctl_TIOCSBRK = 0x5427; + riscv_linux_record_tdep.ioctl_TIOCCBRK = 0x5428; + riscv_linux_record_tdep.ioctl_TIOCGSID = 0x5429; + riscv_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a; + riscv_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b; + riscv_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c; + riscv_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d; + riscv_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430; + riscv_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431; + riscv_linux_record_tdep.ioctl_FIONCLEX = 0x5450; + riscv_linux_record_tdep.ioctl_FIOCLEX = 0x5451; + riscv_linux_record_tdep.ioctl_FIOASYNC = 0x5452; + riscv_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453; + riscv_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454; + riscv_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455; + riscv_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456; + riscv_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457; + riscv_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458; + riscv_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459; + riscv_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a; + riscv_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b; + riscv_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c; + riscv_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d; + riscv_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e; + riscv_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f; + riscv_linux_record_tdep.ioctl_FIOQSIZE = 0x5460; + + /* These values are the second argument of system call "sys_fcntl" + and "sys_fcntl64". They are obtained from Linux Kernel source. */ + riscv_linux_record_tdep.fcntl_F_GETLK = 5; + riscv_linux_record_tdep.fcntl_F_GETLK64 = 12; + riscv_linux_record_tdep.fcntl_F_SETLK64 = 13; + riscv_linux_record_tdep.fcntl_F_SETLKW64 = 14; + + riscv_linux_record_tdep.arg1 = RISCV_A0_REGNUM; + riscv_linux_record_tdep.arg2 = RISCV_A1_REGNUM; + riscv_linux_record_tdep.arg3 = RISCV_A2_REGNUM; + riscv_linux_record_tdep.arg4 = RISCV_A3_REGNUM; + riscv_linux_record_tdep.arg5 = RISCV_A4_REGNUM; + riscv_linux_record_tdep.arg6 = RISCV_A5_REGNUM; +} + /* Initialize RISC-V Linux ABI info. */ static void @@ -205,6 +458,9 @@ riscv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) tramp_frame_prepend_unwinder (gdbarch, &riscv_linux_sigframe); tdep->syscall_next_pc = riscv_linux_syscall_next_pc; + tdep->riscv_syscall_record = riscv_linux_syscall_record; + + riscv64_linux_record_tdep_init (gdbarch, riscv_linux_record_tdep); } /* Initialize RISC-V Linux target support. */ diff --git a/gdb/riscv-linux-tdep.h b/gdb/riscv-linux-tdep.h new file mode 100644 index 00000000000..0f481b168d1 --- /dev/null +++ b/gdb/riscv-linux-tdep.h @@ -0,0 +1,29 @@ +/* Copyright (C) 2024-2025 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#ifndef RISCV_LINUX_TDEP_H +#define RISCV_LINUX_TDEP_H + +#include "linux-record.h" + +/* riscv64_canonicalize_syscall maps from the native riscv Linux set + of syscall ids into a canonical set of syscall ids used by + process record. */ + +extern enum gdb_syscall riscv64_canonicalize_syscall (int syscall); + +#endif /* RISCV_LINUX_TDEP_H */ diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c index 932708ca4e9..cf1023a70c2 100644 --- a/gdb/riscv-tdep.c +++ b/gdb/riscv-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for the RISC-V architecture, for GDB. - Copyright (C) 2018-2024 Free Software Foundation, Inc. + Copyright (C) 2018-2025 Free Software Foundation, Inc. This file is part of GDB. @@ -54,9 +54,12 @@ #include "observable.h" #include "prologue-value.h" #include "arch/riscv.h" +#include "record-full.h" #include "riscv-ravenscar-thread.h" #include "gdbsupport/gdb-safe-ctype.h" +#include + /* The stack must be 16-byte aligned. */ #define SP_ALIGNMENT 16 @@ -1655,6 +1658,11 @@ class riscv_insn int imm_signed () const { return m_imm.s; } + /* Fetch instruction from target memory at ADDR, return the content of + the instruction, and update LEN with the instruction length. */ + static ULONGEST fetch_instruction (struct gdbarch *gdbarch, + CORE_ADDR addr, int *len); + private: /* Extract 5 bit register field at OFFSET from instruction OPCODE. */ @@ -1800,11 +1808,6 @@ class riscv_insn m_rs2 = decode_register_index_short (ival, OP_SH_CRS2S); } - /* Fetch instruction from target memory at ADDR, return the content of - the instruction, and update LEN with the instruction length. */ - static ULONGEST fetch_instruction (struct gdbarch *gdbarch, - CORE_ADDR addr, int *len); - /* The length of the instruction in bytes. Should be 2 or 4. */ int m_length; @@ -4415,6 +4418,9 @@ riscv_gdbarch_init (struct gdbarch_info info, set_gdbarch_stap_register_indirection_suffixes (gdbarch, stap_register_indirection_suffixes); + /* Process record-replay */ + set_gdbarch_process_record (gdbarch, riscv_process_record); + /* Hook in OS ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); @@ -4833,3 +4839,673 @@ this option can be used."), &setriscvcmdlist, &showriscvcmdlist); } + +/* A wrapper to read register under number regnum to address addr. + Returns false if error happened and makes warning. */ + +static bool +try_read (struct regcache *regcache, int regnum, ULONGEST &addr) +{ + gdb_assert (regcache != nullptr); + + if (regcache->raw_read (regnum, &addr) + != register_status::REG_VALID) + { + warning (_("Can not read at address %lx"), addr); + return false; + } + return true; +} + +/* Helper class to record instruction. */ + +class riscv_recorded_insn final +{ +public: + /* Type for saved register. */ + using regnum_type = int; + /* Type for saved memory. First is address, second is length. */ + using memory_type = std::pair; + + /* Enum class that represents which type does recording belong to. */ + enum class record_type + { + UNKNOWN, + ORDINARY, + + /* Corner cases. */ + ECALL, + EBREAK, + }; + +private: + /* Type for set of registers that need to be saved. */ + using recorded_regs = std::vector; + /* Type for set of memory records that need to be saved. */ + using recorded_mems = std::vector; + + /* Type for memory address, extracted from memory_type. */ + using mem_addr = decltype (std::declval ().first); + /* Type for memory length, extracted from memory_type. */ + using mem_len = decltype (std::declval ().second); + + /* Record type of current instruction. */ + record_type m_record_type = record_type::UNKNOWN; + + /* Flag that represents was there an error in current recording. */ + bool m_error_occured = false; + + /* Set of registers that need to be recorded. */ + recorded_regs m_regs; + /* Set of memory chunks that need to be recorded. */ + recorded_mems m_mems; + + /* Width in bytes of the general purpose registers for GDBARCH, + where recording is happening. */ + int m_xlen = 0; + + /* Helper for decode 16-bit instruction RS1. */ + static regnum_type + decode_crs1_short (ULONGEST opcode) noexcept + { + return ((opcode >> OP_SH_CRS1S) & OP_MASK_CRS1S) + 8; + } + + /* Helper for decode 16-bit instruction RS2. */ + static regnum_type + decode_crs2_short (ULONGEST opcode) noexcept + { + return ((opcode >> OP_SH_CRS2S) & OP_MASK_CRS2S) + 8; + } + + /* Helper for decode 16-bit instruction CRS1. */ + static regnum_type + decode_crs1 (ULONGEST opcode) noexcept + { + return ((opcode >> OP_SH_RD) & OP_MASK_RD); + } + + /* Helper for decode 16-bit instruction CRS2. */ + static regnum_type + decode_crs2 (ULONGEST opcode) noexcept + { + return ((opcode >> OP_SH_CRS2) & OP_MASK_CRS2); + } + + /* Helper for decode 32-bit instruction RD. */ + static regnum_type + decode_rd (ULONGEST ival) noexcept + { + return (ival >> OP_SH_RD) & OP_MASK_RD; + } + + /* Helper for decode 32-bit instruction RS1. */ + static regnum_type + decode_rs1 (ULONGEST ival) noexcept + { + return (ival >> OP_SH_RS1) & OP_MASK_RS1; + } + + /* Helper for decode 32-bit instruction RS2. */ + static regnum_type + decode_rs2 (ULONGEST ival) noexcept + { + return (ival >> OP_SH_RS2) & OP_MASK_RS2; + } + + /* Helper for decode 32-bit instruction CSR. */ + static regnum_type + decode_csr (ULONGEST ival) noexcept + { + return (ival >> OP_SH_CSR) & OP_MASK_CSR; + } + + /* Set ordinary record type. Always returns true. */ + bool + set_ordinary_record_type () noexcept + { + m_record_type = record_type::ORDINARY; + return true; + } + + /* Set error happened. Always returns false. */ + bool + set_error () noexcept + { + m_error_occured = true; + return false; + } + + /* Check if current recording has an error. */ + bool + has_error () const noexcept + { + return m_error_occured; + } + + /* Reads register. Sets error and returns false if error happened. */ + bool + read_reg (struct regcache *regcache, regnum_type reg, + ULONGEST &addr) noexcept + { + gdb_assert (regcache != nullptr); + + if (!try_read (regcache, reg, addr)) + return set_error (); + return true; + } + + /* Save register. Returns true or aborts if exception happened. */ + bool + save_reg (regnum_type regnum) noexcept + { + m_regs.emplace_back (regnum); + return true; + } + + /* Save memory chunk. Returns true or aborts if exception happened. */ + bool + save_mem (mem_addr addr, mem_len len) noexcept + { + m_mems.emplace_back (addr, len); + return true; + } + + /* Returns true if instruction needs only saving pc. */ + static bool + need_save_pc (ULONGEST ival) noexcept + { + return (is_beq_insn (ival) || is_bne_insn (ival) || is_blt_insn (ival) + || is_bge_insn (ival) || is_bltu_insn (ival) || is_bgeu_insn (ival) + || is_fence_insn (ival) || is_pause_insn (ival) + || is_fence_i_insn (ival)); + } + + /* Returns true if instruction is classified. */ + bool + try_save_pc (ULONGEST ival) noexcept + { + if (!need_save_pc (ival)) + return false; + + return set_ordinary_record_type (); + } + + /* Returns true if instruction needs only saving pc and rd. */ + static bool + need_save_pc_rd (ULONGEST ival) noexcept + { + return (is_lui_insn (ival) || is_auipc_insn (ival) || is_jal_insn (ival) + || is_jalr_insn (ival) || is_lb_insn (ival) || is_lh_insn (ival) + || is_lw_insn (ival) || is_lbu_insn (ival) || is_lhu_insn (ival) + || is_addi_insn (ival) || is_slti_insn (ival) + || is_sltiu_insn (ival) || is_xori_insn (ival) || is_ori_insn (ival) + || is_andi_insn (ival) || is_slli_rv32_insn (ival) + || is_srli_rv32_insn (ival) || is_srai_rv32_insn (ival) + || is_add_insn (ival) || is_sub_insn (ival) || is_sll_insn (ival) + || is_slt_insn (ival) || is_sltu_insn (ival) || is_xor_insn (ival) + || is_srl_insn (ival) || is_sra_insn (ival) || is_or_insn (ival) + || is_and_insn (ival) || is_lwu_insn (ival) || is_ld_insn (ival) + || is_slli_insn (ival) || is_srli_insn (ival) || is_srai_insn (ival) + || is_addiw_insn (ival) || is_slliw_insn (ival) + || is_srliw_insn (ival) || is_sraiw_insn (ival) + || is_addw_insn (ival) || is_subw_insn (ival) || is_sllw_insn (ival) + || is_srlw_insn (ival) || is_sraw_insn (ival) || is_mul_insn (ival) + || is_mulh_insn (ival) || is_mulhsu_insn (ival) + || is_mulhu_insn (ival) || is_div_insn (ival) || is_divu_insn (ival) + || is_rem_insn (ival) || is_remu_insn (ival) || is_mulw_insn (ival) + || is_divw_insn (ival) || is_divuw_insn (ival) + || is_remw_insn (ival) || is_remuw_insn (ival) + || is_lr_w_insn (ival) || is_lr_d_insn (ival) + || is_fcvt_w_s_insn (ival) || is_fcvt_wu_s_insn (ival) + || is_fmv_x_s_insn (ival) || is_feq_s_insn (ival) + || is_flt_s_insn (ival) || is_fle_s_insn (ival) + || is_fclass_s_insn (ival) || is_fcvt_l_s_insn (ival) + || is_fcvt_lu_s_insn (ival) || is_feq_d_insn (ival) + || is_flt_d_insn (ival) || is_fle_d_insn (ival) + || is_fclass_d_insn (ival) || is_fcvt_w_d_insn (ival) + || is_fcvt_wu_d_insn (ival) || is_fcvt_l_d_insn (ival) + || is_fcvt_lu_d_insn (ival) || is_fmv_x_d_insn (ival)); + } + + /* Returns true if instruction is classified. This function can set + m_error_occured. */ + bool + try_save_pc_rd (ULONGEST ival) noexcept + { + if (!need_save_pc_rd (ival)) + return false; + + return (!save_reg (decode_rd (ival)) || set_ordinary_record_type ()); + } + + /* Returns true if instruction needs only saving pc and + floating point rd. */ + static bool + need_save_pc_fprd (ULONGEST ival) noexcept + { + return (is_flw_insn (ival) || is_fmadd_s_insn (ival) + || is_fmsub_s_insn (ival) || is_fnmsub_s_insn (ival) + || is_fnmadd_s_insn (ival) || is_fadd_s_insn (ival) + || is_fsub_s_insn (ival) || is_fmul_s_insn (ival) + || is_fdiv_s_insn (ival) || is_fsqrt_s_insn (ival) + || is_fsgnj_s_insn (ival) || is_fsgnjn_s_insn (ival) + || is_fsgnjx_s_insn (ival) || is_fmin_s_insn (ival) + || is_fmax_s_insn (ival) || is_fcvt_s_w_insn (ival) + || is_fcvt_s_wu_insn (ival) || is_fmv_s_x_insn (ival) + || is_fcvt_s_l_insn (ival) || is_fcvt_s_lu_insn (ival) + || is_fld_insn (ival) || is_fmadd_d_insn (ival) + || is_fmsub_d_insn (ival) || is_fnmsub_d_insn (ival) + || is_fnmadd_d_insn (ival) || is_fadd_d_insn (ival) + || is_fsub_d_insn (ival) || is_fmul_d_insn (ival) + || is_fdiv_d_insn (ival) || is_fsqrt_d_insn (ival) + || is_fsgnj_d_insn (ival) || is_fsgnjn_d_insn (ival) + || is_fsgnjx_d_insn (ival) || is_fmin_d_insn (ival) + || is_fmax_d_insn (ival) || is_fcvt_s_d_insn (ival) + || is_fcvt_d_s_insn (ival) || is_fcvt_d_w_insn (ival) + || is_fcvt_d_wu_insn (ival) || is_fcvt_d_l_insn (ival) + || is_fcvt_d_lu_insn (ival) || is_fmv_d_x_insn (ival)); + } + + /* Returns true if instruction is classified. This function can set + m_error_occured. */ + bool + try_save_pc_fprd (ULONGEST ival) noexcept + { + if (!need_save_pc_fprd (ival)) + return false; + + return (!save_reg (RISCV_FIRST_FP_REGNUM + decode_rd (ival)) + || set_ordinary_record_type ()); + } + + /* Returns true if instruction needs only saving pc, rd and csr. */ + static bool + need_save_pc_rd_csr (ULONGEST ival) noexcept + { + return (is_csrrw_insn (ival) || is_csrrs_insn (ival) || is_csrrc_insn (ival) + || is_csrrwi_insn (ival) || is_csrrsi_insn (ival) + || is_csrrc_insn (ival)); + } + + /* Returns true if instruction is classified. This function can set + m_error_occured. */ + bool + try_save_pc_rd_csr (ULONGEST ival) noexcept + { + if (!need_save_pc_rd_csr (ival)) + return false; + + return (!save_reg (decode_rd (ival)) + || !save_reg (RISCV_FIRST_CSR_REGNUM + decode_csr (ival)) + || set_ordinary_record_type ()); + } + + /* Returns the size of the memory chunk that needs to be saved if the + instruction belongs to the group that needs only saving pc and memory. + Otherwise returns 0. */ + static mem_len + need_save_pc_mem (ULONGEST ival) noexcept + { + if (is_sb_insn (ival)) + return 1; + if (is_sh_insn (ival)) + return 2; + if (is_sw_insn (ival) || is_fsw_insn (ival)) + return 4; + if (is_sd_insn (ival) || is_fsd_insn (ival)) + return 8; + return 0; + } + + /* Returns true if instruction is classified. This function can set + m_error_occured. */ + bool + try_save_pc_mem (ULONGEST ival, struct regcache *regcache) noexcept + { + gdb_assert (regcache != nullptr); + + mem_addr addr = mem_addr{}; + mem_len len = need_save_pc_mem (ival); + if (len <= 0) + return false; + + mem_len offset = EXTRACT_STYPE_IMM (ival); + return (!read_reg (regcache, decode_rs1 (ival), addr) + || !save_mem (addr + offset, len) || set_ordinary_record_type ()); + } + + /* Returns the size of the memory chunk that needs to be saved if the + instruction belongs to the group that needs only saving pc, rd and memory. + Otherwise returns 0. */ + static mem_len + need_save_pc_rd_mem (ULONGEST ival) noexcept + { + if (is_sc_w_insn (ival) || is_amoswap_w_insn (ival) + || is_amoadd_w_insn (ival) || is_amoxor_w_insn (ival) + || is_amoand_w_insn (ival) || is_amoor_w_insn (ival) + || is_amomin_w_insn (ival) || is_amomax_w_insn (ival) + || is_amominu_w_insn (ival) || is_amomaxu_w_insn (ival)) + return 4; + if (is_sc_d_insn (ival) || is_amoswap_d_insn (ival) + || is_amoadd_d_insn (ival) || is_amoxor_d_insn (ival) + || is_amoand_d_insn (ival) || is_amoor_d_insn (ival) + || is_amomin_d_insn (ival) || is_amomax_d_insn (ival) + || is_amominu_d_insn (ival) || is_amomaxu_d_insn (ival)) + return 8; + return 0; + } + + /* Returns true if instruction is classified. This function can set + m_error_occured. */ + bool + try_save_pc_rd_mem (ULONGEST ival, struct regcache *regcache) noexcept + { + gdb_assert (regcache != nullptr); + + mem_len len = need_save_pc_rd_mem (ival); + mem_addr addr = 0; + if (len <= 0) + return false; + + return (!read_reg (regcache, decode_rs1 (ival), addr) + || !save_mem (addr, len) || !save_reg (decode_rd (ival)) + || set_ordinary_record_type ()); + } + + /* Returns true if instruction is successfully recordered. The length of + the instruction must be equal 4 bytes. */ + bool + record_insn_len4 (ULONGEST ival, struct regcache *regcache) noexcept + { + gdb_assert (regcache != nullptr); + + if (is_ecall_insn (ival)) + { + m_record_type = record_type::ECALL; + return true; + } + + if (is_ebreak_insn (ival)) + { + m_record_type = record_type::EBREAK; + return true; + } + + if (try_save_pc (ival) || try_save_pc_rd (ival) || try_save_pc_fprd (ival) + || try_save_pc_rd_csr (ival) || try_save_pc_mem (ival, regcache) + || try_save_pc_rd_mem (ival, regcache)) + return !has_error (); + + warning (_("Currently this instruction with len 4(%lx) is unsupported"), + ival); + return false; + } + + /* Returns true if instruction is successfully recordered. The length of + the instruction must be equal 2 bytes. */ + bool + record_insn_len2 (ULONGEST ival, struct regcache *regcache) noexcept + { + gdb_assert (regcache != nullptr); + + mem_addr addr = mem_addr{}; + + /* The order here is very important, because + opcodes of some instructions may be the same. */ + + if (is_c_addi4spn_insn (ival) || is_c_lw_insn (ival) + || (m_xlen == 8 && is_c_ld_insn (ival))) + return (!save_reg (decode_crs2_short (ival)) + || set_ordinary_record_type ()); + + if (is_c_fld_insn (ival) || (m_xlen == 4 && is_c_flw_insn (ival))) + return (!save_reg (RISCV_FIRST_FP_REGNUM + decode_crs2_short (ival)) + || set_ordinary_record_type ()); + + if (is_c_fsd_insn (ival) || (m_xlen == 8 && is_c_sd_insn (ival))) + { + ULONGEST offset = ULONGEST{EXTRACT_CLTYPE_LD_IMM (ival)}; + return (!read_reg (regcache, decode_crs1_short (ival), addr) + || !save_mem (addr + offset, 8) || set_ordinary_record_type ()); + } + + if ((m_xlen == 4 && is_c_fsw_insn (ival)) || is_c_sw_insn (ival)) + { + ULONGEST offset = ULONGEST{EXTRACT_CLTYPE_LW_IMM (ival)}; + return (!read_reg (regcache, decode_crs1_short (ival), addr) + || !save_mem (addr + offset, 4) || set_ordinary_record_type ()); + } + + if (is_c_nop_insn (ival)) + return set_ordinary_record_type (); + + if (is_c_addi_insn (ival)) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (m_xlen == 4 && is_c_jal_insn (ival)) + return (!save_reg (RISCV_RA_REGNUM) || set_ordinary_record_type ()); + + if ((m_xlen == 8 && is_c_addiw_insn (ival)) || is_c_li_insn (ival)) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (is_c_addi16sp_insn (ival)) + return (!save_reg (RISCV_SP_REGNUM) || set_ordinary_record_type ()); + + if (is_c_lui_insn (ival)) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (is_c_srli_insn (ival) || is_c_srai_insn (ival) || is_c_andi_insn (ival) + || is_c_sub_insn (ival) || is_c_xor_insn (ival) || is_c_or_insn (ival) + || is_c_and_insn (ival) || (m_xlen == 8 && is_c_subw_insn (ival)) + || (m_xlen == 8 && is_c_addw_insn (ival))) + return (!save_reg (decode_crs1_short (ival)) + || set_ordinary_record_type ()); + + if (is_c_j_insn (ival) || is_c_beqz_insn (ival) || is_c_bnez_insn (ival)) + return set_ordinary_record_type (); + + if (is_c_slli_insn (ival)) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (is_c_fldsp_insn (ival) || (m_xlen == 4 && is_c_flwsp_insn (ival))) + return (!save_reg (RISCV_FIRST_FP_REGNUM + decode_crs1 (ival)) + || set_ordinary_record_type ()); + + if (is_c_lwsp_insn (ival) || (m_xlen == 8 && is_c_ldsp_insn (ival))) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (is_c_jr_insn (ival)) + return set_ordinary_record_type (); + + if (is_c_mv_insn (ival)) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (is_c_ebreak_insn (ival)) + { + m_record_type = record_type::EBREAK; + return true; + } + + if (is_c_jalr_insn (ival)) + return (!save_reg (RISCV_RA_REGNUM) || set_ordinary_record_type ()); + + if (is_c_add_insn (ival)) + return (!save_reg (decode_crs1 (ival)) || set_ordinary_record_type ()); + + if (is_c_fsdsp_insn (ival) || (m_xlen == 8 && is_c_sdsp_insn (ival))) + { + ULONGEST offset = ULONGEST{EXTRACT_CSSTYPE_SDSP_IMM (ival)}; + return (!read_reg (regcache, RISCV_SP_REGNUM, addr) + || !save_mem (addr + offset, 8) || set_ordinary_record_type ()); + } + + if (is_c_swsp_insn (ival) || (m_xlen == 4 && is_c_fswsp_insn (ival))) + { + ULONGEST offset = ULONGEST{EXTRACT_CSSTYPE_SWSP_IMM (ival)}; + return (!read_reg (regcache, RISCV_SP_REGNUM, addr) + || !save_mem (addr + offset, 4) || set_ordinary_record_type ()); + } + + warning (_("Currently this instruction with len 2(%lx) is unsupported"), + ival); + return false; + } + +public: + /* Iterator for registers that need to be recorded. */ + using regs_iter = recorded_regs::const_iterator; + /* Iterator for memory chunks that need to be recorded. */ + using mems_iter = recorded_mems::const_iterator; + + /* Record instruction at address addr. Returns false if error happened. */ + bool + record (gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr) noexcept + { + gdb_assert (gdbarch != nullptr); + gdb_assert (regcache != nullptr); + + int m_length = 0; + m_xlen = riscv_isa_xlen (gdbarch); + ULONGEST ival = riscv_insn::fetch_instruction (gdbarch, addr, &m_length); + if (!save_reg (RISCV_PC_REGNUM)) + return false; + + if (m_length == 4) + return record_insn_len4 (ival, regcache); + + if (m_length == 2) + return record_insn_len2 (ival, regcache); + + /* 6 bytes or more. If the instruction is longer than 8 bytes, we don't + have full instruction bits in ival. At least, such long instructions + are not defined yet, so just ignore it. */ + gdb_assert (m_length > 0 && m_length % 2 == 0); + + warning (_("Can not record unknown instruction (opcode = %lx)"), ival); + return false; + } + + /* Get record type of instruction. */ + record_type + get_record_type () const noexcept + { + return m_record_type; + } + + /* Returns an iterator to the beginning of the registers that need + to be saved. */ + regs_iter + regs_begin () const noexcept + { + return m_regs.begin (); + } + + /* Returns an iterator to the end of the registers that need + to be saved. */ + regs_iter + regs_end () const noexcept + { + return m_regs.end (); + } + + /* Returns an iterator to the beginning of the memory chunks that need + to be saved. */ + mems_iter + mems_begin () const noexcept + { + return m_mems.begin (); + } + + /* Returns an iterator to the end of the memory chunks that need + to be saved. */ + mems_iter + mems_end () const noexcept + { + return m_mems.end (); + } +}; + +/* A helper function to record instruction using record API. */ + +static int +riscv_record_insn_details (struct gdbarch *gdbarch, struct regcache *regcache, + const riscv_recorded_insn &insn) +{ + gdb_assert (gdbarch != nullptr); + gdb_assert (regcache != nullptr); + + riscv_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + auto regs_begin = insn.regs_begin (); + auto regs_end = insn.regs_end (); + if (std::any_of (regs_begin, + regs_end, + [®cache] (auto &®_it) + { + return record_full_arch_list_add_reg (regcache, reg_it); + })) + return -1; + + auto mems_begin = insn.mems_begin (); + auto mems_end = insn.mems_end (); + if (std::any_of (mems_begin, + mems_end, + [] (auto &&mem_it) + { + return record_full_arch_list_add_mem (mem_it.first, + mem_it.second); + })) + return -1; + + switch (insn.get_record_type ()) + { + case riscv_recorded_insn::record_type::ORDINARY: + break; + + case riscv_recorded_insn::record_type::ECALL: + { + if (!tdep->riscv_syscall_record) + { + warning (_("Syscall record is not supported")); + return -1; + } + ULONGEST reg_val = ULONGEST{}; + if (!try_read (regcache, RISCV_A7_REGNUM, reg_val)) + return -1; + return tdep->riscv_syscall_record (regcache, reg_val); + } + + case riscv_recorded_insn::record_type::EBREAK: + break; + + default: + return -1; + } + return 0; +} + +/* Parse the current instruction and record the values of the registers and + memory that will be changed in current instruction to record_arch_list. + Return -1 if something is wrong. */ + +int +riscv_process_record (struct gdbarch *gdbarch, struct regcache *regcache, + CORE_ADDR addr) +{ + gdb_assert (gdbarch != nullptr); + gdb_assert (regcache != nullptr); + + riscv_recorded_insn insn; + if (!insn.record (gdbarch, regcache, addr)) + { + record_full_arch_list_add_end (); + return -1; + } + + int ret_val = riscv_record_insn_details (gdbarch, regcache, insn); + + if (record_full_arch_list_add_end ()) + return -1; + + return ret_val; +} diff --git a/gdb/riscv-tdep.h b/gdb/riscv-tdep.h index 4bdc2e7a3d5..726f197af02 100644 --- a/gdb/riscv-tdep.h +++ b/gdb/riscv-tdep.h @@ -35,7 +35,11 @@ enum RISCV_FP_REGNUM = 8, /* Frame Pointer. */ RISCV_A0_REGNUM = 10, /* First argument. */ RISCV_A1_REGNUM = 11, /* Second argument. */ - RISCV_A7_REGNUM = 17, /* Seventh argument. */ + RISCV_A2_REGNUM = 12, /* Third argument. */ + RISCV_A3_REGNUM = 13, /* Forth argument. */ + RISCV_A4_REGNUM = 14, /* Fifth argument. */ + RISCV_A5_REGNUM = 15, /* Sixth argument. */ + RISCV_A7_REGNUM = 17, /* Register to pass syscall number. */ RISCV_PC_REGNUM = 32, /* Program Counter. */ RISCV_NUM_INTEGER_REGS = 32, @@ -113,6 +117,10 @@ struct riscv_gdbarch_tdep : gdbarch_tdep_base /* Return the expected next PC assuming FRAME is stopped at a syscall instruction. */ CORE_ADDR (*syscall_next_pc) (const frame_info_ptr &frame) = nullptr; + + /* Syscall record. */ + int (*riscv_syscall_record) (struct regcache *regcache, + unsigned long svc_number) = nullptr; }; @@ -177,6 +185,12 @@ extern void riscv_supply_regset (const struct regset *regset, struct regcache *regcache, int regnum, const void *regs, size_t len); +/* Parse the current instruction, and record the values of the + registers and memory that will be changed by the current + instruction. Returns -1 if something goes wrong, 0 otherwise. */ +extern int riscv_process_record (struct gdbarch *gdbarch, + struct regcache *regcache, CORE_ADDR addr); + /* The names of the RISC-V target description features. */ extern const char *riscv_feature_name_csr; diff --git a/gdb/syscalls/riscv-canonicalize-syscall-gen.py b/gdb/syscalls/riscv-canonicalize-syscall-gen.py new file mode 100755 index 00000000000..aa07ac13145 --- /dev/null +++ b/gdb/syscalls/riscv-canonicalize-syscall-gen.py @@ -0,0 +1,163 @@ +#!/usr/bin/env python3 +# pylint: disable=invalid-name + +# Copyright (C) 2024-2025 Free Software Foundation, Inc. +# Contributed by Timur Golubovich + +# This file is part of GDB. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +# To get help message for this script, run: +# ./gdb/syscalls/riscv-canonicalize-syscall-gen.py --help + +# Execution result: + +# usage: riscv-canonicalize-syscall-gen.py [-h] -i INPUT +# +# Generate file gdb/riscv-canonicalize-syscall-gen.c from path to riscv linux syscalls. +# +# options: +# -h, --help show this help message and exit +# -i INPUT, --input INPUT +# path to riscv linux syscalls (riscv-glibc/sysdeps/unix/sysv/linux/riscv/rv64/arch-syscall.h) + +import argparse +import re +import sys +from pathlib import Path as _Path + +head = """\ +/* DO NOT EDIT: Autogenerated by riscv-canonicalize-syscall-gen.py + + Copyright (C) 2024-2025 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "defs.h" +#include "riscv-linux-tdep.h" + +/* riscv64_canonicalize_syscall maps from the native riscv 64 Linux set + of syscall ids into a canonical set of syscall ids used by + process record. */ + +enum gdb_syscall +riscv64_canonicalize_syscall (int syscall) +{ + switch (syscall) + { +""" + +tail = """\ + default: + return gdb_sys_no_syscall; + } +} +""" + + +class Generator: + def _get_gdb_syscalls(self, gdb_syscalls_path: _Path) -> list[str]: + gdb_syscalls: list[str] = [] + with open(gdb_syscalls_path, "r", encoding="UTF-8") as file: + lines = file.readlines() + for line in lines: + match = re.search(r"\s*(?Pgdb_sys_[^S]+)\S*=", line) + if match: + gdb_syscalls.append(match.group("name").strip()) + return gdb_syscalls + + def _get_canon_syscalls_lines(self, syscalls_path: _Path, gdb_syscalls: list[str]) -> list[str]: + canon_syscalls: dict[int, str] = {} + with open(syscalls_path, "r", encoding="UTF-8") as file: + lines = file.readlines() + for line in lines: + match = re.match(r"#define\s+__NR_(?P[^\s]+)\s+(?P\d+)", line) + if match: + syscall_name = match.group("name") + syscall_num = int(match.group("number")) + gdb_syscall_name = f"gdb_sys_{syscall_name}" + if gdb_syscall_name in gdb_syscalls: + value = f" case {syscall_num}: return {gdb_syscall_name};\n" + canon_syscalls[syscall_num] = value + # this is a place for corner cases + elif syscall_name == "mmap": + gdb_old_syscall_name = "gdb_old_mmap" + value = f" case {syscall_num}: return {gdb_old_syscall_name};\n" + canon_syscalls[syscall_num] = value + else: + value = f" /* case {syscall_num}: return {gdb_syscall_name}; */\n" + canon_syscalls[syscall_num] = value + return [canon_syscalls[syscall_num] for syscall_num in sorted(canon_syscalls)] + + def generate(self, syscalls_path: _Path) -> None: + repo_path = _Path(__file__).parent.parent.parent + gdb_syscalls_path = repo_path / "gdb" / "linux-record.h" + canon_syscalls_path = repo_path / "gdb" / "riscv-canonicalize-syscall-gen.c" + + gdb_syscalls = self._get_gdb_syscalls(gdb_syscalls_path) + canon_syscalls_lines = self._get_canon_syscalls_lines(syscalls_path, gdb_syscalls) + + with open(canon_syscalls_path, "w", encoding="UTF-8") as file: + file.writelines(head) + file.writelines(canon_syscalls_lines) + file.writelines(tail) + + +help_message = """\ +Generate file gdb/riscv-canonicalize-syscall-gen.c +from path to riscv linux syscalls. +""" + + +def setup_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=help_message) + parser.add_argument( + "-i", + "--input", + type=_Path, + required=True, + help="path to riscv linux syscalls (riscv-glibc/sysdeps/unix/sysv/linux/riscv/rv64/arch-syscall.h)", + ) + return parser + + +def main(argv: list[str]) -> int: + try: + parser = setup_parser() + args = parser.parse_args(argv) + generator = Generator() + generator.generate(args.input) + return 0 + except RuntimeError as e: + print(str(e)) + return -1 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp index 410f99e3350..b048ac7078b 100644 --- a/gdb/testsuite/lib/gdb.exp +++ b/gdb/testsuite/lib/gdb.exp @@ -3718,7 +3718,8 @@ proc supports_reverse {} { || [istarget "i\[34567\]86-*-linux*"] || [istarget "aarch64*-*-linux*"] || [istarget "powerpc*-*-linux*"] - || [istarget "s390*-*-linux*"] } { + || [istarget "s390*-*-linux*"] + || [istarget "riscv*-*-*"] } { return 1 } -- 2.34.1