binutils-gdb/gdb/configure.nat
Andrew Burgess cd9b374ffe gdb/gdbserver: share some code relating to target description creation
This commit is part of a series to share more of the x86 target
description creation code between GDB and gdbserver.

Unlike previous commits which were mostly refactoring, this commit is
the first that makes a real change, though that change should mostly
be for gdbserver; I've largely adopted the "GDB" way of doing things
for gdbserver, and this fixes a real gdbserver bug.

On a x86-64 Linux target, running the test:

  gdb.server/connect-with-no-symbol-file.exp

results in two core files being created.  Both of these core files are
from the inferior process, created after gdbserver has detached.

In this test a gdbserver process is started and then, after gdbserver
has started, but before GDB attaches, we either delete the inferior
executable, or change its permissions so it can't be read.  Only after
doing this do we attempt to connect with GDB.

As GDB connects to gdbserver, gdbserver attempts to figure out the
target description so that it can send the description to GDB, this
involves a call to x86_linux_read_description.

In x86_linux_read_description one of the first things we do is try to
figure out if the process is 32-bit or 64-bit.  To do this we look up
the executable via the thread-id, and then attempt to read the
architecture size from the executable.  This isn't going to work if
the executable has been deleted, or is no longer readable.

And so, as we can't read the executable, we default to an i386 target
and use an i386 target description.

A consequence of using an i386 target description is that addresses
are assumed to be 32-bits.  Here's an example session that shows the
problems this causes.  This is run on an x86-64 machine, and the test
binary (xx.x) is a standard 64-bit x86-64 binary:

  shell_1$ gdbserver --once localhost :54321 /tmp/xx.x

  shell_2$ gdb -q
  (gdb) set sysroot
  (gdb) shell chmod 000 /tmp/xx.x
  (gdb) target remote :54321
  Remote debugging using :54321
  warning: /tmp/xx.x: Permission denied.
  0xf7fd3110 in ?? ()
  (gdb) show architecture
  The target architecture is set to "auto" (currently "i386").
  (gdb) p/x $pc
  $1 = 0xf7fd3110
  (gdb) info proc mappings
  process 2412639
  Mapped address spaces:

  	Start Addr   End Addr       Size     Offset  Perms   objfile
  	  0x400000   0x401000     0x1000        0x0  r--p   /tmp/xx.x
  	  0x401000   0x402000     0x1000     0x1000  r-xp   /tmp/xx.x
  	  0x402000   0x403000     0x1000     0x2000  r--p   /tmp/xx.x
  	  0x403000   0x405000     0x2000     0x2000  rw-p   /tmp/xx.x
  	0xf7fcb000 0xf7fcf000     0x4000        0x0  r--p   [vvar]
  	0xf7fcf000 0xf7fd1000     0x2000        0x0  r-xp   [vdso]
  	0xf7fd1000 0xf7fd3000     0x2000        0x0  r--p   /usr/lib64/ld-2.30.so
  	0xf7fd3000 0xf7ff3000    0x20000     0x2000  r-xp   /usr/lib64/ld-2.30.so
  	0xf7ff3000 0xf7ffb000     0x8000    0x22000  r--p   /usr/lib64/ld-2.30.so
  	0xf7ffc000 0xf7ffe000     0x2000    0x2a000  rw-p   /usr/lib64/ld-2.30.so
  	0xf7ffe000 0xf7fff000     0x1000        0x0  rw-p
  	0xfffda000 0xfffff000    0x25000        0x0  rw-p   [stack]
  	0xff600000 0xff601000     0x1000        0x0  r-xp   [vsyscall]
  (gdb) info inferiors
    Num  Description       Connection           Executable
  * 1    process 2412639   1 (remote :54321)
  (gdb) shell cat /proc/2412639/maps
  00400000-00401000 r--p 00000000 fd:03 45907133           /tmp/xx.x
  00401000-00402000 r-xp 00001000 fd:03 45907133           /tmp/xx.x
  00402000-00403000 r--p 00002000 fd:03 45907133           /tmp/xx.x
  00403000-00405000 rw-p 00002000 fd:03 45907133           /tmp/xx.x
  7ffff7fcb000-7ffff7fcf000 r--p 00000000 00:00 0          [vvar]
  7ffff7fcf000-7ffff7fd1000 r-xp 00000000 00:00 0          [vdso]
  7ffff7fd1000-7ffff7fd3000 r--p 00000000 fd:00 143904     /usr/lib64/ld-2.30.so
  7ffff7fd3000-7ffff7ff3000 r-xp 00002000 fd:00 143904     /usr/lib64/ld-2.30.so
  7ffff7ff3000-7ffff7ffb000 r--p 00022000 fd:00 143904     /usr/lib64/ld-2.30.so
  7ffff7ffc000-7ffff7ffe000 rw-p 0002a000 fd:00 143904     /usr/lib64/ld-2.30.so
  7ffff7ffe000-7ffff7fff000 rw-p 00000000 00:00 0
  7ffffffda000-7ffffffff000 rw-p 00000000 00:00 0          [stack]
  ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0  [vsyscall]
  (gdb)

