From patchwork Mon Mar 17 15:50:55 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Zheng Junjie X-Patchwork-Id: 40282 Return-Path: X-Original-To: patchwork@mira.cbaines.net Delivered-To: patchwork@mira.cbaines.net Received: by mira.cbaines.net (Postfix, from userid 113) id D9D6527BBEA; Mon, 17 Mar 2025 15:52:54 +0000 (GMT) X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on mira.cbaines.net X-Spam-Level: X-Spam-Status: No, score=-5.6 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,FROM_SUSPICIOUS_NTLD,MAILING_LIST_MULTI, PDS_OTHER_BAD_TLD,RCVD_IN_DNSWL_BLOCKED,RCVD_IN_VALIDITY_CERTIFIED, RCVD_IN_VALIDITY_RPBL,RCVD_IN_VALIDITY_SAFE,SPF_HELO_PASS autolearn=ham autolearn_force=no version=3.4.6 Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mira.cbaines.net (Postfix) with ESMTPS id 6F36E27BBE9 for ; Mon, 17 Mar 2025 15:52:49 +0000 (GMT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1tuClD-0000tv-EN; Mon, 17 Mar 2025 11:52:18 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1tuCl2-0000sZ-QP for guix-patches@gnu.org; Mon, 17 Mar 2025 11:52:06 -0400 Received: from debbugs.gnu.org ([2001:470:142:5::43]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1tuCl0-0008P1-Jt for guix-patches@gnu.org; Mon, 17 Mar 2025 11:52:04 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=debbugs.gnu.org; s=debbugs-gnu-org; h=MIME-Version:Date:From:To:Subject; bh=AR68vEazbiBABnzn1Y+PUoWhZEPt+fPR1D3mMGWzXyk=; b=pcAa5DxEk4j5Ik+6vleReF8sspAkRohOufQI9P1eWZK5tcgY5gzrZdcLe1qgyZavTizGpDVz6fHnhgwL02Uu+HxbJwVdmjWHCIEbwI2K1ZU6Xv3ZrTWtvESFh2Hcx2kbeZbjeMEDsDaQMr1/k5g4UvcbOlCQRswhMdYPbDLToqx3zFW9rIVI7VTwieER6EH46INuMZW2jVqezy7tfWskqZubavw2YgpK/IlrtzGYKGGSM4jluImGuiJ7xFCLcnkB2Oca5cyOjM1iUGpG1W9Gf8XwmDNIB1Aekmq9W0xiSYK9/cW88ANhAOznyeQvoXvwC0F/or7Uu8zfrvwO1cB5GQ==; Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1tuCkz-0000Ti-Vq for guix-patches@gnu.org; Mon, 17 Mar 2025 11:52:02 -0400 X-Loop: help-debbugs@gnu.org Subject: [bug#77073] [PATCH] gnu: Add gdb-16. Resent-From: Zheng Junjie Original-Sender: "Debbugs-submit" Resent-CC: guix-patches@gnu.org Resent-Date: Mon, 17 Mar 2025 15:52:01 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: report 77073 X-GNU-PR-Package: guix-patches X-GNU-PR-Keywords: patch To: 77073@debbugs.gnu.org X-Debbugs-Original-To: guix-patches@gnu.org Received: via spool by submit@debbugs.gnu.org id=B.17422266891522 (code B ref -1); Mon, 17 Mar 2025 15:52:01 +0000 Received: (at submit) by debbugs.gnu.org; 17 Mar 2025 15:51:29 +0000 Received: from localhost ([127.0.0.1]:60248 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1tuCkP-0000OC-Sg for submit@debbugs.gnu.org; Mon, 17 Mar 2025 11:51:28 -0400 Received: from lists.gnu.org ([2001:470:142::17]:44978) by debbugs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.84_2) (envelope-from ) id 1tuCkK-0000ND-44 for submit@debbugs.gnu.org; Mon, 17 Mar 2025 11:51:24 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1tuCkE-0000BK-2z for guix-patches@gnu.org; Mon, 17 Mar 2025 11:51:14 -0400 Received: from mail.z572.online ([88.99.160.180]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1tuCkA-0008Js-0x for guix-patches@gnu.org; Mon, 17 Mar 2025 11:51:13 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=z572.online; s=me; t=1742227020; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=9tvmBxxtv9nOffwMmdI4tVFd8XIcpCvXEoA2LsJHnVg=; b=CEn6kJNugtKSowjRBRS+rWfeMoYUbK4xMOR3KRZAEKIeUQkRWLXGlYekEAJxWr2GlwhdLJ zvd3YJr0bIkiKohWWjpXeTgp7mYKqB3o/cAleGY8dU62sDIIyVdNDSmnviSUffD/E/NZdp 22jfH/y8cHB6z5TIurEQnhpoOgZ8zf0= Received: from m.tailaa68d.ts.net (mail1.85362086.com [107.174.64.25]) by mail.z572.online (OpenSMTPD) with ESMTPSA id afb35c72 (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO) for ; Mon, 17 Mar 2025 15:56:59 +0000 (UTC) From: Zheng Junjie Date: Mon, 17 Mar 2025 23:50:55 +0800 Message-ID: <913afae449eed97684c38dda38ea37f19d8d432b.1742226655.git.z572@z572.online> X-Mailer: git-send-email 2.48.1 MIME-Version: 1.0 Received-SPF: pass client-ip=88.99.160.180; envelope-from=z572@z572.online; helo=mail.z572.online X-Spam_score_int: 23 X-Spam_score: 2.3 X-Spam_bar: ++ X-Spam_report: (2.3 / 5.0 requ) BAYES_00=-1.9, DKIM_INVALID=0.1, DKIM_SIGNED=0.1, FROM_SUSPICIOUS_NTLD=0.499, FROM_SUSPICIOUS_NTLD_FP=1.999, PDS_OTHER_BAD_TLD=1.476, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, RCVD_IN_VALIDITY_SAFE_BLOCKED=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list X-BeenThere: guix-patches@gnu.org List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guix-patches-bounces+patchwork=mira.cbaines.net@gnu.org Sender: guix-patches-bounces+patchwork=mira.cbaines.net@gnu.org X-getmail-retrieved-from-mailbox: Patches * gnu/packages/gdb.scm (gdb-16): New variable. * gnu/packages/patches/gdb-16-hurd64.patch: New patch. * gnu/local.mk (dist_patch_DATA): Register it. Change-Id: I15fb50be38258ce99ddf260ada0b3f6304c8ed4a --- gnu/local.mk | 1 + gnu/packages/gdb.scm | 14 + gnu/packages/patches/gdb-16-hurd64.patch | 867 +++++++++++++++++++++++ 3 files changed, 882 insertions(+) create mode 100644 gnu/packages/patches/gdb-16-hurd64.patch base-commit: 507fc8d3e34b87f94a13a38fe259f1ae5abe8493 diff --git a/gnu/local.mk b/gnu/local.mk index 01d13a11ae8..700407d5c57 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -1413,6 +1413,7 @@ dist_patch_DATA = \ %D%/packages/patches/gd-fix-tests-on-i686.patch \ %D%/packages/patches/gd-brect-bounds.patch \ %D%/packages/patches/gdb-hurd64.patch \ + %D%/packages/patches/gdb-16-hurd64.patch \ %D%/packages/patches/gdk-pixbuf-honor-GUIX_GDK_PIXBUF_MODULE_FILES.patch \ %D%/packages/patches/gdm-default-session.patch \ %D%/packages/patches/gdm-remove-hardcoded-xwayland-path.patch \ diff --git a/gnu/packages/gdb.scm b/gnu/packages/gdb.scm index ef100306b4d..61239e3c3ae 100644 --- a/gnu/packages/gdb.scm +++ b/gnu/packages/gdb.scm @@ -6,6 +6,7 @@ ;;; Copyright © 2020 Vincent Legoll ;;; Copyright © 2020, 2021, 2024 Janneke Nieuwenhuizen ;;; Copyright © 2020, 2021 Maxim Cournoyer +;;; Copyright © 2025 Zheng Junjie ;;; ;;; This file is part of GNU Guix. ;;; @@ -176,6 +177,19 @@ (define-public gdb-15 (base32 "0k9i8mizg4hby020k53kqmc835pajh9c8d5klv5s1ddm6p6hqdc3")))))) +(define-public gdb-16 + (package + (inherit gdb-14) + (version "16.2") + (source (origin + (method url-fetch) + (uri (string-append "mirror://gnu/gdb/gdb-" + version ".tar.xz")) + (patches (search-patches "gdb-16-hurd64.patch")) + (sha256 + (base32 + "0681906z34jy134jkn820jzf8b4l42ki6sjkj33kfp7l4dzwn0j0")))))) + (define-public gdb ;; The "default" version. gdb-14) diff --git a/gnu/packages/patches/gdb-16-hurd64.patch b/gnu/packages/patches/gdb-16-hurd64.patch new file mode 100644 index 00000000000..f2c48d9db75 --- /dev/null +++ b/gnu/packages/patches/gdb-16-hurd64.patch @@ -0,0 +1,867 @@ +from https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=5110839934507dca11761e538ce3158849c1354b + +From 5110839934507dca11761e538ce3158849c1354b Mon Sep 17 00:00:00 2001 +From: Flavio Cruz +Date: Sun, 2 Feb 2025 23:15:22 -0500 +Subject: [PATCH] Port GDB to Hurd x86_64. + +This port extends the existing i686 port to support x86_64 by reusing +existing code whenever it makes sense. + +* gdb/amd64-gnu-tdep.c: Adds logic for handling signal frames and + position of amd64 registers in the different Hurd structs. + The signal code is very similar to i686, except the trampoline code + is adapted. +* gdb/config/i386/nm-i386gnu.h: renamed to gdb/config/i386/nm-x86-gnu.h + and adapt it for x86_64. +* gdb/config/i386/i386gnu.mn: renamed to gdb/config/i386/nm-x86-gnu.mn + and reuse it for x86_64. +* gdb/configure.host: recognize gnu64 as a host. +* gdb/configure.nat: recognize gnu64 host and update existing i386gnu to + reuse the new shared files. +* gdb/configure.tgt: recognize x86_64-*-gnu* triplet and use + amd64-gnu-tdep.c. +* gdb/i386-gnu-tdep.c: added i386_gnu_thread_state_reg_offset that is + copied from i386-gnu-nat.c. This makes it similar to amd64. +* gdb/i386-gnu-nat.c: rename it to x86-gnu-nat.c since we reuse this for + i386 and amd64. Updated REG_ADDR to use one of the structures. Added + VALID_REGISTER to make sure it's a register we can provide at this time + (not all of them are available in amd64). FLAGS_REGISTER is either rfl + or efl depending on the arch. Renamed functions and class from i386 to x86 + whenever they can be reused. + +Tested on Hurd x86_64 and i686. +--- + gdb/Makefile.in | 4 +- + gdb/amd64-gnu-tdep.c | 231 ++++++++++++++++++ + .../i386/{nm-i386gnu.h => nm-x86-gnu.h} | 7 + + gdb/config/i386/{i386gnu.mn => x86-gnu.mn} | 0 + gdb/configure.host | 1 + + gdb/configure.nat | 27 +- + gdb/configure.tgt | 6 +- + gdb/i386-gnu-tdep.c | 13 +- + gdb/{i386-gnu-nat.c => x86-gnu-nat.c} | 171 +++++++++---- + 9 files changed, 403 insertions(+), 57 deletions(-) + create mode 100644 gdb/amd64-gnu-tdep.c + rename gdb/config/i386/{nm-i386gnu.h => nm-x86-gnu.h} (83%) + rename gdb/config/i386/{i386gnu.mn => x86-gnu.mn} (100%) + rename gdb/{i386-gnu-nat.c => x86-gnu-nat.c} (68%) + +diff --git a/gdb/Makefile.in b/gdb/Makefile.in +index b726b1dc612..1619c8253dc 100644 +--- a/gdb/Makefile.in ++++ b/gdb/Makefile.in +@@ -741,6 +741,7 @@ ALL_64_TARGET_OBS = \ + amd64-darwin-tdep.o \ + amd64-dicos-tdep.o \ + amd64-fbsd-tdep.o \ ++ amd64-gnu-tdep.o \ + amd64-linux-tdep.o \ + amd64-netbsd-tdep.o \ + amd64-obsd-tdep.o \ +@@ -1700,6 +1701,7 @@ ALLDEPFILES = \ + amd64-dicos-tdep.c \ + amd64-fbsd-nat.c \ + amd64-fbsd-tdep.c \ ++ amd64-gnu-tdep.c \ + amd64-linux-nat.c \ + amd64-linux-tdep.c \ + amd64-nat.c \ +@@ -1755,7 +1757,6 @@ ALLDEPFILES = \ + i386-dicos-tdep.c \ + i386-fbsd-nat.c \ + i386-fbsd-tdep.c \ +- i386-gnu-nat.c \ + i386-gnu-tdep.c \ + i386-linux-nat.c \ + i386-linux-tdep.c \ +@@ -1882,6 +1883,7 @@ ALLDEPFILES = \ + vax-tdep.c \ + windows-nat.c \ + windows-tdep.c \ ++ x86-gnu-nat.c \ + x86-nat.c \ + x86-tdep.c \ + xcoffread.c \ +diff --git a/gdb/amd64-gnu-tdep.c b/gdb/amd64-gnu-tdep.c +new file mode 100644 +index 00000000000..435095e3359 +--- /dev/null ++++ b/gdb/amd64-gnu-tdep.c +@@ -0,0 +1,231 @@ ++/* Target-dependent code for the GNU Hurd. ++ Copyright (C) 2024 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 "extract-store-integer.h" ++#include "gdbcore.h" ++#include "osabi.h" ++#include "solib-svr4.h" ++ ++#include "amd64-tdep.h" ++#include "glibc-tdep.h" ++ ++/* Recognizing signal handler frames. */ ++ ++/* When the GNU/Hurd libc calls a signal handler, the return address points ++ inside the trampoline assembly snippet. ++ ++ If the trampoline function name can not be identified, we resort to reading ++ memory from the process in order to identify it. */ ++ ++static const gdb_byte gnu_sigtramp_code[] = ++{ ++/* rpc_wait_trampoline: */ ++ 0x48, 0xc7, 0xc0, 0xe7, 0xff, 0xff, 0xff, /* mov $-25,%rax */ ++ 0x0f, 0x05, /* syscall */ ++ 0x49, 0x89, 0x04, 0x24, /* mov %rax,(%r12) */ ++ 0x48, 0x89, 0xdc, /* mov %rbx,%rsp */ ++ ++/* trampoline: */ ++ 0x5f, /* pop %rdi */ ++ 0x5e, /* pop %rsi */ ++ 0x5a, /* pop %rdx */ ++ 0x48, 0x83, 0xc4, 0x08, /* add $0x8,%rsp */ ++ 0x41, 0xff, 0xd5, /* call *%r13 */ ++ ++/* RA HERE */ ++ 0x48, 0x8b, 0x7c, 0x24, 0x10, /* mov 0x10(%rsp),%rdi */ ++ 0xc3, /* ret */ ++ ++/* firewall: */ ++ 0xf4, /* hlt */ ++}; ++ ++#define GNU_SIGTRAMP_LEN (sizeof gnu_sigtramp_code) ++#define GNU_SIGTRAMP_TAIL 7 /* length of tail after RA */ ++ ++/* If THIS_FRAME is a sigtramp routine, return the address of the ++ start of the routine. Otherwise, return 0. */ ++ ++static CORE_ADDR ++amd64_gnu_sigtramp_start (frame_info_ptr this_frame) ++{ ++ CORE_ADDR pc = get_frame_pc (this_frame); ++ gdb_byte buf[GNU_SIGTRAMP_LEN]; ++ ++ if (!safe_frame_unwind_memory (this_frame, ++ pc + GNU_SIGTRAMP_TAIL - GNU_SIGTRAMP_LEN, ++ buf)) ++ return 0; ++ ++ if (memcmp (buf, gnu_sigtramp_code, GNU_SIGTRAMP_LEN) != 0) ++ return 0; ++ ++ return pc; ++} ++ ++/* Return whether THIS_FRAME corresponds to a Hurd sigtramp routine. */ ++ ++static int ++amd64_gnu_sigtramp_p (const frame_info_ptr &this_frame) ++{ ++ CORE_ADDR pc = get_frame_pc (this_frame); ++ const char *name; ++ ++ find_pc_partial_function (pc, &name, NULL, NULL); ++ ++ /* If we have a NAME, we can check for the trampoline function */ ++ if (name != NULL && strcmp (name, "trampoline") == 0) ++ return 1; ++ ++ return amd64_gnu_sigtramp_start (this_frame) != 0; ++} ++ ++/* Offset to sc_i386_thread_state in sigcontext, from . */ ++#define AMD64_GNU_SIGCONTEXT_THREAD_STATE_OFFSET 32 ++ ++/* Assuming THIS_FRAME is a Hurd sigtramp routine, return the ++ address of the associated sigcontext structure. */ ++ ++static CORE_ADDR ++amd64_gnu_sigcontext_addr (const frame_info_ptr &this_frame) ++{ ++ struct gdbarch *gdbarch = get_frame_arch (this_frame); ++ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); ++ CORE_ADDR pc; ++ CORE_ADDR sp; ++ gdb_byte buf[8]; ++ ++ get_frame_register (this_frame, AMD64_RSP_REGNUM, buf); ++ sp = extract_unsigned_integer (buf, 8, byte_order); ++ ++ pc = amd64_gnu_sigtramp_start (this_frame); ++ if (pc) ++ { ++ CORE_ADDR sigcontext_addr; ++ ++ /* The sigcontext structure address is passed as the third argument ++ * of the signal handler but %RDX is not saved across calls. Luckily, ++ * the structured is saved underneath the &__sigreturn and a dummy word ++ * to fill the slot for the address for __sigreturn to return to. ++ */ ++ read_memory (sp + 16, buf, 8); ++ sigcontext_addr = extract_unsigned_integer (buf, 8, byte_order); ++ return sigcontext_addr + AMD64_GNU_SIGCONTEXT_THREAD_STATE_OFFSET; ++ } ++ ++ error (_("Couldn't recognize signal trampoline.")); ++ return 0; ++} ++ ++/* Mapping between the general-purpose registers in `struct ++ sigcontext' format (starting at sc_i386_thread_state) ++ and GDB's register cache layout. */ ++ ++/* From . */ ++static int amd64_gnu_sc_reg_offset[] = ++{ ++ 15 * 8, /* %rax */ ++ 12 * 8, /* %rbx */ ++ 14 * 8, /* %rcx */ ++ 13 * 8, /* %rdx */ ++ 10 * 8, /* %rsi */ ++ 9 * 8, /* %rdi */ ++ 10 * 8, /* %rbp */ ++ 11 * 8, /* %rsp */ ++ 0 * 8, /* %r8 ... */ ++ 8 * 8, ++ 7 * 8, ++ 6 * 8, ++ 3 * 8, ++ 2 * 8, ++ 1 * 8, ++ 0 * 8, /* ... %r15 */ ++ 16 * 8, /* %rip */ ++ 18 * 8, /* %eflags */ ++ 17 * 8, /* %cs */ ++}; ++ ++/* From . */ ++static int amd64_gnu_gregset_reg_offset[] = ++{ ++ 10 * 8, /* %rax */ ++ 5 * 8, /* %rbx */ ++ 11 * 8, /* %rcx */ ++ 12 * 8, /* %rdx */ ++ 13 * 8, /* %rsi */ ++ 14 * 8, /* %rdi */ ++ 4 * 8, /* %rbp */ ++ 19 * 8, /* %rsp */ ++ 9 * 8, /* %r8 ... */ ++ 8 * 8, ++ 7 * 8, ++ 6 * 8, ++ 3 * 8, ++ 2 * 8, ++ 1 * 8, ++ 0 * 8, /* ... %r15 */ ++ 16 * 8, /* %rip */ ++ 18 * 8, /* %eflags */ ++ 17 * 8, /* %cs */ ++ -1, /* %ss */ ++ -1, /* %ds */ ++ -1, /* %es */ ++ -1, /* %fs */ ++ -1, /* %gs */ ++}; ++ ++static void ++amd64_gnu_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) ++{ ++ i386_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); ++ ++ amd64_init_abi (info, gdbarch, ++ amd64_target_description (X86_XSTATE_SSE_MASK, true)); ++ ++ /* Enable TLS support. */ ++ set_gdbarch_fetch_tls_load_module_address (gdbarch, ++ svr4_fetch_objfile_link_map); ++ ++ /* Hurd uses SVR4-style shared libraries. */ ++ set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); ++ ++ /* Hurd uses the dynamic linker included in the GNU C Library. */ ++ set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); ++ ++ tdep->gregset_reg_offset = amd64_gnu_gregset_reg_offset; ++ tdep->gregset_num_regs = ARRAY_SIZE (amd64_gnu_gregset_reg_offset); ++ tdep->sizeof_gregset = 21 * 8; /* sizeof (struct i386_thread_state); */ ++ ++ tdep->sigtramp_p = amd64_gnu_sigtramp_p; ++ tdep->sigcontext_addr = amd64_gnu_sigcontext_addr; ++ tdep->sc_reg_offset = amd64_gnu_sc_reg_offset; ++ tdep->sc_num_regs = ARRAY_SIZE (amd64_gnu_sc_reg_offset); ++ ++ /* Hurd uses SVR4-style shared libraries. */ ++ set_solib_svr4_fetch_link_map_offsets ++ (gdbarch, svr4_lp64_fetch_link_map_offsets); ++} ++ ++void _initialize_amd64_gnu_tdep (); ++void ++_initialize_amd64_gnu_tdep () ++{ ++ gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, ++ GDB_OSABI_HURD, amd64_gnu_init_abi); ++} +diff --git a/gdb/config/i386/nm-i386gnu.h b/gdb/config/i386/nm-x86-gnu.h +similarity index 83% +rename from gdb/config/i386/nm-i386gnu.h +rename to gdb/config/i386/nm-x86-gnu.h +index d2d5de83948..ed4d1729227 100644 +--- a/gdb/config/i386/nm-i386gnu.h ++++ b/gdb/config/i386/nm-x86-gnu.h +@@ -22,9 +22,16 @@ + /* Thread flavors used in re-setting the T bit. */ + #define THREAD_STATE_FLAVOR i386_REGS_SEGS_STATE + #define THREAD_STATE_SIZE i386_THREAD_STATE_COUNT ++#ifdef __x86_64__ ++#define THREAD_STATE_SET_TRACED(state) \ ++ ((struct i386_thread_state *) (state))->rfl |= 0x100 ++#define THREAD_STATE_CLEAR_TRACED(state) \ ++ ((((struct i386_thread_state *) (state))->rfl &= ~0x100), 1) ++#else + #define THREAD_STATE_SET_TRACED(state) \ + ((struct i386_thread_state *) (state))->efl |= 0x100 + #define THREAD_STATE_CLEAR_TRACED(state) \ + ((((struct i386_thread_state *) (state))->efl &= ~0x100), 1) ++#endif /* __x86_64__ */ + + #endif /* CONFIG_I386_NM_I386GNU_H */ +diff --git a/gdb/config/i386/i386gnu.mn b/gdb/config/i386/x86-gnu.mn +similarity index 100% +rename from gdb/config/i386/i386gnu.mn +rename to gdb/config/i386/x86-gnu.mn +diff --git a/gdb/configure.host b/gdb/configure.host +index 22855cdbdf8..fdd651987e3 100644 +--- a/gdb/configure.host ++++ b/gdb/configure.host +@@ -183,6 +183,7 @@ x86_64-*-mingw*) gdb_host=mingw64 + gdb_host_obs=mingw-hdep.o + ;; + x86_64-*-cygwin*) gdb_host=cygwin64 ;; ++x86_64-*-gnu*) gdb_host=gnu64 ;; + m32r*-*-linux*) gdb_host=linux ;; + + xtensa*-*-linux*) gdb_host=linux ;; +diff --git a/gdb/configure.nat b/gdb/configure.nat +index 9e78091250a..7b3896217d2 100644 +--- a/gdb/configure.nat ++++ b/gdb/configure.nat +@@ -211,23 +211,44 @@ case ${gdb_host} in + ;; + esac + ;; ++ gnu64) ++ case ${gdb_host_cpu} in ++ i386) ++ # Host: x86_64 running the GNU Hurd ++ NATDEPFILES='x86-gnu-nat.o gnu-nat.o \ ++ x86-nat.o nat/x86-dregs.o \ ++ amd64-nat.o fork-child.o \ ++ nat/fork-inferior.o \ ++ notify_S.o process_reply_S.o msg_reply_S.o \ ++ msg_U.o exc_request_U.o exc_request_S.o' ++ HAVE_NATIVE_GCORE_HOST=1 ++ ++ NAT_FILE='nm-x86-gnu.h' ++ MH_CFLAGS='-D_GNU_SOURCE' ++ ++ XM_CLIBS='-lshouldbeinlibc' ++ ++ nat_makefile_frag="${srcdir}/config/${gdb_host_cpu}/x86-gnu.mn" ++ ;; ++ esac ++ ;; + i386gnu) + case ${gdb_host_cpu} in + i386) + # Host: Intel 386 running the GNU Hurd +- NATDEPFILES='i386-gnu-nat.o gnu-nat.o \ ++ NATDEPFILES='x86-gnu-nat.o gnu-nat.o \ + x86-nat.o nat/x86-dregs.o fork-child.o \ + nat/fork-inferior.o \ + notify_S.o process_reply_S.o msg_reply_S.o \ + msg_U.o exc_request_U.o exc_request_S.o' + HAVE_NATIVE_GCORE_HOST=1 + +- NAT_FILE='nm-i386gnu.h' ++ NAT_FILE='nm-x86-gnu.h' + MH_CFLAGS='-D_GNU_SOURCE' + + XM_CLIBS='-lshouldbeinlibc' + +- nat_makefile_frag="${srcdir}/config/${gdb_host_cpu}/i386gnu.mn" ++ nat_makefile_frag="${srcdir}/config/${gdb_host_cpu}/x86-gnu.mn" + ;; + esac + ;; +diff --git a/gdb/configure.tgt b/gdb/configure.tgt +index f7b9e32cba9..18a15c032c3 100644 +--- a/gdb/configure.tgt ++++ b/gdb/configure.tgt +@@ -327,7 +327,7 @@ i[34567]86-*-linux*) + ;; + i[34567]86-*-gnu*) + # Target: Intel 386 running the GNU Hurd +- gdb_target_obs="i386-gnu-tdep.o solib-svr4.o" ++ gdb_target_obs="i386-gnu-tdep.o glibc-tdep.o solib-svr4.o" + ;; + i[34567]86-*-cygwin*) + # Target: Intel 386 running win32 +@@ -734,6 +734,10 @@ x86_64-*-openbsd*) + x86_64-*-rtems*) + gdb_target_obs="${amd64_tobjs} ${i386_tobjs} i386-bsd-tdep.o" + ;; ++x86_64-*-gnu*) ++ # Target: x86_64 running the GNU Hurd ++ gdb_target_obs="amd64-gnu-tdep.o glibc-tdep.o solib-svr4.o" ++ ;; + xtensa*-*-*linux*) + # Target: GNU/Linux Xtensa + gdb_target_obs="xtensa-linux-tdep.o symfile-mem.o linux-tdep.o" +diff --git a/gdb/i386-gnu-tdep.c b/gdb/i386-gnu-tdep.c +index 98e11518a91..5ffc1388ec0 100644 +--- a/gdb/i386-gnu-tdep.c ++++ b/gdb/i386-gnu-tdep.c +@@ -21,6 +21,7 @@ + #include "osabi.h" + #include "solib-svr4.h" + ++#include "glibc-tdep.h" + #include "i386-tdep.h" + + /* Recognizing signal handler frames. */ +@@ -72,8 +73,7 @@ i386_gnu_sigtramp_start (const frame_info_ptr &this_frame) + return pc; + } + +-/* Return whether THIS_FRAME corresponds to a GNU/Linux sigtramp +- routine. */ ++/* Return whether THIS_FRAME corresponds to a Hurd sigtramp routine. */ + + static int + i386_gnu_sigtramp_p (const frame_info_ptr &this_frame) +@@ -178,9 +178,18 @@ i386gnu_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) + /* GNU uses ELF. */ + i386_elf_init_abi (info, gdbarch); + ++ /* Hurd uses SVR4-style shared libraries. */ ++ set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); + set_solib_svr4_fetch_link_map_offsets + (gdbarch, svr4_ilp32_fetch_link_map_offsets); + ++ /* Hurd uses the dynamic linker included in the GNU C Library. */ ++ set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); ++ ++ /* Enable TLS support. */ ++ set_gdbarch_fetch_tls_load_module_address (gdbarch, ++ svr4_fetch_objfile_link_map); ++ + tdep->gregset_reg_offset = i386gnu_gregset_reg_offset; + tdep->gregset_num_regs = ARRAY_SIZE (i386gnu_gregset_reg_offset); + tdep->sizeof_gregset = 19 * 4; +diff --git a/gdb/i386-gnu-nat.c b/gdb/x86-gnu-nat.c +similarity index 68% +rename from gdb/i386-gnu-nat.c +rename to gdb/x86-gnu-nat.c +index 52d4a4b7cec..da3b7e923dd 100644 +--- a/gdb/i386-gnu-nat.c ++++ b/gdb/x86-gnu-nat.c +@@ -34,7 +34,13 @@ extern "C" + #include "floatformat.h" + #include "regcache.h" + ++ ++#ifdef __x86_64__ ++#include "amd64-tdep.h" ++#include "amd64-nat.h" ++#else + #include "i386-tdep.h" ++#endif + + #include "inf-child.h" + #include "i387-tdep.h" +@@ -42,21 +48,82 @@ extern "C" + /* Offset to the thread_state_t location where REG is stored. */ + #define REG_OFFSET(reg) offsetof (struct i386_thread_state, reg) + ++#ifdef __x86_64__ ++ + /* At REG_OFFSET[N] is the offset to the thread_state_t location where + the GDB register N is stored. */ +-static int reg_offset[] = ++static int amd64_gnu_thread_state_reg_offset[] = + { +- REG_OFFSET (eax), REG_OFFSET (ecx), REG_OFFSET (edx), REG_OFFSET (ebx), +- REG_OFFSET (uesp), REG_OFFSET (ebp), REG_OFFSET (esi), REG_OFFSET (edi), +- REG_OFFSET (eip), REG_OFFSET (efl), REG_OFFSET (cs), REG_OFFSET (ss), +- REG_OFFSET (ds), REG_OFFSET (es), REG_OFFSET (fs), REG_OFFSET (gs) ++ REG_OFFSET (rax), /* %rax */ ++ REG_OFFSET (rbx), /* %rbx */ ++ REG_OFFSET (rcx), /* %rcx */ ++ REG_OFFSET (rdx), /* %rdx */ ++ REG_OFFSET (rsi), /* %rsi */ ++ REG_OFFSET (rdi), /* %rdi */ ++ REG_OFFSET (rbp), /* %rbp */ ++ REG_OFFSET (ursp), /* %rsp */ ++ REG_OFFSET (r8), /* %r8 ... */ ++ REG_OFFSET (r9), ++ REG_OFFSET (r10), ++ REG_OFFSET (r11), ++ REG_OFFSET (r12), ++ REG_OFFSET (r13), ++ REG_OFFSET (r14), ++ REG_OFFSET (r15), /* ... %r15 */ ++ REG_OFFSET (rip), /* %rip */ ++ REG_OFFSET (rfl), /* %rflags */ ++ REG_OFFSET (cs) /* %cs */ + }; + +-#define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum]) ++static const int amd64_gnu_thread_state_num_regs = ++ ARRAY_SIZE (amd64_gnu_thread_state_reg_offset); ++ ++#define REG_ADDR(state, regnum) \ ++ ((char *)(state) + amd64_gnu_thread_state_reg_offset[regnum]) ++#define VALID_REGISTER(regnum) \ ++ ((regnum) >= 0 && (regnum) < amd64_gnu_thread_state_num_regs) ++#define NUM_GREGS amd64_gnu_thread_state_num_regs ++#define FLAGS_REGISTER rfl ++ ++#else ++ ++/* At REG_OFFSET[N] is the offset to the thread_state_t location where ++ the GDB register N is stored. */ ++static int i386_gnu_thread_state_reg_offset[] = ++{ ++ REG_OFFSET (eax), /* %eax */ ++ REG_OFFSET (ecx), /* %ecx */ ++ REG_OFFSET (edx), /* %edx */ ++ REG_OFFSET (ebx), /* %ebx */ ++ REG_OFFSET (uesp), /* %esp */ ++ REG_OFFSET (ebp), /* %ebp */ ++ REG_OFFSET (esi), /* %esi */ ++ REG_OFFSET (edi), /* %edi */ ++ REG_OFFSET (eip), /* %eip */ ++ REG_OFFSET (efl), /* %efl */ ++ REG_OFFSET (cs), /* %cs */ ++ REG_OFFSET (ss), /* %ss */ ++ REG_OFFSET (ds), /* %ds */ ++ REG_OFFSET (es), /* %es */ ++ REG_OFFSET (fs), /* %fs */ ++ REG_OFFSET (gs) /* gs */ ++}; ++ ++static const int i386_gnu_thread_state_num_regs = ++ ARRAY_SIZE (i386_gnu_thread_state_reg_offset); ++ ++#define REG_ADDR(state, regnum) \ ++ ((char *)(state) + i386_gnu_thread_state_reg_offset[regnum]) ++#define VALID_REGISTER(regnum) \ ++ ((regnum) >= 0 && (regnum) < i386_gnu_thread_state_num_regs) ++#define NUM_GREGS i386_gnu_thread_state_num_regs ++#define FLAGS_REGISTER efl ++ ++#endif /* __x86_64__ */ + + + +-/* The i386 GNU Hurd target. */ ++/* The x86 GNU Hurd target. */ + + #ifdef i386_DEBUG_STATE + using gnu_base_target = x86_nat_target; +@@ -64,13 +131,13 @@ using gnu_base_target = x86_nat_target; + using gnu_base_target = gnu_nat_target; + #endif + +-struct i386_gnu_nat_target final : public gnu_base_target ++struct x86_gnu_nat_target final : public gnu_base_target + { + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + }; + +-static i386_gnu_nat_target the_i386_gnu_nat_target; ++static x86_gnu_nat_target the_x86_gnu_nat_target; + + /* Get the whole floating-point state of THREAD and record the values + of the corresponding (pseudo) registers. */ +@@ -105,7 +172,7 @@ fetch_fpregs (struct regcache *regcache, struct proc *thread) + + /* Fetch register REGNO, or all regs if REGNO is -1. */ + void +-i386_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno) ++x86_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno) + { + struct proc *thread; + ptid_t ptid = regcache->ptid (); +@@ -118,7 +185,7 @@ i386_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno) + error (_("Can't fetch registers from thread %s: No such thread"), + target_pid_to_str (ptid).c_str ()); + +- if (regno < I386_NUM_GREGS || regno == -1) ++ if (VALID_REGISTER (regno) || regno == -1) + { + thread_state_t state; + +@@ -137,7 +204,7 @@ i386_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno) + + proc_debug (thread, "fetching all register"); + +- for (i = 0; i < I386_NUM_GREGS; i++) ++ for (i = 0; i < NUM_GREGS; i++) + regcache->raw_supply (i, REG_ADDR (state, i)); + thread->fetched_regs = ~0; + } +@@ -152,7 +219,7 @@ i386_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno) + } + } + +- if (regno >= I386_NUM_GREGS || regno == -1) ++ if (!VALID_REGISTER(regno) || regno == -1) + { + proc_debug (thread, "fetching floating-point registers"); + +@@ -195,7 +262,7 @@ store_fpregs (const struct regcache *regcache, struct proc *thread, int regno) + + /* Store at least register REGNO, or all regs if REGNO == -1. */ + void +-i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno) ++x86_gnu_nat_target::store_registers (struct regcache *regcache, int regno) + { + struct proc *thread; + struct gdbarch *gdbarch = regcache->arch (); +@@ -209,7 +276,7 @@ i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno) + error (_("Couldn't store registers into thread %s: No such thread"), + target_pid_to_str (ptid).c_str ()); + +- if (regno < I386_NUM_GREGS || regno == -1) ++ if (VALID_REGISTER (regno) || regno == -1) + { + thread_state_t state; + thread_state_data_t old_state; +@@ -230,14 +297,14 @@ i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno) + + /* Save the T bit. We might try to restore the %eflags register + below, but changing the T bit would seriously confuse GDB. */ +- trace = ((struct i386_thread_state *)state)->efl & 0x100; ++ trace = ((struct i386_thread_state *)state)->FLAGS_REGISTER & 0x100; + + if (!was_aborted && was_valid) + /* See which registers have changed after aborting the thread. */ + { + int check_regno; + +- for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++) ++ for (check_regno = 0; check_regno < NUM_GREGS; check_regno++) + if ((thread->fetched_regs & (1 << check_regno)) + && memcpy (REG_ADDR (&old_state, check_regno), + REG_ADDR (state, check_regno), +@@ -262,7 +329,7 @@ i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno) + + proc_debug (thread, "storing all registers"); + +- for (i = 0; i < I386_NUM_GREGS; i++) ++ for (i = 0; i < NUM_GREGS; i++) + if (REG_VALID == regcache->get_register_status (i)) + regcache->raw_collect (i, REG_ADDR (state, i)); + } +@@ -276,11 +343,11 @@ i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno) + } + + /* Restore the T bit. */ +- ((struct i386_thread_state *)state)->efl &= ~0x100; +- ((struct i386_thread_state *)state)->efl |= trace; ++ ((struct i386_thread_state *)state)->FLAGS_REGISTER &= ~0x100; ++ ((struct i386_thread_state *)state)->FLAGS_REGISTER |= trace; + } + +- if (regno >= I386_NUM_GREGS || regno == -1) ++ if (!VALID_REGISTER (regno) || regno == -1) + { + proc_debug (thread, "storing floating-point registers"); + +@@ -295,7 +362,7 @@ i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno) + /* Get debug registers for thread THREAD. */ + + static void +-i386_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread) ++x86_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread) + { + mach_msg_type_number_t count = i386_DEBUG_STATE_COUNT; + kern_return_t err; +@@ -310,7 +377,7 @@ i386_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread) + /* Set debug registers for thread THREAD. */ + + static void +-i386_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread) ++x86_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread) + { + kern_return_t err; + +@@ -324,23 +391,23 @@ i386_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread) + /* Set DR_CONTROL in THREAD. */ + + static void +-i386_gnu_dr_set_control_one (struct proc *thread, void *arg) ++x86_gnu_dr_set_control_one (struct proc *thread, void *arg) + { + unsigned long *control = (unsigned long *) arg; + struct i386_debug_state regs; + +- i386_gnu_dr_get (®s, thread); ++ x86_gnu_dr_get (®s, thread); + regs.dr[DR_CONTROL] = *control; +- i386_gnu_dr_set (®s, thread); ++ x86_gnu_dr_set (®s, thread); + } + + /* Set DR_CONTROL to CONTROL in all threads. */ + + static void +-i386_gnu_dr_set_control (unsigned long control) ++x86_gnu_dr_set_control (unsigned long control) + { + inf_update_procs (gnu_current_inf); +- inf_threads (gnu_current_inf, i386_gnu_dr_set_control_one, &control); ++ inf_threads (gnu_current_inf, x86_gnu_dr_set_control_one, &control); + } + + /* Parameters to set a debugging address. */ +@@ -354,20 +421,20 @@ struct reg_addr + /* Set address REGNUM (zero based) to ADDR in THREAD. */ + + static void +-i386_gnu_dr_set_addr_one (struct proc *thread, void *arg) ++x86_gnu_dr_set_addr_one (struct proc *thread, void *arg) + { + struct reg_addr *reg_addr = (struct reg_addr *) arg; + struct i386_debug_state regs; + +- i386_gnu_dr_get (®s, thread); ++ x86_gnu_dr_get (®s, thread); + regs.dr[reg_addr->regnum] = reg_addr->addr; +- i386_gnu_dr_set (®s, thread); ++ x86_gnu_dr_set (®s, thread); + } + + /* Set address REGNUM (zero based) to ADDR in all threads. */ + + static void +-i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr) ++x86_gnu_dr_set_addr (int regnum, CORE_ADDR addr) + { + struct reg_addr reg_addr; + +@@ -377,13 +444,13 @@ i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr) + reg_addr.addr = addr; + + inf_update_procs (gnu_current_inf); +- inf_threads (gnu_current_inf, i386_gnu_dr_set_addr_one, ®_addr); ++ inf_threads (gnu_current_inf, x86_gnu_dr_set_addr_one, ®_addr); + } + + /* Get debug register REGNUM value from only the one LWP of PTID. */ + + static unsigned long +-i386_gnu_dr_get_reg (ptid_t ptid, int regnum) ++x86_gnu_dr_get_reg (ptid_t ptid, int regnum) + { + struct i386_debug_state regs; + struct proc *thread; +@@ -392,7 +459,7 @@ i386_gnu_dr_get_reg (ptid_t ptid, int regnum) + inf_update_procs (gnu_current_inf); + + thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ()); +- i386_gnu_dr_get (®s, thread); ++ x86_gnu_dr_get (®s, thread); + + return regs.dr[regnum]; + } +@@ -400,46 +467,50 @@ i386_gnu_dr_get_reg (ptid_t ptid, int regnum) + /* Return the inferior's debug register REGNUM. */ + + static CORE_ADDR +-i386_gnu_dr_get_addr (int regnum) ++x86_gnu_dr_get_addr (int regnum) + { + gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR); + +- return i386_gnu_dr_get_reg (inferior_ptid, regnum); ++ return x86_gnu_dr_get_reg (inferior_ptid, regnum); + } + + /* Get DR_STATUS from only the one thread of INFERIOR_PTID. */ + + static unsigned long +-i386_gnu_dr_get_status (void) ++x86_gnu_dr_get_status (void) + { +- return i386_gnu_dr_get_reg (inferior_ptid, DR_STATUS); ++ return x86_gnu_dr_get_reg (inferior_ptid, DR_STATUS); + } + + /* Return the inferior's DR7 debug control register. */ + + static unsigned long +-i386_gnu_dr_get_control (void) ++x86_gnu_dr_get_control (void) + { +- return i386_gnu_dr_get_reg (inferior_ptid, DR_CONTROL); ++ return x86_gnu_dr_get_reg (inferior_ptid, DR_CONTROL); + } + #endif /* i386_DEBUG_STATE */ + +-void _initialize_i386gnu_nat (); ++void _initialize_x86_gnu_nat (); + void +-_initialize_i386gnu_nat () ++_initialize_x86_gnu_nat () + { + #ifdef i386_DEBUG_STATE +- x86_dr_low.set_control = i386_gnu_dr_set_control; ++ x86_dr_low.set_control = x86_gnu_dr_set_control; + gdb_assert (DR_FIRSTADDR == 0 && DR_LASTADDR < i386_DEBUG_STATE_COUNT); +- x86_dr_low.set_addr = i386_gnu_dr_set_addr; +- x86_dr_low.get_addr = i386_gnu_dr_get_addr; +- x86_dr_low.get_status = i386_gnu_dr_get_status; +- x86_dr_low.get_control = i386_gnu_dr_get_control; ++ x86_dr_low.set_addr = x86_gnu_dr_set_addr; ++ x86_dr_low.get_addr = x86_gnu_dr_get_addr; ++ x86_dr_low.get_status = x86_gnu_dr_get_status; ++ x86_dr_low.get_control = x86_gnu_dr_get_control; ++#ifdef __x86_64__ ++ x86_set_debug_register_length (8); ++#else + x86_set_debug_register_length (4); ++#endif + #endif /* i386_DEBUG_STATE */ + +- gnu_target = &the_i386_gnu_nat_target; ++ gnu_target = &the_x86_gnu_nat_target; + + /* Register the target. */ +- add_inf_child_target (&the_i386_gnu_nat_target); ++ add_inf_child_target (&the_x86_gnu_nat_target); + } +-- +2.47.1 +