Port GDB to powerpc-lynx178.

gdb/ChangeLog:

        * defs.h (enum gdb_osabi): Add GDB_OSABI_LYNXOS178.
        * osabi.c (gdb_osabi_names): Add entry for GDB_OSABI_LYNXOS178.
        * xcoffread.c (xcoff_get_core_n_import_files): New function.
        (xcoff_get_n_import_files): New function.
        * xcoffread.h (xcoffread.h): Add declaration.
        * rs6000-aix-tdep.c: #include "xcoffread.h".
        (rs6000_aix_osabi_sniffer): Do not return GDB_OSABI_AIX for
        XCOFF executables that do not depend on any shared library.
        * rs6000-lynx178-tdep.c: New file.
        * configure.tgt: Add powerpc-*-lynx*178 handling.
        * Makefile.in (ALL_TARGET_OBS): Add rs6000-lynx178-tdep.o.
        (ALLDEPFILES): Add rs6000-lynx178-tdep.c.

9 files changed, 518 insertions, 0 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index c7549c3..48c10b9 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,18 @@
+2012-12-18  Joel Brobecker  <brobecker@adacore.com>
+
+	* defs.h (enum gdb_osabi): Add GDB_OSABI_LYNXOS178.
+	* osabi.c (gdb_osabi_names): Add entry for GDB_OSABI_LYNXOS178.
+	* xcoffread.c (xcoff_get_core_n_import_files): New function.
+	(xcoff_get_n_import_files): New function.
+	* xcoffread.h (xcoffread.h): Add declaration.
+	* rs6000-aix-tdep.c: #include "xcoffread.h".
+	(rs6000_aix_osabi_sniffer): Do not return GDB_OSABI_AIX for
+	XCOFF executables that do not depend on any shared library.
+	* rs6000-lynx178-tdep.c: New file.
+	* configure.tgt: Add powerpc-*-lynx*178 handling.
+	* Makefile.in (ALL_TARGET_OBS): Add rs6000-lynx178-tdep.o.
+	(ALLDEPFILES): Add rs6000-lynx178-tdep.c.
+
 2012-12-18  Hui Zhu  <hui_zhu@mentor.com>
 
 	* ui-file.c (ui_file): Add to_fseek.
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 244694c..194568b 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -565,6 +565,7 @@ ALL_TARGET_OBS = \
 	ppc-linux-tdep.o ppcnbsd-tdep.o ppcobsd-tdep.o ppc-sysv-tdep.o \
 	rl78-tdep.o \
 	rs6000-aix-tdep.o rs6000-tdep.o ppc-ravenscar-thread.o \
+	rs6000-lynx178-tdep.o \
 	rx-tdep.o \
 	s390-tdep.o \
 	score-tdep.o \
@@ -1488,6 +1489,7 @@ ALLDEPFILES = \
 	dcache.c \
 	rl78-tdep.c \
 	rs6000-nat.c rs6000-tdep.c ppc-ravenscar-thread.c \
+	rs6000-lynx178-tdep.c \
 	rx-tdep.c \
 	s390-tdep.c s390-nat.c \
 	score-tdep.c \
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index 6aa2dfd..5b77bb2 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -411,6 +411,12 @@ powerpc-*-linux* | powerpc64-*-linux*)
 	gdb_sim=../sim/ppc/libsim.a
 	build_gdbserver=yes
 	;;
+powerpc-*-lynx*178)
+	# Target: PowerPC running Lynx178.
+	gdb_target_obs="rs6000-tdep.o rs6000-lynx178-tdep.o \
+			xcoffread.o monitor.o dsrec.o ppc-sysv-tdep.o \
+			ravenscar-thread.o ppc-ravenscar-thread.o"
+	;;
 powerpc*-*-*)
 	# Target: PowerPC running eabi
 	gdb_target_obs="rs6000-tdep.o monitor.o dsrec.o ppcbug-rom.o \
diff --git a/gdb/defs.h b/gdb/defs.h
index ee49a89..2e0bff3 100644
--- a/gdb/defs.h
+++ b/gdb/defs.h
@@ -597,6 +597,7 @@ enum gdb_osabi
   GDB_OSABI_DARWIN,
   GDB_OSABI_SYMBIAN,
   GDB_OSABI_OPENVMS,