Notice the difference between the mappings reported via GDB and those
reported directly from the kernel via /proc/PID/maps, the addresses of
every mapping is clamped to 32-bits for GDB, while the kernel reports
real 64-bit addresses.

Notice also that the $pc value is a 32-bit value.  It appears to be
within one of the mappings reported by GDB, but is outside any of the
mappings reported from the kernel.

And this is where the problem arises.  When gdbserver detaches from
the inferior we pass the inferior the address from which it should
resume.  Due to the 32/64 bit confusion we tell the inferior to resume
from the 32-bit $pc value, which is not within any valid mapping, and
so, as soon as the inferior resumes, it segfaults.

If we look at how GDB (not gdbserver) figures out its target
description then we see an interesting difference.  GDB doesn't try to
read the executable.  Instead GDB uses ptrace to query the thread's
state, and uses this to figure out the if the thread is 32 or 64 bit.

If we update gdbserver to do it the "GDB" way then the above problem
is resolved, gdbserver now sees the process as 64-bit, and when we
detach from the inferior we give it the correct 64-bit address, and
the inferior no longer segfaults.

Now, I could just update the gdbserver code, but better, I think, to
share one copy of the code between GDB and gdbserver in gdb/nat/.
That is what this commit does.

The cores of x86_linux_read_description from gdbserver and
x86_linux_nat_target::read_description from GDB are moved into a new
file gdb/nat/x86-linux-tdesc.c and combined into a single function
x86_linux_tdesc_for_tid which is called from each location.

This new function does things the GDB way, the only changes are to
allow for the sharing; we now have a callback function to call the
first time that the xcr0 state is read, this allows for GDB and
gdbserver to perform their own initialisation as needed, and
additionally, the new function takes a pointer for where to cache the
xcr0 value, this isn't needed for this commit, but will be useful in a
later commit where gdbserver will want to read this cached xcr0
value.

Another thing to note about this commit is how the functions
i386_linux_read_description and amd64_linux_read_description are
handled.  For now I've left these function as implemented separately
in GDB and gdbserver.  I've moved the declarations of these functions
into gdb/nat/x86-linux-tdesc.h, but the implementations are left as
separate.

A later commit in this series will make these functions shared too,
but doing this is not trivial, so I've left that for a separate
commit.  Merging the declarations as I've done here ensures that
everyone implements the function to the same API, and once these
functions are shared (in a later commit) we'll want a shared
declaration anyway.

Approved-By: John Baldwin <jhb@FreeBSD.org>
2024-03-25 17:14:19 +00:00

506 lines
12 KiB
Bash

