sparc: support %dN and %qN syntax for FP registers.

[deliverable/binutils-gdb.git] / bfd / aix5ppc-core.c

diff --git a/bfd/aix5ppc-core.c b/bfd/aix5ppc-core.c
index 9db4f5468c458098fc3214e69c83b02d4bbff812..fe034b9c64905fee225553cac568c209b50a05ce 100644 (file)
--- a/bfd/aix5ppc-core.c
+++ b/bfd/aix5ppc-core.c
@@ -1,14 +1,13 @@
 /* IBM RS/6000 "XCOFF" back-end for BFD.
 /* IBM RS/6000 "XCOFF" back-end for BFD.

-   Copyright 2001, 2002
-   Free Software Foundation, Inc.
+   Copyright (C) 2001-2015 Free Software Foundation, Inc.

    Written by Tom Rix
    Written by Tom Rix

-   Contributed by Redhat.
+   Contributed by Red Hat Inc.

 
    This file is part of BFD, the Binary File Descriptor library.
 
    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
 
    This file is part of BFD, the Binary File Descriptor library.
 
    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
+   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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -18,21 +17,21 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */

 
 

+#include "sysdep.h"

 #include "bfd.h"
 
 #include "bfd.h"
 

+const bfd_target *xcoff64_core_p (bfd *);
+bfd_boolean xcoff64_core_file_matches_executable_p (bfd *, bfd *);
+char *xcoff64_core_file_failing_command (bfd *);
+int xcoff64_core_file_failing_signal (bfd *);
+

 #ifdef AIX_5_CORE
 
 #ifdef AIX_5_CORE
 

-#include "sysdep.h"

 #include "libbfd.h"
 
 #include "libbfd.h"
 

-const bfd_target * xcoff64_core_p PARAMS ((bfd *));
-boolean            xcoff64_core_file_matches_executable_p PARAMS ((bfd *, bfd *));
-char *             xcoff64_core_file_failing_command PARAMS ((bfd *));
-int                xcoff64_core_file_failing_signal PARAMS ((bfd *));
-

 /* Aix 5.1 system include file.  */
 
 /* Need to define this macro so struct ld_info64 get included.  */
 /* Aix 5.1 system include file.  */
 
 /* Need to define this macro so struct ld_info64 get included.  */


@@ -40,15 +39,20 @@ int                xcoff64_core_file_failing_signal PARAMS ((bfd *));
 #include <sys/ldr.h>
 #include <core.h>
 
 #include <sys/ldr.h>
 #include <core.h>
 

+/* The default architecture and machine for matching core files.  */
+#define DEFAULT_ARCHITECTURE   bfd_arch_powerpc
+#define DEFAULT_MACHINE                bfd_mach_ppc_620
+

 #define        core_hdr(abfd)          ((struct core_dumpxx *) abfd->tdata.any)
 
 #define CHECK_FILE_OFFSET(s, v) \
   ((bfd_signed_vma)(v) < 0 || (bfd_signed_vma)(v) > (bfd_signed_vma)(s).st_size)
 
 const bfd_target *
 #define        core_hdr(abfd)          ((struct core_dumpxx *) abfd->tdata.any)
 
 #define CHECK_FILE_OFFSET(s, v) \
   ((bfd_signed_vma)(v) < 0 || (bfd_signed_vma)(v) > (bfd_signed_vma)(s).st_size)
 
 const bfd_target *