+  GDB_OSABI_LYNXOS178,
 
   GDB_OSABI_INVALID		/* keep this last */
 };
diff --git a/gdb/osabi.c b/gdb/osabi.c
index 7f60984..42cb8a0 100644
--- a/gdb/osabi.c
+++ b/gdb/osabi.c
@@ -73,6 +73,7 @@ static const char * const gdb_osabi_names[] =
   "Darwin",
   "Symbian",
   "OpenVMS",
+  "LynxOS178",
 
   "<invalid>"
 };
diff --git a/gdb/rs6000-aix-tdep.c b/gdb/rs6000-aix-tdep.c
index b4fc931..8b1c416 100644
--- a/gdb/rs6000-aix-tdep.c
+++ b/gdb/rs6000-aix-tdep.c
@@ -35,6 +35,7 @@
 #include "rs6000-tdep.h"
 #include "ppc-tdep.h"
 #include "exceptions.h"
+#include "xcoffread.h"
 
 /* Hook for determining the TOC address when calling functions in the
    inferior under AIX.  The initialization code in rs6000-nat.c sets
@@ -739,6 +740,13 @@ rs6000_aix_osabi_sniffer (bfd *abfd)
 {
   gdb_assert (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
 
+  /* The only noticeable difference between Lynx178 XCOFF files and
+     AIX XCOFF files comes from the fact that there are no shared
+     libraries on Lynx178.  On AIX, we are betting that an executable
+     linked with no shared library will never exist.  */
+  if (xcoff_get_n_import_files (abfd) <= 0)
+    return GDB_OSABI_UNKNOWN;
+
   return GDB_OSABI_AIX;
 }
 
