[RFC/RFA] Adding new files for Interix (take 3)

Joel Brobecker
2002-10-15T23:54:53Z

[-- Attachment #1: Type: text/plain, Size: 580 bytes --]

Hello,

I would like to check the following interix-specific files in the trunk.
I think I fixed most of Mark K's comments in the previous RFC;
hopefully, these file are now acceptable for inclusion.

2002-10-15 Joel Brobecker <brobecker@gnat.com>

New interix-specific files:
* config/i386/nm-interix.h: New file.
* config/i386/xm-interix.h: New file.
* config/i386/interix.mh: New file.
* config/i386/interix.mt: New file.
* i386-interix-nat.c: New file.
* i386-interix-tdep.c: New file.

OK to apply?

Thanks,
--
Joel

[-- Attachment #2: nm-interix.h --]
[-- Type: text/plain, Size: 1206 bytes --]

/* Native-dependent definitions for Intel 386 running Interix, for GDB.
Copyright 1986, 1987, 1989, 1992, 1996 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

#ifndef NM_INTERIX_H
#define NM_INTERIX_H

/* Be shared lib aware. */
#include "solib.h"

/* submodes of USE_PROC_FS. */
#define UNIXWARE

/* It's ALMOST coff; bfd does the same thing. Mostly used in coffread.c. */
#define COFF_IMAGE_WITH_PE

/* Turn on our own child_pid_to_exec_file. */
#define CHILD_PID_TO_EXEC_FILE

#endif /* NM_INTERIX_H */

[-- Attachment #3: xm-interix.h --]
[-- Type: text/plain, Size: 1643 bytes --]

/* Host-dependent definitions for i386 running Interix.
Copyright 2002 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */

#ifndef XM_I386INTERIX_H
#define XM_I386INTERIX_H

/* FIXME: This file is only temporary, and the final intent is to get
rid of each macro defined here. This will be done later. */

/* Interix has a minimal sbrk() (but not what's wanted for this usage),
and its relationship to environ[] is not what's usually expected
(as in, there is no specific relationship at all). Just pretend
we don't have an sbrk(). */
#undef HAVE_SBRK

#undef HAVE_POLL /* Only partially implemented so far. */

/* Used in coffread.c to adjust the symbol offsets. */
#define ADJUST_OBJFILE_OFFSETS(objfile, type) \
pei_adjust_objfile_offsets(objfile, type)

extern CORE_ADDR bfd_getImageBase(bfd *abfd);
#define NONZERO_LINK_BASE(abfd) bfd_getImageBase(abfd)

#endif /* XM_I386INTERIX_H */

[-- Attachment #4: interix.mh --]
[-- Type: text/plain, Size: 327 bytes --]

# Host: Intel 386 running Interix
XDEPFILES=
NATDEPFILES= corelow.o core-regset.o fork-child.o i386-interix-nat.o \
procfs.o proc-api.o proc-events.o proc-flags.o proc-why.o
NAT_FILE= nm-interix.h
XM_FILE= xm-interix.h
# The below may be temporary; mmalloc relies on sbrk() at the moment
MMALLOC=
MMALLOC_CFLAGS=-DNO_MMALLOC

[-- Attachment #5: interix.mt --]
[-- Type: text/plain, Size: 130 bytes --]

# Target: Intel 386 running Interix
TDEPFILES= i386-tdep.o i387-tdep.o i386-interix-tdep.o solib.o solib-pei.o
TM_FILE= tm-i386.h

[-- Attachment #6: i386-interix-nat.c --]
[-- Type: text/plain, Size: 4955 bytes --]

/* Native-dependent code for Interix running on i386's, for GDB.
Copyright 2002 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

#include "defs.h"

#include <sys/procfs.h>
#include <inferior.h>
#include <fcntl.h>

#include <i386-tdep.h>
#include "gdb_string.h"
#include "gdbcore.h"
#include "gregset.h"
#include "regcache.h"

typedef unsigned long greg_t;

/* This is a duplicate of the table in i386-linux-nat.c. */

static int regmap[] = {
EAX, ECX, EDX, EBX,
UESP, EBP, ESI, EDI,
EIP, EFL, CS, SS,
DS, ES, FS, GS,
};

/* Forward declarations. */
extern void _initialize_core_interix (void);
extern initialize_file_ftype _initialize_core_interix;

/* Given a pointer to a general register set in /proc format (gregset_t *),
unpack the register contents and supply them as gdb's idea of the current
register values. */

void
supply_gregset (gregset_t *gregsetp)
{
int regi;
greg_t *regp = (greg_t *) & gregsetp->gregs;

for (regi = 0; regi < I386_NUM_GREGS; regi++)
{
supply_register (regi, (char *) (regp + regmap[regi]));
}
}

/* Store GDB's value for REGNO in *GREGSETP. If REGNO is -1, do all
of them. */

void
fill_gregset (gregset_t *gregsetp, int regno)
{
int regi;
greg_t *regp = (greg_t *) gregsetp->gregs;

for (regi = 0; regi < I386_NUM_GREGS; regi++)
if (regno == -1 || regi == regno)
regcache_collect (regi, (void *) (regp + regmap[regi]));
}

/* Fill GDB's register file with the floating-point register values in
*FPREGSETP. */

void
supply_fpregset (fpregset_t *fpregsetp)
{
i387_supply_fsave ((char *) fpregsetp);
}

/* Given a pointer to a floating point register set in (fpregset_t *)
format, update all of the registers from gdb's idea of the current
floating point register set. */

void
fill_fpregset (fpregset_t *fpregsetp, int regno)
{
i387_fill_fsave ((char *) fpregsetp, regno);
}

/* Read the values of either the general register set (WHICH equals 0)
or the floating point register set (WHICH equals 2) from the core
file data (pointed to by CORE_REG_SECT), and update gdb's idea of
their current values. The CORE_REG_SIZE parameter is compared to
the size of the gregset or fpgregset structures (as appropriate) to
validate the size of the structure from the core file. The
REG_ADDR parameter is ignored. */

static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
CORE_ADDR reg_addr)
{
gdb_gregset_t gregset;
gdb_fpregset_t fpregset;

if (which == 0)
{
if (core_reg_size != sizeof (gregset))
{
warning ("wrong size gregset struct in core file");
}
else
{
memcpy ((char *) &gregset, core_reg_sect, sizeof (gregset));
supply_gregset (&gregset);
}
}
else if (which == 2)
{
if (core_reg_size != sizeof (fpregset))
{
warning ("wrong size fpregset struct in core file");
}
else
{
memcpy ((char *) &fpregset, core_reg_sect, sizeof (fpregset));
supply_fpregset (&fpregset);
}
}
}

#include <setjmp.h>

static struct core_fns interix_core_fns =
{
bfd_target_coff_flavour, /* core_flavour (more or less) */
default_check_format, /* check_format */
default_core_sniffer, /* core_sniffer */
fetch_core_registers, /* core_read_registers */
NULL /* next */
};

void
_initialize_core_interix (void)
{
add_core_fns (&interix_core_fns);
}

/* We don't have a /proc/pid/file or /proc/pid/exe to read a link from,
so read it from the same place ps gets the name. */

char *
child_pid_to_exec_file (int pid)
{
char *path;
char *buf;
int fd, c;
char *p;

xasprintf (&path, "/proc/%d/stat", pid);
buf = xcalloc (MAXPATHLEN + 1, sizeof (char));
make_cleanup (xfree, path);
make_cleanup (xfree, buf);

fd = open (path, O_RDONLY);

if (fd < 0)
return NULL;

/* Skip over "Argv0\t". */
lseek (fd, 6, SEEK_SET);

c = read (fd, buf, MAXPATHLEN);
close (fd);

if (c < 0)
return NULL;

buf[c] = '\0'; /* Ensure null termination. */
p = strchr (buf, '\n');
if (p != NULL)
*p = '\0';

return buf;
}

[-- Attachment #7: i386-interix-tdep.c --]
[-- Type: text/plain, Size: 12146 bytes --]

/* Target-dependent code for Interix running on i386's, for GDB.
Copyright 2002 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

#include "defs.h"
#include "arch-utils.h"

#include "frame.h"
#include "gdb_string.h"
#include "gdb-stabs.h"
#include "gdbcore.h"
#include "gdbtypes.h"
#include "i386-tdep.h"
#include "inferior.h"
#include "libbfd.h"
#include "objfiles.h"
#include "osabi.h"
#include "regcache.h"

/* offsetof (mcontext_t, gregs.gregs[EBP]) */
static const int mcontext_EBP_greg_offset = 180;

/* offsetof (mcontext_t, gregs.gregs[EIP]) */
static const int mcontext_EIP_greg_offset = 184;

/* offsetof (mcontext_t, gregs.gregs[UESP]) */
static const int mcontext_UESP_greg_offset = 196;

/* offsetof (mcontext_t, gregs.reserved[1]) */
static const int mcontext_syscall_greg_offset = 4;

/* offsetof (_JUMP_BUFFER, Eip) */
static const int jump_buffer_Eip_offset = 20;

/* See procfs.c and *interix*.h in config/[alpha,i386]. */
/* ??? These should be static, but this needs a bit of work before this
can be done. */
CORE_ADDR tramp_start;
CORE_ADDR tramp_end;
CORE_ADDR null_start;
CORE_ADDR null_end;
int winver; /* Windows NT version number */

/* Forward declarations. */
extern void _initialize_i386_interix_tdep (void);
extern initialize_file_ftype _initialize_i386_interix_tdep;

/* Adjust the section offsets in an objfile structure so that it's correct
for the type of symbols being read (or undo it with the _restore
arguments).

If main programs ever start showing up at other than the default Image
Base, this is where that would likely be applied. */

void
pei_adjust_objfile_offsets (struct objfile *objfile,
enum objfile_adjusts type)
{
int i;
CORE_ADDR symbols_offset;

switch (type)
{
case adjust_for_symtab:
symbols_offset = NONZERO_LINK_BASE (objfile->obfd);
break;
case adjust_for_symtab_restore:
symbols_offset = -NONZERO_LINK_BASE (objfile->obfd);
break;
case adjust_for_stabs:
case adjust_for_stabs_restore:
case adjust_for_dwarf:
case adjust_for_dwarf_restore:
default:
return;
}

for (i = 0; i < SECT_OFF_MAX; i++)
{
(objfile->section_offsets)->offsets[i] += symbols_offset;
}
}

static int
i386_interix_pc_in_sigtramp (CORE_ADDR pc, char *name)
{
/* This is sufficient, where used, but is NOT a complete test; There
is more in INIT_EXTRA_FRAME_INFO (a.k.a. interix_back_one_frame). */
return ((pc >= tramp_start && pc < tramp_end)
|| (pc >= null_start && pc < null_end));
}

static int
i386_interix_in_solib_call_trampoline (CORE_ADDR pc, char *name)
{
return i386_pe_skip_trampoline_code (pc, name);
}

static CORE_ADDR
i386_interix_skip_trampoline_code (CORE_ADDR pc)
{
return i386_pe_skip_trampoline_code (pc, 0);
}

static void
i386_interix_init_frame_pc (int fromleaf, struct frame_info *prev)
{
/* Nothing to do on Interix. */
}

static int
i386_interix_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
{
/* In the context where this is used, we get the saved PC before we've
successfully unwound far enough to be sure what we've got (it may
be a signal handler caller). If we're dealing with a signal
handler caller, this will return valid, which is fine. If not,
it'll make the correct test. */
return (thisframe->signal_handler_caller
|| (chain != 0
&& !inside_entry_file (read_memory_integer
(thisframe->frame + 4, 4))));
}

/* We want to find the previous frame, which on Interix is tricky when signals
are involved; set frame->frame appropriately, and also get the pc
and tweak signal_handler_caller; this replaces a boatload of nested
macros, as well. */
static void
i386_interix_back_one_frame (int fromleaf, struct frame_info *frame)
{
CORE_ADDR ra;
CORE_ADDR fm;
CORE_ADDR context;
long t;

if (frame == NULL)
internal_error (__FILE__, __LINE__, "unexpected NULL frame");

if (fromleaf)
{
frame->pc = SAVED_PC_AFTER_CALL (frame->next);
return;
}

if (!frame->next)
{
frame->pc = read_pc ();

/* Part of the signal stuff... See below. */
if (stopped_by_random_signal)
{
/* We know we're in a system call mini-frame; was it
NullApi or something else? */
ra = SAVED_PC_AFTER_CALL (frame);
if (ra >= null_start && ra < null_end)
frame->signal_handler_caller = 1;
/* There might also be an indirect call to the mini-frame,
putting one more return address on the stack. (XP only,
I think?) This can't (reasonably) return the address of the
signal handler caller unless it's that situation, so this
is safe. */
ra = read_memory_unsigned_integer (read_register (SP_REGNUM) + 4, 4);
if (ra >= null_start && ra < null_end)
frame->signal_handler_caller = 1;
}
return;
}

if (!frame->next->signal_handler_caller)
{
frame->pc = read_memory_integer (frame->next->frame + 4, 4);
return;
}

/* This is messy (actually AWFUL)... The "trampoline" might be 2, 3
or all 5 entities on the frame.

Chunk 1 will be present when we're actually in a signal handler.
Chunk 2 will be present when an asynchronous signal (one that
didn't come in with a system call) is present.
We may not (yet) be in the handler, if we're just returning
from the call.
When we're actually in a handler taken from an asynchronous
signal, both will be present.

Chunk 1:
PdxSignalDeliverer's frame
+ Context struct -- not accounted for in any frame

Chunk 2:
+ PdxNullPosixApi's frame
+ PdxNullApiCaller's frame
+ Context struct = 0x230 not accounted for in any frame

The symbol names come from examining objdumps of psxdll.dll;
they don't appear in the runtime image.

For gdb's purposes, we can pile all this into one frame. */

ra = frame->next->pc;
/* Are we already pointing at PdxNullPosixApi? We are if
this is a signal frame, we're at next-to-top, and were stopped
by a random signal (if it wasn't the right address under
these circumstances, we wouldn't be here at all by tests above
on the prior frame). */
if (frame->next->next == NULL && stopped_by_random_signal)
{
/* We're pointing at the frame FOR PdxNullApi. */
fm = frame->frame;
}
else
{
/* No... We must be pointing at the frame that was called
by PdxSignalDeliverer; back up across the whole mess. */

/* Extract the frame for PdxSignalDeliverer.
Note: FRAME_CHAIN used the "old" frame pointer because we were
a deliverer. Get the address of the context record that's on
here frameless. */
context = read_memory_integer (frame->frame, 4); /* an Arg */

/* Now extract the frame pointer contained in the context. */
fm = read_memory_integer (context + mcontext_EBP_greg_offset, 4);

ra = read_memory_integer (context + mcontext_EIP_greg_offset, 4);

/* We need to know if we're in a system call because we'll be
in a syscall mini-frame, if so, and the rules are different. */
t = (long) read_memory_integer (context + mcontext_syscall_greg_offset,
4);
/* t contains 0 if running free, 1 if blocked on a system call,
and 2 if blocked on an exception message (e.g. a trap);
we don't expect to get here with a 2. */
if (t != 1)
{
/* Not at a system call, therefore it can't be NullApi. */
frame->pc = ra;
frame->frame = fm;
return;
}

/* It's a system call... Mini frame, then look for NullApi. */
/* Get the RA (on the stack) associated with this... It's
a system call mini-frame. */
ra = read_memory_integer (context + mcontext_UESP_greg_offset, 4);

if (winver >= 51)
{
/* Newer versions of Windows NT interpose another return
address (but no other "stack frame" stuff) that we need
to simply ignore here. */
ra += 4;
}

ra = read_memory_integer (ra, 4);

if (!(ra >= null_start && ra < null_end))
{
/* No Null API present; we're done. */
frame->pc = ra;
frame->frame = fm;
return;
}
}

/* At this point, we're looking at the frame for PdxNullPosixApi,
in either case.

PdxNullPosixApi is called by PdxNullApiCaller (which in turn
is called by _PdxNullApiCaller (note the _).)
PdxNullPosixApiCaller (no _) is a frameless function.

The saved frame pointer is as fm, but it's not of interest
to us because it skips us over the saved context, which is
the wrong thing to do, because it skips the interrrupted
routine! PdxNullApiCaller takes as its only argument the
address of the context of the interrupded function (which
is really in no frame, but jammed on the stack by the system)

So: fm+0: saved bp
fm+4: return address to _PdxNullApiCaller
fm+8: arg to PdxNullApiCaller pushed by _Pdx... */

fm = read_memory_integer (fm + 0x8, 4);

/* Extract the second context record. */

ra = read_memory_integer (fm + mcontext_EIP_greg_offset, 4);
fm = read_memory_integer (fm + mcontext_EBP_greg_offset, 4);

frame->frame = fm;
frame->pc = ra;

return;
}

static CORE_ADDR
i386_interix_frame_saved_pc (struct frame_info *fi)
{
/* Assume that we've already unwound enough to have the caller's address
if we're dealing with a signal handler caller (And if that fails,
return 0). */
if (fi->signal_handler_caller)
return fi->next ? fi->next->pc : 0;
else
return read_memory_integer (fi->frame + 4, 4);
}

static void
i386_interix_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

tdep->struct_return = reg_struct_return;
tdep->jb_pc_offset = jump_buffer_Eip_offset;

set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_pc_in_sigtramp (gdbarch, i386_interix_pc_in_sigtramp);
set_gdbarch_in_solib_call_trampoline (gdbarch,
i386_interix_in_solib_call_trampoline);
set_gdbarch_skip_trampoline_code (gdbarch,
i386_interix_skip_trampoline_code);
set_gdbarch_init_extra_frame_info (gdbarch, i386_interix_back_one_frame);
set_gdbarch_init_frame_pc (gdbarch, i386_interix_init_frame_pc);
set_gdbarch_frame_chain_valid (gdbarch, i386_interix_frame_chain_valid);
set_gdbarch_frame_saved_pc (gdbarch, i386_interix_frame_saved_pc);
set_gdbarch_name_of_malloc (gdbarch, "_malloc");
}

static enum gdb_osabi
i386_interix_osabi_sniffer (bfd * abfd)
{
char *target_name = bfd_get_target (abfd);

if (strcmp (target_name, "pei-i386") == 0)
return GDB_OSABI_INTERIX;

return GDB_OSABI_UNKNOWN;
}

void
_initialize_i386_interix_tdep (void)
{
gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour,
i386_interix_osabi_sniffer);

gdbarch_register_osabi (bfd_arch_i386, GDB_OSABI_INTERIX,
i386_interix_init_abi);
}