-xcoff64_core_p (abfd)
-     bfd *abfd;
+xcoff64_core_p (bfd *abfd)

 {
 {

+  enum bfd_architecture arch;
+  unsigned long mach;

   struct core_dumpxx core, *new_core_hdr;
   struct stat statbuf;
   asection *sec;
   struct core_dumpxx core, *new_core_hdr;
   struct stat statbuf;
   asection *sec;


@@ -56,17 +60,18 @@ xcoff64_core_p (abfd)
   bfd_vma ld_offset;
   bfd_size_type i;
   struct vm_infox vminfo;
   bfd_vma ld_offset;
   bfd_size_type i;
   struct vm_infox vminfo;

-  bfd_target *return_value = NULL;
+  const bfd_target *return_value = NULL;
+  flagword flags;

 
   /* Get the header.  */
   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
     goto xcoff64_core_p_error;
 
 
   /* Get the header.  */
   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
     goto xcoff64_core_p_error;
 

-  if (sizeof (struct core_dumpxx) 
+  if (sizeof (struct core_dumpxx)

       != bfd_bread (&core, sizeof (struct core_dumpxx), abfd))
     goto xcoff64_core_p_error;
 
       != bfd_bread (&core, sizeof (struct core_dumpxx), abfd))
     goto xcoff64_core_p_error;
 

-  if (bfd_stat (abfd, &statbuf) < 0) 
+  if (bfd_stat (abfd, &statbuf) < 0)

     goto xcoff64_core_p_error;
 
   /* Sanity checks
     goto xcoff64_core_p_error;
 
   /* Sanity checks


@@ -82,24 +87,24 @@ xcoff64_core_p (abfd)
      See rs6000-core.c for comment on size of core
      If there isn't enough of a real core file, bail.  */
 
      See rs6000-core.c for comment on size of core
      If there isn't enough of a real core file, bail.  */
 

-  if ((CORE_VERSION_1 != (core.c_flag & CORE_VERSION_1)) 
-      || (0 != core.c_entries) 
-      || (! (IS_PROC64 (&core.c_u.U_proc))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_fdsinfox))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_loader))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_loader + core.c_lsize))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_thr))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_segregion))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_stack))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_stack + core.c_size))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_data))) 
-      || ((CHECK_FILE_OFFSET (statbuf, core.c_data + core.c_datasize))) 
-      || (! (core.c_flag & UBLOCK_VALID)) 
-      || (! (core.c_flag & LE_VALID))) 
+  if ((CORE_VERSION_1 != (core.c_flag & CORE_VERSION_1))
+      || (0 != core.c_entries)
+      || (! (IS_PROC64 (&core.c_u.U_proc)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_fdsinfox)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_loader)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_loader + core.c_lsize)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_thr)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_segregion)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_stack)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_stack + core.c_size)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_data)))
+      || ((CHECK_FILE_OFFSET (statbuf, core.c_data + core.c_datasize)))
+      || (! (core.c_flag & UBLOCK_VALID))
+      || (! (core.c_flag & LE_VALID)))

     goto xcoff64_core_p_error;
 
     goto xcoff64_core_p_error;
 

-  /* Check for trucated stack or general truncating.  */
-  if ((! (core.c_flag & USTACK_VALID)) 
+  /* Check for truncated stack or general truncating.  */
+  if ((! (core.c_flag & USTACK_VALID))

       || (core.c_flag & CORE_TRUNC))
     {
       bfd_set_error (bfd_error_file_truncated);
       || (core.c_flag & CORE_TRUNC))
     {
       bfd_set_error (bfd_error_file_truncated);


@@ -107,82 +112,84 @@ xcoff64_core_p (abfd)
       return return_value;
     }
 
       return return_value;
     }
 

-  new_core_hdr = (struct core_dumpxx *)
-    bfd_zalloc (abfd, sizeof (struct core_dumpxx));
-  if (NULL == new_core_hdr) 
+  new_core_hdr = bfd_zalloc (abfd, sizeof (struct core_dumpxx));
+  if (NULL == new_core_hdr)

     return return_value;
 
   memcpy (new_core_hdr, &core, sizeof (struct core_dumpxx));
     return return_value;
 
   memcpy (new_core_hdr, &core, sizeof (struct core_dumpxx));

-  core_hdr(abfd) = (char *)new_core_hdr;
+  /* The core_hdr() macro is no longer used here because it would
+     expand to code relying on gcc's cast-as-lvalue extension,
+     which was removed in gcc 4.0.  */
+  abfd->tdata.any = new_core_hdr;

 
   /* .stack section.  */
 
   /* .stack section.  */

-  sec = bfd_make_section_anyway (abfd, ".stack");
-  if (NULL == sec) 
+  flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
+  sec = bfd_make_section_anyway_with_flags (abfd, ".stack", flags);
+  if (NULL == sec)

     return return_value;
 
     return return_value;
 

-  sec->flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
-  sec->_raw_size = core.c_size;
+  sec->size = core.c_size;

   sec->vma = core.c_stackorg;
   sec->filepos = core.c_stack;
 
   /* .reg section for all registers.  */
   sec->vma = core.c_stackorg;
   sec->filepos = core.c_stack;
 
   /* .reg section for all registers.  */