diff --git a/gdb/rs6000-lynx178-tdep.c b/gdb/rs6000-lynx178-tdep.c
new file mode 100644
index 0000000..92a6bc2
--- /dev/null
+++ b/gdb/rs6000-lynx178-tdep.c
@@ -0,0 +1,422 @@
+/* Copyright (C) 2012 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/>.  */
+
+#include "defs.h"
+#include "osabi.h"
+#include "regcache.h"
+#include "gdbcore.h"
+#include "gdbtypes.h"
+#include "infcall.h"
+#include "ppc-tdep.h"
+#include "value.h"
+#include "xcoffread.h"
+
+/* Implement the "push_dummy_call" gdbarch method.  */
+
+static CORE_ADDR
+rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch,
+				struct value *function,
+				struct regcache *regcache, CORE_ADDR bp_addr,
+				int nargs, struct value **args, CORE_ADDR sp,
+				int struct_return, CORE_ADDR struct_addr)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  int ii;
+  int len = 0;
+  int argno;			/* current argument number */
+  int argbytes;			/* current argument byte */
+  gdb_byte tmp_buffer[50];
+  int f_argno = 0;		/* current floating point argno */
+  int wordsize = gdbarch_tdep (gdbarch)->wordsize;
+  CORE_ADDR func_addr = find_function_addr (function, NULL);
+
+  struct value *arg = 0;
+  struct type *type;
+
+  ULONGEST saved_sp;
+
+  /* The calling convention this function implements assumes the
+     processor has floating-point registers.  We shouldn't be using it
+     on PPC variants that lack them.  */
+  gdb_assert (ppc_floating_point_unit_p (gdbarch));
+
+  /* The first eight words of ther arguments are passed in registers.
+     Copy them appropriately.  */
+  ii = 0;
+
+  /* If the function is returning a `struct', then the first word
+     (which will be passed in r3) is used for struct return address.
+     In that case we should advance one word and start from r4
+     register to copy parameters.  */
+  if (struct_return)
+    {
+      regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
+				   struct_addr);
+      ii++;
+    }
+
+  /* Effectively indirect call... gcc does...
+
+     return_val example( float, int);
+
+     eabi:
+     float in fp0, int in r3
+     offset of stack on overflow 8/16
+     for varargs, must go by type.
+     power open:
+     float in r3&r4, int in r5
+     offset of stack on overflow different
+     both:
+     return in r3 or f0.  If no float, must study how gcc emulates floats;
+     pay attention to arg promotion.
+     User may have to cast\args to handle promotion correctly
+     since gdb won't know if prototype supplied or not.  */
+
+  for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
+    {
+      int reg_size = register_size (gdbarch, ii + 3);
+
+      arg = args[argno];
+      type = check_typedef (value_type (arg));
+      len = TYPE_LENGTH (type);
+
+      if (TYPE_CODE (type) == TYPE_CODE_FLT)
+	{
+
+	  /* Floating point arguments are passed in fpr's, as well as gpr's.
+	     There are 13 fpr's reserved for passing parameters.  At this point
+	     there is no way we would run out of them.  */
+
+	  gdb_assert (len <= 8);
+
+	  regcache_cooked_write (regcache,
+	                         tdep->ppc_fp0_regnum + 1 + f_argno,
+	                         value_contents (arg));
+	  ++f_argno;
+	}
+
+      if (len > reg_size)
+	{
+
+	  /* Argument takes more than one register.  */
+	  while (argbytes < len)
+	    {
+	      gdb_byte word[MAX_REGISTER_SIZE];
+	      memset (word, 0, reg_size);
+	      memcpy (word,
+		      ((char *) value_contents (arg)) + argbytes,
+		      (len - argbytes) > reg_size
+		        ? reg_size : len - argbytes);
+	      regcache_cooked_write (regcache,
+	                            tdep->ppc_gp0_regnum + 3 + ii,
+				    word);
+	      ++ii, argbytes += reg_size;
+
+	      if (ii >= 8)
+		goto ran_out_of_registers_for_arguments;
+	    }
+	  argbytes = 0;
+	  --ii;
+	}
+      else
+	{
+	  /* Argument can fit in one register.  No problem.  */
+	  int adj = gdbarch_byte_order (gdbarch)
+		    == BFD_ENDIAN_BIG ? reg_size - len : 0;
+	  gdb_byte word[MAX_REGISTER_SIZE];
+
+	  memset (word, 0, reg_size);
+	  memcpy (word, value_contents (arg), len);
+	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
+	}
+      ++argno;
+    }
+
+ran_out_of_registers_for_arguments:
+
+  regcache_cooked_read_unsigned (regcache,
+				 gdbarch_sp_regnum (gdbarch),
+				 &saved_sp);
+
+  /* Location for 8 parameters are always reserved.  */
+  sp -= wordsize * 8;
+
+  /* Another six words for back chain, TOC register, link register, etc.  */
+  sp -= wordsize * 6;
+
+  /* Stack pointer must be quadword aligned.  */
+  sp = align_down (sp, 16);
+
+  /* If there are more arguments, allocate space for them in
+     the stack, then push them starting from the ninth one.  */
+
+  if ((argno < nargs) || argbytes)
+    {
+      int space = 0, jj;
+
+      if (argbytes)
+	{
+	  space += align_up (len - argbytes, 4);
+	  jj = argno + 1;
+	}
+      else
+	jj = argno;
+
+      for (; jj < nargs; ++jj)
+	{
+	  struct value *val = args[jj];
+
+	  space += align_up (TYPE_LENGTH (value_type (val)), 4);
+	}
+
+      /* Add location required for the rest of the parameters.  */
+      space = align_up (space, 16);
+      sp -= space;
+
+      /* This is another instance we need to be concerned about
+         securing our stack space.  If we write anything underneath %sp
+         (r1), we might conflict with the kernel who thinks he is free
+         to use this area.  So, update %sp first before doing anything
+         else.  */
+
+      regcache_raw_write_signed (regcache,
+				 gdbarch_sp_regnum (gdbarch), sp);
+
+      /* If the last argument copied into the registers didn't fit there
+         completely, push the rest of it into stack.  */
+
+      if (argbytes)
+	{
+	  write_memory (sp + 24 + (ii * 4),
+			value_contents (arg) + argbytes,
+			len - argbytes);
+	  ++argno;
+	  ii += align_up (len - argbytes, 4) / 4;
+	}
+
+      /* Push the rest of the arguments into stack.  */
+      for (; argno < nargs; ++argno)
+	{
+
+	  arg = args[argno];
+	  type = check_typedef (value_type (arg));
+	  len = TYPE_LENGTH (type);
+
+
+	  /* Float types should be passed in fpr's, as well as in the
+             stack.  */
+	  if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
+	    {
+
+	      gdb_assert (len <= 8);
+
+	      regcache_cooked_write (regcache,
+				     tdep->ppc_fp0_regnum + 1 + f_argno,
+				     value_contents (arg));
+	      ++f_argno;
+	    }
+
+	  write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
+	  ii += align_up (len, 4) / 4;
+	}
+    }
+
+  /* Set the stack pointer.  According to the ABI, the SP is meant to
+     be set _before_ the corresponding stack space is used.  On AIX,
+     this even applies when the target has been completely stopped!
+     Not doing this can lead to conflicts with the kernel which thinks
+     that it still has control over this not-yet-allocated stack
+     region.  */
+  regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
+
+  /* Set back chain properly.  */
+  store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
+  write_memory (sp, tmp_buffer, wordsize);
+
+  /* Point the inferior function call's return address at the dummy's
+     breakpoint.  */
+  regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
+
+  target_store_registers (regcache, -1);
+  return sp;
+}
+
+/* Implement the "return_value" gdbarch method.  */
+
+static enum return_value_convention
+rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function,
+			     struct type *valtype, struct regcache *regcache,
+			     gdb_byte *readbuf, const gdb_byte *writebuf)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+  /* The calling convention this function implements assumes the
+     processor has floating-point registers.  We shouldn't be using it
+     on PowerPC variants that lack them.  */
+  gdb_assert (ppc_floating_point_unit_p (gdbarch));
+
+  /* AltiVec extension: Functions that declare a vector data type as a
+     return value place that return value in VR2.  */
+  if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
+      && TYPE_LENGTH (valtype) == 16)
+    {
+      if (readbuf)
+	regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
+      if (writebuf)
+	regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
+
+      return RETURN_VALUE_REGISTER_CONVENTION;
+    }
+
+  /* If the called subprogram returns an aggregate, there exists an
+     implicit first argument, whose value is the address of a caller-
+     allocated buffer into which the callee is assumed to store its
+     return value.  All explicit parameters are appropriately
+     relabeled.  */
+  if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
+      || TYPE_CODE (valtype) == TYPE_CODE_UNION
+      || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
+    return RETURN_VALUE_STRUCT_CONVENTION;
+
+  /* Scalar floating-point values are returned in FPR1 for float or
+     double, and in FPR1:FPR2 for quadword precision.  Fortran
+     complex*8 and complex*16 are returned in FPR1:FPR2, and
+     complex*32 is returned in FPR1:FPR4.  */
+  if (TYPE_CODE (valtype) == TYPE_CODE_FLT
+      && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
+    {
+      struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
+      gdb_byte regval[8];
+
+      /* FIXME: kettenis/2007-01-01: Add support for quadword
+	 precision and complex.  */
+
+      if (readbuf)
+	{
+	  regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
+	  convert_typed_floating (regval, regtype, readbuf, valtype);
+	}
+      if (writebuf)
+	{
+	  convert_typed_floating (writebuf, valtype, regval, regtype);
+	  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
+	}
+
+      return RETURN_VALUE_REGISTER_CONVENTION;
+  }
+
+  /* Values of the types int, long, short, pointer, and char (length
+     is less than or equal to four bytes), as well as bit values of
+     lengths less than or equal to 32 bits, must be returned right
+     justified in GPR3 with signed values sign extended and unsigned
+     values zero extended, as necessary.  */
+  if (TYPE_LENGTH (valtype) <= tdep->wordsize)
+    {
+      if (readbuf)
+	{
+	  ULONGEST regval;
+
+	  /* For reading we don't have to worry about sign extension.  */
+	  regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
+					 &regval);
+	  store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
+				  regval);
+	}
+      if (writebuf)
+	{
+	  /* For writing, use unpack_long since that should handle any
+	     required sign extension.  */
+	  regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
+					  unpack_long (valtype, writebuf));
+	}
+
+      return RETURN_VALUE_REGISTER_CONVENTION;
+    }
+
+  /* Eight-byte non-floating-point scalar values must be returned in
+     GPR3:GPR4.  */
+
+  if (TYPE_LENGTH (valtype) == 8)
+    {
+      gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
+      gdb_assert (tdep->wordsize == 4);
+
+      if (readbuf)
+	{
+	  gdb_byte regval[8];
+
+	  regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
+	  regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
+				regval + 4);
+	  memcpy (readbuf, regval, 8);
+	}
+      if (writebuf)
+	{
+	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
+	  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
+				 writebuf + 4);
+	}
+
+      return RETURN_VALUE_REGISTER_CONVENTION;
+    }
+
+  return RETURN_VALUE_STRUCT_CONVENTION;
+}
+
+/* PowerPC Lynx178 OSABI sniffer.  */
+
+static enum gdb_osabi
+rs6000_lynx178_osabi_sniffer (bfd *abfd)
+{
+  if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
+    return GDB_OSABI_UNKNOWN;
+
+  /* The only noticeable difference between Lynx178 XCOFF files and
+     AIX XCOFF files comes from the fact that there are no shared
+     libraries on Lynx178.  So if the number of import files is
+     different from zero, it cannot be a Lynx178 binary.  */
+  if (xcoff_get_n_import_files (abfd) != 0)
+    return GDB_OSABI_UNKNOWN;
+
+  return GDB_OSABI_LYNXOS178;
+}
+
+/* Callback for powerpc-lynx178 initialization.  */
+
+static void
+rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+  set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call);
+  set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value);
+  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+}
+
+/* -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_rs6000_lynx178_tdep;
+
+void
+_initialize_rs6000_lynx178_tdep (void)
+{
+  gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
+                                  bfd_target_xcoff_flavour,
+                                  rs6000_lynx178_osabi_sniffer);
+  gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
+                          rs6000_lynx178_init_osabi);
+}
+
diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c
index 10c93cc..f3562ff 100644
--- a/gdb/xcoffread.c
+++ b/gdb/xcoffread.c
@@ -3113,6 +3113,67 @@ static const struct sym_fns xcoff_sym_fns =
   &psym_functions
 };
 
+/* Same as xcoff_get_n_import_files, but for core files.  */
+
+static int
+xcoff_get_core_n_import_files (bfd *abfd)
+{
+  asection *sect = bfd_get_section_by_name (abfd, ".ldinfo");
+  gdb_byte buf[4];
+  file_ptr offset = 0;
+  int n_entries = 0;
+
+  if (sect == NULL)
+    return -1;  /* Not a core file.  */
+
+  for (offset = 0; offset < bfd_get_section_size (sect);)
+    {
+      int next;
+
+      n_entries++;
+
+      if (!bfd_get_section_contents (abfd, sect, buf, offset, 4))
+	return -1;
+      next = bfd_get_32 (abfd, buf);
+      if (next == 0)
+	break;  /* This is the last entry.  */
+      offset += next;
+    }
+
+  /* Return the number of entries, excluding the first one, which is
+     the path to the executable that produced this core file.  */
+  return n_entries - 1;
+}
+
+/* Return the number of import files (shared libraries) that the given
+   BFD depends on.  Return -1 if this number could not be computed.  */
+
+int
+xcoff_get_n_import_files (bfd *abfd)
+{
+  asection *sect = bfd_get_section_by_name (abfd, ".loader");
+  gdb_byte buf[4];
+  int l_nimpid;
+
+  /* If the ".loader" section does not exist, the objfile is probably
+     not an executable.  Might be a core file...  */
+  if (sect == NULL)
+    return xcoff_get_core_n_import_files (abfd);
+
+  /* The number of entries in the Import Files Table is stored in
+     field l_nimpid.  This field is always at offset 16, and is
+     always 4 bytes long.  Read those 4 bytes.  */
+
+  if (!bfd_get_section_contents (abfd, sect, buf, 16, 4))
+    return -1;
+  l_nimpid = bfd_get_32 (abfd, buf);
+
+  /* By convention, the first entry is the default LIBPATH value
+     to be used by the system loader, so it does not count towards
+     the number of import files.  */
+  return l_nimpid - 1;
+}
+
 /* Free the per-objfile xcoff data.  */
 
 static void
diff --git a/gdb/xcoffread.h b/gdb/xcoffread.h
index 3df08ee..86e1d07 100644
--- a/gdb/xcoffread.h
+++ b/gdb/xcoffread.h
@@ -21,4 +21,6 @@
 
 extern CORE_ADDR xcoff_get_toc_offset (struct objfile *);
 
+extern int xcoff_get_n_import_files (bfd *abfd);
+
 #endif /* xcoffread.h */