# ; -*- mode: sh ; -*-
# Copyright (C) 2013-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 <http://www.gnu.org/licenses/>.
# Variables defined here:
#
# NAT_FILE - The header file with definitions for this native target.
#
# NATDEPFILES - Source files required for native debugging on this
# native target.
#
# NAT_CDEPS - Dynamic symbols to be exported for libthread_db.
#
# LOADLIBES - Libraries against which GDB will be linked for this
# native target.
#
# MH_CFLAGS - Additional CFLAGS for this host.
#
# XM_CLIBS - Host-dependent libraries against which GDB will be linked
# for this native target.
#
# HAVE_NATIVE_GCORE_HOST - Whether gcore should be installed on this
# native target.
#
# nat_makefile_frag - Name of the (optional) Makefile fragment file
# required to build the native target. The
# fragment is incorporated into the Makefile that
# configure constructs from Makefile.in.
#
# Notes:
#
# - To avoid shell expansion of variables, declare them with single
# quotes.
#
# - nat_makefile_frag must contain the full path of the file.
# This first case is useful for filling default values for each
# gdb_host.
case ${gdb_host} in
*linux*)
NAT_FILE='config/nm-linux.h'
NATDEPFILES='inf-ptrace.o fork-child.o nat/fork-inferior.o \
proc-service.o \
linux-thread-db.o linux-nat.o nat/linux-osdata.o linux-fork.o \
nat/linux-procfs.o nat/linux-ptrace.o nat/linux-waitpid.o \
nat/linux-personality.o nat/linux-namespaces.o'
NAT_CDEPS='$(srcdir)/proc-service.list'
LOADLIBES='-ldl $(RDYNAMIC)'
;;
fbsd*)
NATDEPFILES='fork-child.o nat/fork-inferior.o inf-ptrace.o fbsd-nat.o'
HAVE_NATIVE_GCORE_HOST=1
LOADLIBES='-lkvm'
;;
nbsd*)
NATDEPFILES='fork-child.o nat/fork-inferior.o nat/netbsd-nat.o inf-ptrace.o'
HAVE_NATIVE_GCORE_HOST=1
;;
obsd*)
NATDEPFILES='fork-child.o nat/fork-inferior.o inf-ptrace.o'
;;
cygwin*)
NATDEPFILES='x86-nat.o nat/x86-dregs.o windows-nat.o nat/windows-nat.o'
;;
mingw*)
NATDEPFILES='x86-nat.o nat/x86-dregs.o windows-nat.o nat/windows-nat.o'
;;
aix)
NATDEPFILES='nat/fork-inferior.o fork-child.o inf-ptrace.o'
;;
darwin)
NATDEPFILES='fork-child.o nat/fork-inferior.o darwin-nat.o \
darwin-nat-info.o'
;;
sol2)
NATDEPFILES='fork-child.o nat/fork-inferior.o \
procfs.o proc-api.o proc-events.o proc-flags.o proc-why.o \
sol-thread.o'
HAVE_NATIVE_GCORE_HOST=1
;;
esac
# This is where we actually filter by host and host CPU.
case ${gdb_host} in
aix)
case ${gdb_host_cpu} in
powerpc)
# Host: IBM PowerPC running AIX aix-thread.o is not
# listed in NATDEPFILES as it is pulled in by
# configure.
NATDEPFILES="${NATDEPFILES} rs6000-aix-nat.o"
# When compiled with cc, for debugging, this argument
# should be passed. We have no idea who our current
# compiler is though, so we skip it.
# MH_CFLAGS='-bnodelcsect'
;;
esac
;;
alpha-linux)
case ${gdb_host_cpu} in
alpha)
# Host: Little-endian Alpha running Linux
NATDEPFILES="${NATDEPFILES} linux-nat-trad.o alpha-linux-nat.o"
# doublest.c currently assumes some properties of FP arithmetic
# on the host which require this.
MH_CFLAGS='-mieee'
;;
esac
;;
cygwin)
case ${gdb_host_cpu} in
i386)
# Native config information for GDB on i386
# systems running Cygwin.
NATDEPFILES="${NATDEPFILES} i386-windows-nat.o"
;;
esac
;;
cygwin64)
case ${gdb_host_cpu} in
i386)
# Native config information for GDB on amd64
# systems running Cygwin.
NATDEPFILES="${NATDEPFILES} i386-windows-nat.o amd64-windows-nat.o"
;;
esac
;;
darwin)
case ${gdb_host_cpu} in
i386)
# Host: IA86 running Darwin
NATDEPFILES="${NATDEPFILES} i386-darwin-nat.o x86-nat.o \
nat/x86-dregs.o amd64-nat.o"
;;
esac
;;
fbsd)
case ${gdb_host_cpu} in
aarch64)
# Host: FreeBSD/aarch64
NATDEPFILES="${NATDEPFILES} aarch64-nat.o \
nat/aarch64-hw-point.o aarch64-fbsd-nat.o"
LOADLIBES=
;;
arm)
# Host: FreeBSD/arm
NATDEPFILES="${NATDEPFILES} arm-fbsd-nat.o"
LOADLIBES=
;;
i386)
# Host: FreeBSD/i386
NATDEPFILES="${NATDEPFILES} x86-nat.o nat/x86-dregs.o \
nat/x86-xstate.o x86-bsd-nat.o x86-fbsd-nat.o i386-fbsd-nat.o \
bsd-kvm.o"
;;
mips)
# Host: FreeBSD/mips
NATDEPFILES="${NATDEPFILES} mips-fbsd-nat.o"
LOADLIBES=
;;
powerpc)
# Native config information for GDB on PowerPC
# systems running FreeBSD.
NATDEPFILES="${NATDEPFILES} ppc-fbsd-nat.o bsd-kvm.o"
;;
riscv*)
# Host: FreeBSD/riscv
NATDEPFILES="${NATDEPFILES} riscv-fbsd-nat.o"
;;
sparc)
# Host: FreeBSD/sparc64
NATDEPFILES="${NATDEPFILES} sparc-nat.o sparc64-nat.o \
sparc64-fbsd-nat.o bsd-kvm.o"
;;
esac
;;
fbsd64)
case ${gdb_host_cpu} in
i386)
# Host: FreeBSD/amd64
NATDEPFILES="${NATDEPFILES} amd64-nat.o \
amd64-fbsd-nat.o bsd-kvm.o x86-nat.o nat/x86-dregs.o \
nat/x86-xstate.o x86-bsd-nat.o x86-fbsd-nat.o"
;;
esac
;;
go32)
case ${gdb_host_cpu} in
i386)
# Host: Intel x86 running DJGPP
# We include several header files from config/djgpp
MH_CFLAGS='-I$(srcdir)/config/djgpp'
NATDEPFILES='go32-nat.o x86-nat.o nat/x86-dregs.o'
XM_CLIBS='-ldbg'
;;
esac
;;
i386gnu)
case ${gdb_host_cpu} in
i386)
# Host: Intel 386 running the GNU Hurd
NATDEPFILES='i386-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'
MH_CFLAGS='-D_GNU_SOURCE'
XM_CLIBS='-lshouldbeinlibc'
nat_makefile_frag="${srcdir}/config/${gdb_host_cpu}/i386gnu.mn"
;;
esac
;;
linux)
case ${gdb_host_cpu} in
aarch64)
# Host: AArch64 based machine running GNU/Linux
NATDEPFILES="${NATDEPFILES} aarch64-nat.o aarch64-linux-nat.o \
aarch32-linux-nat.o nat/aarch64-hw-point.o \
nat/aarch64-linux-hw-point.o \
nat/aarch64-linux.o \
nat/aarch64-scalable-linux-ptrace.o \
nat/aarch64-mte-linux-ptrace.o"
;;
arc)
# Host: ARC based machine running GNU/Linux
NATDEPFILES="${NATDEPFILES} arc-linux-nat.o"
;;
arm)
# Host: ARM based machine running GNU/Linux
NATDEPFILES="${NATDEPFILES} arm-linux-nat.o \
aarch32-linux-nat.o"
;;
i386)
# Host: Intel 386 running GNU/Linux.
NATDEPFILES="${NATDEPFILES} x86-nat.o nat/x86-dregs.o \
nat/x86-xstate.o \
i386-linux-nat.o x86-linux-nat.o nat/linux-btrace.o \
nat/x86-linux.o nat/x86-linux-dregs.o nat/x86-linux-tdesc.o"
;;
ia64)
# Host: Intel IA-64 running GNU/Linux
NATDEPFILES="${NATDEPFILES} ia64-linux-nat.o"
;;
loongarch)
# Host: LoongArch, running GNU/Linux.
NATDEPFILES="${NATDEPFILES} loongarch-linux-nat.o linux-nat-trad.o"
;;
m32r)
# Host: M32R based machine running GNU/Linux
NATDEPFILES="${NATDEPFILES} m32r-linux-nat.o"
;;
m68k)
# Host: Motorola m68k running GNU/Linux.
NATDEPFILES="${NATDEPFILES} m68k-linux-nat.o"
;;
mips)
# Host: Linux/MIPS
NATDEPFILES="${NATDEPFILES} linux-nat-trad.o \
mips-linux-nat.o nat/mips-linux-watch.o"
;;
or1k)
# Host: Linux/OpenRISC
NATDEPFILES="${NATDEPFILES} or1k-linux-nat.o"
;;
pa)
# Host: Hewlett-Packard PA-RISC machine, running Linux
NATDEPFILES="${NATDEPFILES} hppa-linux-nat.o"
;;
powerpc)
# Host: PowerPC, running Linux
NATDEPFILES="${NATDEPFILES} ppc-linux-nat.o nat/ppc-linux.o"
;;
riscv*)
# Host: RISC-V, running Linux
NATDEPFILES="${NATDEPFILES} riscv-linux-nat.o \
nat/riscv-linux-tdesc.o"
;;
s390)
# Host: S390, running Linux
NATDEPFILES="${NATDEPFILES} s390-linux-nat.o"
;;
sparc)
# Host: GNU/Linux SPARC
NATDEPFILES="${NATDEPFILES} sparc-nat.o sparc-linux-nat.o"
;;
tilegx)
# Host: Tilera TILE-Gx running GNU/Linux.
NATDEPFILES="${NATDEPFILES} tilegx-linux-nat.o"
NAT_CDEPS=
;;
xtensa)
# Host: Xtensa, running GNU/Linux.
NATDEPFILES="${NATDEPFILES} xtensa-linux-nat.o"
;;
esac
;;
linux64)
case ${gdb_host_cpu} in
i386)
# Host: GNU/Linux x86-64
NATDEPFILES="${NATDEPFILES} x86-nat.o nat/x86-dregs.o \
nat/x86-xstate.o amd64-nat.o amd64-linux-nat.o x86-linux-nat.o \
nat/linux-btrace.o \
nat/x86-linux.o nat/x86-linux-dregs.o nat/x86-linux-tdesc.o \
nat/amd64-linux-siginfo.o"
;;
sparc)
# Host: GNU/Linux UltraSPARC
NATDEPFILES="${NATDEPFILES} sparc-nat.o sparc64-nat.o \
sparc64-linux-nat.o"
;;
esac
;;
mingw)
case ${gdb_host_cpu} in
i386)
NATDEPFILES="${NATDEPFILES} i386-windows-nat.o"
;;
esac
;;
mingw64)
case ${gdb_host_cpu} in
i386)
NATDEPFILES="${NATDEPFILES} i386-windows-nat.o amd64-windows-nat.o"
;;
esac
;;
nbsd)
case ${gdb_host_cpu} in
alpha)
# Host: NetBSD/alpha
NATDEPFILES="${NATDEPFILES} alpha-bsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
mips)
# Host: NetBSD/mips
NATDEPFILES="${NATDEPFILES} mips-netbsd-nat.o"
;;
pa)
# Host: NetBSD/hppa
NATDEPFILES="${NATDEPFILES} netbsd-nat.o hppa-netbsd-nat.o"
;;
powerpc)
# Host: NetBSD/powerpc
NATDEPFILES="${NATDEPFILES} ppc-netbsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
sh)
# Host: NetBSD/sh
NATDEPFILES="${NATDEPFILES} sh-netbsd-nat.o"
;;
esac
;;
nbsd64)
case ${gdb_host_cpu} in
i386)
# Host: NetBSD/amd64
NATDEPFILES="${NATDEPFILES} netbsd-nat.o amd64-nat.o x86-nat.o \
nat/x86-dregs.o x86-bsd-nat.o amd64-bsd-nat.o amd64-netbsd-nat.o"
;;
sparc)
# Host: NetBSD/sparc64
NATDEPFILES="${NATDEPFILES} sparc64-netbsd-nat.o sparc-nat.o \
bsd-kvm.o"
LOADLIBES='-lkvm'
;;
esac
;;
nbsdelf)
case ${gdb_host_cpu} in
arm)
# Host: NetBSD/arm
NATDEPFILES="${NATDEPFILES} arm-netbsd-nat.o"
;;
i386)
# Host: NetBSD/i386 ELF
NATDEPFILES="${NATDEPFILES} netbsd-nat.o x86-nat.o \
nat/x86-dregs.o \
x86-bsd-nat.o i386-bsd-nat.o i386-netbsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
m68k)
# Host: NetBSD/m68k ELF
NATDEPFILES="${NATDEPFILES} m68k-bsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
sparc)
# Host: NetBSD/sparc ELF
NATDEPFILES="${NATDEPFILES} sparc-nat.o sparc-netbsd-nat.o \
bsd-kvm.o"
LOADLIBES='-lkvm'
;;
vax)
# Host: NetBSD/vax ELF
NATDEPFILES="${NATDEPFILES} vax-bsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
esac
;;
nto)
case ${gdb_host_cpu} in
i386)
# Host: Intel 386 running QNX.
NATDEPFILES='nto-procfs.o'
NAT_FILE='config/nm-nto.h'
;;
esac
;;
obsd)
case ${gdb_host_cpu} in
i386)
# Host: OpenBSD/i386 ELF
NATDEPFILES="${NATDEPFILES} obsd-nat.o x86-bsd-nat.o \
i386-bsd-nat.o i386-obsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
m68k)
# Host: OpenBSD/m68k
NATDEPFILES="${NATDEPFILES} m68k-bsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
pa)
# Host: OpenBSD/hppa
NATDEPFILES="${NATDEPFILES} obsd-nat.o hppa-obsd-nat.o"
;;
powerpc)
# Host: OpenBSD/powerpc
NATDEPFILES="${NATDEPFILES} obsd-nat.o ppc-obsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
vax)
# Host: OpenBSD/vax
NATDEPFILES="${NATDEPFILES} vax-bsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
esac
;;
obsd64)
case ${gdb_host_cpu} in
i386)
# Host: OpenBSD/amd64
NATDEPFILES="${NATDEPFILES} obsd-nat.o amd64-nat.o \
x86-bsd-nat.o amd64-bsd-nat.o amd64-obsd-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
mips)
# Host: OpenBSD/mips64
NATDEPFILES="${NATDEPFILES} obsd-nat.o mips64-obsd-nat.o"
;;
sparc)
# Host: OpenBSD/sparc64
NATDEPFILES="${NATDEPFILES} obsd-nat.o sparc64-obsd-nat.o \
sparc-nat.o bsd-kvm.o"
LOADLIBES='-lkvm'
;;
esac
;;
ppc64-linux)
case ${gdb_host_cpu} in
powerpc)
# Host: PowerPC64, running Linux
XM_CLIBS=
NATDEPFILES="${NATDEPFILES} ppc-linux-nat.o nat/ppc-linux.o"
;;
esac
;;
sol2)
case ${gdb_host_cpu} in
i386)
# Host: Solaris x86_64
NATDEPFILES="${NATDEPFILES} \
amd64-nat.o i386-sol2-nat.o"
;;
sparc)
# Host: Solaris SPARC & UltraSPARC
NAT_FILE='nm-sol2.h'
NATDEPFILES="${NATDEPFILES} sparc-sol2-nat.o"
;;
esac
;;
esac