-  sec = bfd_make_section_anyway (abfd, ".reg");
-  if (NULL == sec) 
+  flags = SEC_HAS_CONTENTS | SEC_IN_MEMORY;
+  sec = bfd_make_section_anyway_with_flags (abfd, ".reg", flags);
+  if (NULL == sec)

     return return_value;
 
     return return_value;
 

-  sec->flags = SEC_HAS_CONTENTS | SEC_IN_MEMORY;
-  sec->_raw_size = sizeof (struct __context64);
+  sec->size = sizeof (struct __context64);

   sec->vma = 0;
   sec->filepos = 0;
   sec->contents = (bfd_byte *)&new_core_hdr->c_flt.r64;
 
   /* .ldinfo section.
      To actually find out how long this section is in this particular
   sec->vma = 0;
   sec->filepos = 0;
   sec->contents = (bfd_byte *)&new_core_hdr->c_flt.r64;
 
   /* .ldinfo section.
      To actually find out how long this section is in this particular

-     core dump would require going down the whole list of struct 
+     core dump would require going down the whole list of struct

      ld_info's.   See if we can just fake it.  */
      ld_info's.   See if we can just fake it.  */

-  sec = bfd_make_section_anyway (abfd, ".ldinfo");
+  flags = SEC_HAS_CONTENTS;
+  sec = bfd_make_section_anyway_with_flags (abfd, ".ldinfo", flags);

   if (NULL == sec)
     return return_value;
 
   if (NULL == sec)
     return return_value;
 

-  sec->flags = SEC_HAS_CONTENTS;
-  sec->_raw_size = core.c_lsize;
+  sec->size = core.c_lsize;

   sec->vma = 0;
   sec->filepos = core.c_loader;
 
   /* AIX 4 adds data sections from loaded objects to the core file,
      which can be found by examining ldinfo, and anonymously mmapped
      regions.  */
   sec->vma = 0;
   sec->filepos = core.c_loader;
 
   /* AIX 4 adds data sections from loaded objects to the core file,
      which can be found by examining ldinfo, and anonymously mmapped
      regions.  */

-  
+

   /* .data section from executable.  */
   /* .data section from executable.  */

-  sec = bfd_make_section_anyway (abfd, ".data");
-  if (NULL == sec) 
+  flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
+  sec = bfd_make_section_anyway_with_flags (abfd, ".data", flags);
+  if (NULL == sec)

     return return_value;
 
     return return_value;
 

-  sec->flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
-  sec->_raw_size = core.c_datasize;
+  sec->size = core.c_datasize;

   sec->vma = core.c_dataorg;
   sec->filepos = core.c_data;
 
   /* .data sections from loaded objects.  */
   ld_offset = core.c_loader;
   sec->vma = core.c_dataorg;
   sec->filepos = core.c_data;
 
   /* .data sections from loaded objects.  */
   ld_offset = core.c_loader;

-       
-  while (1) 
+
+  while (1)

     {
     {

-      if (bfd_seek (abfd, ld_offset, SEEK_SET) != 0) 
+      if (bfd_seek (abfd, ld_offset, SEEK_SET) != 0)

        return return_value;
 
       if (sizeof (struct __ld_info64) !=
        return return_value;
 
       if (sizeof (struct __ld_info64) !=

-         bfd_bread (&ldinfo, sizeof (struct __ld_info64), abfd)) 
+         bfd_bread (&ldinfo, sizeof (struct __ld_info64), abfd))

        return return_value;
 
        return return_value;
 

-      if (ldinfo.ldinfo_core) 
+      if (ldinfo.ldinfo_core)

        {
        {

-         sec = bfd_make_section_anyway (abfd, ".data");
-         if (NULL == sec) 
+         flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
+         sec = bfd_make_section_anyway_with_flags (abfd, ".data", flags);
+         if (NULL == sec)

            return return_value;
 
            return return_value;
 

-         sec->flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
-         sec->_raw_size = ldinfo.ldinfo_datasize;
+         sec->size = ldinfo.ldinfo_datasize;

          sec->vma = ldinfo.ldinfo_dataorg;
          sec->filepos = ldinfo.ldinfo_core;
        }
          sec->vma = ldinfo.ldinfo_dataorg;
          sec->filepos = ldinfo.ldinfo_core;
        }


@@ -193,65 +200,68 @@ xcoff64_core_p (abfd)
     }
 
   /* .vmdata sections from anonymously mmapped regions.  */
     }
 
   /* .vmdata sections from anonymously mmapped regions.  */

