From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id 6oy5Ds/5/GfSqTMAWB0awg (envelope-from ) for ; Mon, 14 Apr 2025 08:04:31 -0400 Authentication-Results: simark.ca; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=XbMDCNf/; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id 2AB511E0C3; Mon, 14 Apr 2025 08:04:31 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-6.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,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 C12701E05C for ; Mon, 14 Apr 2025 08:04:28 -0400 (EDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 50320385828B for ; Mon, 14 Apr 2025 12:04:28 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 50320385828B Authentication-Results: sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=XbMDCNf/ Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id 027893858431 for ; Mon, 14 Apr 2025 12:03:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 027893858431 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 027893858431 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1744632220; cv=none; b=vdzGfjQXoZDcsp0BGXxMgTMGfhzP9+1qg996pfTmFgPwinVEJk4zJ0WHtJqOUuzhBHePUBbRKNFwbrCaJ0/WdY/6n2MJuNIzUptfB9vTLb6HBWR6/uFudGqCjEtJlB6nuJp6kk5c/YlJo+HaSG2ntLH94M+1aw9uskrI/Knmm9U= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1744632220; c=relaxed/simple; bh=HqoCH6a9w46sGGDVlggn1WdHvNg9c70AN/166WYe0JU=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=Q7joaHmVJJnrEy71d5Zl3ksn9m7N1h8R+ALhSyLXym+BU0+sf+C0dM2s1GFj/li125O5D+JLOGqCeuOq1oa0G/fVn2E73b35qqiLfxG7gSzAg6drBuUJ1x5JWYJGTP7ELJRAxTf+YdNr0XgiFMpynPZpSyCYXlja0J6zypSg7sA= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 027893858431 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1744632219; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=4YHIVU9CqzPFcTAgUGmNU4pxQRuCf1Z+37kSD654UVo=; b=XbMDCNf/lOSOo2R79wK4QF3xfQTZvKKWZqbZl8CiG58Mx9ETemgp9QPRnR2jiRvvj1fooK 923pPMTh1GgG1gP81aCikDtdM4hTBA7GdRwuPSFmw2tTB89gljHQxcuxD8+0GBATdPPFLh sKkhqIj8eDIXIIn/ZN3wMkihz2ry3uI= Received: from mail-pf1-f197.google.com (mail-pf1-f197.google.com [209.85.210.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-54-4XbbFIcaNIa--NlviNK15g-1; Mon, 14 Apr 2025 08:03:38 -0400 X-MC-Unique: 4XbbFIcaNIa--NlviNK15g-1 X-Mimecast-MFC-AGG-ID: 4XbbFIcaNIa--NlviNK15g_1744632217 Received: by mail-pf1-f197.google.com with SMTP id d2e1a72fcca58-7370e73f690so4812765b3a.3 for ; Mon, 14 Apr 2025 05:03:37 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1744632217; x=1745237017; h=content-transfer-encoding:in-reply-to:from:content-language :references:cc:to:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=4YHIVU9CqzPFcTAgUGmNU4pxQRuCf1Z+37kSD654UVo=; b=mJKBi3pYsj9uFkPadOZKlURv5macvBPR5eFyShfEPHktQnf9M4k/IzOdTAi3tVCaYE j6ACJkZ8GoUL2SvS8V9A3dhLRuOS5d/hNQLXUnd/3wdkGqBVrmKNOcS7lwvGzoE/YNpt wGxMHiTyxMKp5FLrN2qqGRSbiQewsOKJxVeP3fKO1HCafvAu8oNkvr+zd7b71i+7/kgF X8syJU+4HXW/hwqi0zT3AescQA14LqJAx4S3KkP8ufQ/9xqtIKGvthi0E3PI11U+RLNo eHF6xyTO9VxRgFGO7sT8+JwkAbWoi/RXgBqmBAapblXETDFhTHdnSgdmMCfHgp4uuPdJ fwuA== X-Gm-Message-State: AOJu0YzJht75rg8Mi4uqaDttpF/l/0fJVxJg14RMrtuMtzW5+U53I24R Pn90bP4Av/nlQBTV+FQuJyaRGDLl/jplqjZo7cFYJw920+f9lkC1iwlfMNsAvtpXDRAB3zfv+rc F+laB1QxY9kk+LUclkrQd14feXkcMHFaUu7MfO4JF9JFDIhx1bFd4CIXNuik= X-Gm-Gg: ASbGncv+W5/pyE5v6yYA8cqontalQmQlHjOR59q//q0m8DZ+wRcqoKuyQggaQn+RLEu ooUrPw3flhiRp4gXZsL2XFxtrCEEH3qK9vzPiqNSI0Y+hbqsFSqOEjWzHwFSGIJlBb4TbwxhSWA FIP7HZUA8EIkTfZ9WxZaW9pnRH34+HWRImhL59ceiQVnvuLSVnmX1xEajxuVfatVinMu7dPmhat 3u5zk9Un72hm92A5rnz9TI2lqL1qGRWSLigRQaeV0VND9hmWFXoOjdQJvEcl6NJl7yZlNYTr5LK Y/B0y9SzEnd2lgJUuyiZwdA= X-Received: by 2002:a05:6a00:2185:b0:736:3e50:bfec with SMTP id d2e1a72fcca58-73bd11bde77mr19436230b3a.8.1744632216042; Mon, 14 Apr 2025 05:03:36 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEWtXCoAxAY3NO3mpUtj/npGnNCmJC2ucGTSMVmkLBGKcBfRYakEvueLxi2NZCzvVFrx1uoHw== X-Received: by 2002:a05:6a00:2185:b0:736:3e50:bfec with SMTP id d2e1a72fcca58-73bd11bde77mr19436081b3a.8.1744632214736; Mon, 14 Apr 2025 05:03:34 -0700 (PDT) Received: from ?IPV6:2804:14d:8084:9a69::1002? ([2804:14d:8084:9a69::1002]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b02a3220ff0sm7618389a12.66.2025.04.14.05.03.32 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 14 Apr 2025 05:03:33 -0700 (PDT) Message-ID: <6e578959-05fe-4c7d-9771-35136155dcc8@redhat.com> Date: Mon, 14 Apr 2025 09:03:30 -0300 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v8] This commit adds record full support for rv64gc instruction set To: Timur Golubovich , Andrew Burgess Cc: gdb-patches@sourceware.org References: <875xjce5r8.fsf@redhat.com> <20250410115519.617361-1-timurgol007@gmail.com> <87fribdwc9.fsf@redhat.com> From: Guinevere Larsen In-Reply-To: X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: KNIi3xc-4oXbvWZ3K4GoY1sMsWn9h6bySPaV-44_ZEg_1744632217 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Type: text/plain; charset=UTF-8; format=flowed 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 On 4/14/25 5:44 AM, Timur Golubovich wrote: > Hi! > Thank you Andrew for watching this. > I think that now we can merge this patch? If the copyright assignment process has been finished already, yes, this can be merged now! -- Cheers, Guinevere Larsen She/Her/Hers > > пн, 14 апр. 2025 г. в 10:41, Andrew Burgess : > >> Timur writes: >> >>> 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 Andrew! Thank you for review. >>> >>>> I guess riscv-glibc is a fork of glibc that is running ahead of the >>>> upstream glibc project? >>>> >>>> Is there any reason that this cannot work with the official glibc >>>> project? That would be preferable I think unless there's a compelling >>>> reason, which ideally we'd document. >>>> >>>> I tried running the script using current HEAD of glibc, the only >>>> significant change is: >>>> >>>> diff --git i/gdb/riscv-canonicalize-syscall-gen.c w/gdb/riscv-canonicalize-syscall-gen.c >>>> index 3749fc32f33..03579984f4a 100644 >>>> --- i/gdb/riscv-canonicalize-syscall-gen.c >>>> +++ w/gdb/riscv-canonicalize-syscall-gen.c >>>> @@ -270,7 +270,7 @@ riscv64_canonicalize_syscall (int syscall) >>>> 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 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; */ >>>> >>>> There was also a bunch of new syscalls that are added, but commented >>>> out. I haven't tried to figure out if the change above is a bad thing >>>> or not though, maybe you could advise. >>> Yes, I agree with you, I just used riscv-glibc as I had aldready downloaded it >>> and unfortunately the version was pretty old (I started working on this patch >>> almost half a year ago). >>> >>>> This entry needs to move to the correct section of the NEWS file. If >>>> you look for the lines starting '***' you'll see that the first header >>>> is '*** Changes since GDB 16', this is the section where you should >>>> place your entry, probably just before the '* New commands' line. >>>> These include guards need to be renamed to GDB_RISCV_LINUX_TDEP_H. You >>>> can do this automatically if you like with: >>>> >>>> ./gdb/check-include-guards.py --update gdb/*.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 */ >>> Addressed >>> >>>> @@ -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*-*-*"] } { >>>> I notice that every other entry in this list restricts the match to >>>> Linux based targets. Is RISC-V really different here? Or should RISC-V >>>> be similarly restricted? >>> Addressed, this was just my misprint. >>> >>> Hope that now everything is okay, wait for your feedback. >> I scanned the fixes, they look good. I haven't looked at the rest of >> the patch in detail, assuming it hasn't changed from the previous >> version: >> >> Approved-By: Andrew Burgess >> >> Thanks, >> Andrew >> >> >> >>> --- >>> gdb/NEWS | 2 + >>> gdb/configure.tgt | 5 +- >>> gdb/doc/gdb.texinfo | 2 +- >>> gdb/riscv-canonicalize-syscall-gen.c | 358 +++++++++ >>> gdb/riscv-linux-tdep.c | 256 +++++++ >>> gdb/riscv-linux-tdep.h | 29 + >>> gdb/riscv-tdep.c | 686 +++++++++++++++++- >>> gdb/riscv-tdep.h | 16 +- >>> .../riscv-canonicalize-syscall-gen.py | 163 +++++ >>> gdb/testsuite/lib/gdb.exp | 3 +- >>> 10 files changed, 1510 insertions(+), 10 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 99ec392d4c4..1a05a9f9251 100644 >>> --- a/gdb/NEWS >>> +++ b/gdb/NEWS >>> @@ -40,6 +40,8 @@ >>> namespace into which the library was loaded, if more than one namespace >>> is active. >>> >>> +* Add record full support for rv64gc architectures >>> + >>> * New commands >>> >>> maintenance check psymtabs >>> diff --git a/gdb/configure.tgt b/gdb/configure.tgt >>> index 18a15c032c3..44da2257be8 100644 >>> --- a/gdb/configure.tgt >>> +++ b/gdb/configure.tgt >>> @@ -534,8 +534,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 b251c8e1228..73f3b14cf74 100644 >>> --- a/gdb/doc/gdb.texinfo >>> +++ b/gdb/doc/gdb.texinfo >>> @@ -7807,7 +7807,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, >>> -LoongArch, 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..03579984f4a >>> --- /dev/null >>> +++ b/gdb/riscv-canonicalize-syscall-gen.c >>> @@ -0,0 +1,358 @@ >>> +/* 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; */ >>> + /* case 451: return gdb_sys_cachestat; */ >>> + /* case 452: return gdb_sys_fchmodat2; */ >>> + /* case 453: return gdb_sys_map_shadow_stack; */ >>> + /* case 454: return gdb_sys_futex_wake; */ >>> + /* case 455: return gdb_sys_futex_wait; */ >>> + /* case 456: return gdb_sys_futex_requeue; */ >>> + /* case 457: return gdb_sys_statmount; */ >>> + /* case 458: return gdb_sys_listmount; */ >>> + /* case 459: return gdb_sys_lsm_get_self_attr; */ >>> + /* case 460: return gdb_sys_lsm_set_self_attr; */ >>> + /* case 461: return gdb_sys_lsm_list_modules; */ >>> + /* case 462: return gdb_sys_mseal; */ >>> + /* case 463: return gdb_sys_setxattrat; */ >>> + /* case 464: return gdb_sys_getxattrat; */ >>> + /* case 465: return gdb_sys_listxattrat; */ >>> + /* case 466: return gdb_sys_removexattrat; */ >>> + default: >>> + return gdb_sys_no_syscall; >>> + } >>> +} >>> diff --git a/gdb/riscv-linux-tdep.c b/gdb/riscv-linux-tdep.c >>> index 4c0c65c1457..f21039a613c 100644 >>> --- a/gdb/riscv-linux-tdep.c >>> +++ b/gdb/riscv-linux-tdep.c >>> @@ -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..9dd9e373caa >>> --- /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 GDB_RISCV_LINUX_TDEP_H >>> +#define GDB_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 /* GDB_RISCV_LINUX_TDEP_H */ >>> diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c >>> index 91f6dffebe1..19367ff55ba 100644 >>> --- a/gdb/riscv-tdep.c >>> +++ b/gdb/riscv-tdep.c >>> @@ -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 >>> >>> @@ -1669,6 +1672,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. */ >>> @@ -1814,11 +1822,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; >>> >>> @@ -4433,6 +4436,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); >>> >>> @@ -4866,3 +4872,673 @@ equivalent change in the disassembler output."), >>> &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 ad1e9596b83..2903aefd007 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..30e52b7e472 >>> --- /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 (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 (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 c37cc8974e2..0149125e60a 100644 >>> --- a/gdb/testsuite/lib/gdb.exp >>> +++ b/gdb/testsuite/lib/gdb.exp >>> @@ -3758,7 +3758,8 @@ proc supports_reverse {} { >>> || [istarget "aarch64*-*-linux*"] >>> || [istarget "loongarch*-*-linux*"] >>> || [istarget "powerpc*-*-linux*"] >>> - || [istarget "s390*-*-linux*"] } { >>> + || [istarget "s390*-*-linux*"] >>> + || [istarget "riscv*-*-linux*"] } { >>> return 1 >>> } >>> >>> -- >>> 2.34.1