-  if (core.c_vmregions) 
+  if (core.c_vmregions)

     {
     {

-      if (bfd_seek (abfd, core.c_vmm, SEEK_SET) != 0) 
+      if (bfd_seek (abfd, core.c_vmm, SEEK_SET) != 0)

        return return_value;
 
        return return_value;
 

-      for (i = 0; i < core.c_vmregions; i++) 
+      for (i = 0; i < core.c_vmregions; i++)

        if (sizeof (struct vm_infox) !=
        if (sizeof (struct vm_infox) !=

-           bfd_bread (&vminfo, sizeof (struct vm_infox), abfd)) 
+           bfd_bread (&vminfo, sizeof (struct vm_infox), abfd))

          return return_value;
 
          return return_value;
 

-      if (vminfo.vminfo_offset) 
+      if (vminfo.vminfo_offset)

        {
        {

-         sec = bfd_make_section_anyway (abfd, ".vmdata");
-         if (NULL == sec) 
+         flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
+         sec = bfd_make_section_anyway_with_flags (abfd, ".vmdata", flags);
+         if (NULL == sec)

            return return_value;
 
            return return_value;
 

-         sec->flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
-         sec->_raw_size = vminfo.vminfo_size;
+         sec->size = vminfo.vminfo_size;

          sec->vma = vminfo.vminfo_addr;
          sec->filepos = vminfo.vminfo_offset;
        }
     }
 
          sec->vma = vminfo.vminfo_addr;
          sec->filepos = vminfo.vminfo_offset;
        }
     }
 

-  return_value = abfd->xvec;   /* This is garbage for now.  */
-       
+  /* Set the architecture and machine.  */
+  arch = DEFAULT_ARCHITECTURE;
+  mach = DEFAULT_MACHINE;
+  bfd_default_set_arch_mach (abfd, arch, mach);
+
+  return_value = (bfd_target *) abfd->xvec;    /* This is garbage for now.  */
+

  xcoff64_core_p_error:
  xcoff64_core_p_error:

-  if (bfd_get_error () != bfd_error_system_call) 
+  if (bfd_get_error () != bfd_error_system_call)

     bfd_set_error (bfd_error_wrong_format);
     bfd_set_error (bfd_error_wrong_format);

-  
+

   return return_value;
 }
 
   return return_value;
 }
 

-/* Return `true' if given core is from the given executable.  */
+/* Return `TRUE' if given core is from the given executable.  */

 
 

-boolean
-xcoff64_core_file_matches_executable_p (core_bfd, exec_bfd)
-     bfd *core_bfd;
-     bfd *exec_bfd;
+bfd_boolean
+xcoff64_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)

 {
   struct core_dumpxx core;
   char *path, *s;
   size_t alloc;
   const char *str1, *str2;
 {
   struct core_dumpxx core;
   char *path, *s;
   size_t alloc;
   const char *str1, *str2;

-  boolean return_value = false;
+  bfd_boolean return_value = FALSE;

 
   /* Get the header.  */
 
   /* Get the header.  */

-  if (bfd_seek (core_bfd, 0, SEEK_SET) != 0) 
+  if (bfd_seek (core_bfd, 0, SEEK_SET) != 0)

     return return_value;
     return return_value;

-       
+

   if (sizeof (struct core_dumpxx) !=
   if (sizeof (struct core_dumpxx) !=

-      bfd_bread (&core, sizeof (struct core_dumpxx), core_bfd)) 
+      bfd_bread (&core, sizeof (struct core_dumpxx), core_bfd))

     return return_value;
 
     return return_value;
 

-  if (bfd_seek (core_bfd, core.c_loader, SEEK_SET) != 0) 
+  if (bfd_seek (core_bfd, core.c_loader, SEEK_SET) != 0)

     return return_value;
 
   alloc = 100;
   path = bfd_malloc (alloc);
     return return_value;
 
   alloc = 100;
   path = bfd_malloc (alloc);

-  if (path == NULL) 
+  if (path == NULL)

     return return_value;
 
   s = path;
     return return_value;
 
   s = path;


@@ -264,13 +274,13 @@ xcoff64_core_file_matches_executable_p (core_bfd, exec_bfd)
       if (*s == '\0')
        break;
       ++s;
       if (*s == '\0')
        break;
       ++s;

-      if (s == path + alloc) 
+      if (s == path + alloc)

        {
          char *n;
 
          alloc *= 2;
          n = bfd_realloc (path, alloc);
        {
          char *n;
 
          alloc *= 2;
          n = bfd_realloc (path, alloc);

-         if (n == NULL) 
+         if (n == NULL)

            goto xcoff64_core_file_matches_executable_p_end_1;
 
          s = n + (path - s);
            goto xcoff64_core_file_matches_executable_p_end_1;
 
          s = n + (path - s);


@@ -285,8 +295,8 @@ xcoff64_core_file_matches_executable_p (core_bfd, exec_bfd)
   str1 = str1 != NULL ? str1 + 1 : path;
   str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
 
   str1 = str1 != NULL ? str1 + 1 : path;
   str2 = str2 != NULL ? str2 + 1 : exec_bfd->filename;
 

-  if (strcmp (str1, str2) == 0) 
-    return_value = true;
+  if (strcmp (str1, str2) == 0)
+    return_value = TRUE;

 
  xcoff64_core_file_matches_executable_p_end_1:
   free (path);
 
  xcoff64_core_file_matches_executable_p_end_1:
   free (path);


@@ -294,26 +304,24 @@ xcoff64_core_file_matches_executable_p (core_bfd, exec_bfd)
 }
 
 char *
 }
 
 char *

-xcoff64_core_file_failing_command (abfd)
-     bfd *abfd;
+xcoff64_core_file_failing_command (bfd *abfd)

 {
   struct core_dumpxx *c = core_hdr (abfd);
   char *return_value = 0;
 
 {
   struct core_dumpxx *c = core_hdr (abfd);
   char *return_value = 0;
 

-  if (NULL != c) 
+  if (NULL != c)

     return_value = c->c_u.U_proc.pi_comm;
 
   return return_value;
 }
 
 int
     return_value = c->c_u.U_proc.pi_comm;
 
   return return_value;
 }
 
 int

-xcoff64_core_file_failing_signal (abfd)
-     bfd *abfd;
+xcoff64_core_file_failing_signal (bfd *abfd)

 {
   struct core_dumpxx *c = core_hdr (abfd);
   int return_value = 0;
 
 {
   struct core_dumpxx *c = core_hdr (abfd);
   int return_value = 0;
 

-  if (NULL != c) 
+  if (NULL != c)

     return_value = c->c_signo;
 
   return return_value;
     return_value = c->c_signo;
 
   return return_value;


@@ -321,37 +329,27 @@ xcoff64_core_file_failing_signal (abfd)
 
 #else /* AIX_5_CORE */
 
 
 #else /* AIX_5_CORE */
 

-const bfd_target * xcoff64_core_p PARAMS ((bfd *));
-boolean            xcoff64_core_file_matches_executable_p PARAMS ((bfd *, bfd *));
-char *             xcoff64_core_file_failing_command PARAMS ((bfd *));
-int                xcoff64_core_file_failing_signal PARAMS ((bfd *));
-

 const bfd_target *
 const bfd_target *

-xcoff64_core_p (abfd)
-     bfd *abfd ATTRIBUTE_UNUSED;
+xcoff64_core_p (bfd *abfd ATTRIBUTE_UNUSED)

 {
   bfd_set_error (bfd_error_wrong_format);
   return 0;
 }
 
 {
   bfd_set_error (bfd_error_wrong_format);
   return 0;
 }
 

-boolean
-xcoff64_core_file_matches_executable_p (core_bfd, exec_bfd)
-     bfd *core_bfd ATTRIBUTE_UNUSED;
-     bfd *exec_bfd ATTRIBUTE_UNUSED;
+bfd_boolean
+xcoff64_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)

 {
 {

-  return false;
+  return generic_core_file_matches_executable_p (core_bfd, exec_bfd);

 }
 
 char *
 }
 
 char *

-xcoff64_core_file_failing_command (abfd)
-     bfd *abfd ATTRIBUTE_UNUSED;
+xcoff64_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)

 {
   return 0;
 }
 
 int
 {
   return 0;
 }
 
 int

-xcoff64_core_file_failing_signal (abfd)
-     bfd *abfd ATTRIBUTE_UNUSED;
+xcoff64_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)

 {
   return 0;
 }
 {
   return 0;
 }