[ ChangeLog ]
[deliverable/binutils-gdb.git] / include / aout / aout64.h
index 8cbf30b8934901a151e8698d2c792f10edc0ba26..bc96d2a776734e4dc51a4beee767729467351567 100644 (file)
@@ -1,4 +1,20 @@
-/* `a.out' object-file definitions, including extensions to 64-bit fields */
+/* `a.out' object-file definitions, including extensions to 64-bit fields
+
+   Copyright 2001 Free Software Foundation, Inc.
+
+   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 __A_OUT_64_H__
 #define __A_OUT_64_H__
@@ -40,7 +56,9 @@ struct external_exec
 
 /* This indicates a demand-paged executable with the header in the text.
    It is used by 386BSD (and variants) and Linux, at least.  */
+#ifndef QMAGIC
 #define QMAGIC 0314
+#endif
 # ifndef N_BADMAG
 #  define N_BADMAG(x)    (N_MAGIC(x) != OMAGIC         \
                        && N_MAGIC(x) != NMAGIC         \
@@ -57,13 +75,13 @@ struct external_exec
 #define N_IS_QMAGIC(x) (0)
 #endif
 
-/* The difference between PAGE_SIZE and N_SEGSIZE is that PAGE_SIZE is
+/* The difference between TARGET_PAGE_SIZE and N_SEGSIZE is that TARGET_PAGE_SIZE is
    the finest granularity at which you can page something, thus it
    controls the padding (if any) before the text segment of a ZMAGIC
    file.  N_SEGSIZE is the resolution at which things can be marked as
    read-only versus read/write, so it controls the padding between the
    text segment and the data segment (in memory; on disk the padding
-   between them is PAGE_SIZE).  PAGE_SIZE and N_SEGSIZE are the same
+   between them is TARGET_PAGE_SIZE).  TARGET_PAGE_SIZE and N_SEGSIZE are the same
    for most machines, but different for sun3.  */
 
 /* By default, segment size is constant.  But some machines override this
@@ -95,7 +113,7 @@ struct external_exec
      * If N_HEADER_IN_TEXT(x) is false (which defaults to being the case when
        the entry point is less than EXEC_BYTES_SIZE into a page (e.g. page
        aligned)): (padding is needed so that text can start at a page boundary)
-       start at TEXT_START_ADDR, offset PAGE_SIZE, size as stated.
+       start at TEXT_START_ADDR, offset TARGET_PAGE_SIZE, size as stated.
 
     Specific configurations may want to hardwire N_HEADER_IN_TEXT,
     for efficiency or to allow people to play games with the entry point.
@@ -106,21 +124,26 @@ struct external_exec
     the entry point, perhaps with the ld -e flag.)
 
     * QMAGIC is always like a ZMAGIC for which N_HEADER_IN_TEXT is true,
-    and for which the starting address is PAGE_SIZE (or should this be
+    and for which the starting address is TARGET_PAGE_SIZE (or should this be
     SEGMENT_SIZE?) (TEXT_START_ADDR only applies to ZMAGIC, not to QMAGIC).
     */
 
 /* This macro is only relevant for ZMAGIC files; QMAGIC always has the header
    in the text.  */
 #ifndef N_HEADER_IN_TEXT
-#define N_HEADER_IN_TEXT(x) (((x).a_entry & (PAGE_SIZE-1)) >= EXEC_BYTES_SIZE)
+#define N_HEADER_IN_TEXT(x) \
+  (((x).a_entry & (TARGET_PAGE_SIZE-1)) >= EXEC_BYTES_SIZE)
 #endif
 
 /* Sun shared libraries, not linux.  This macro is only relevant for ZMAGIC
    files.  */
 #ifndef N_SHARED_LIB
+#if defined (TEXT_START_ADDR) && TEXT_START_ADDR == 0
+#define N_SHARED_LIB(x) (0)
+#else
 #define N_SHARED_LIB(x) ((x).a_entry < TEXT_START_ADDR)
 #endif
+#endif
 
 /* Returning 0 not TEXT_START_ADDR for OMAGIC and NMAGIC is based on
    the assumption that we are dealing with a .o file, not an
@@ -129,40 +152,43 @@ struct external_exec
 
 #ifndef N_TXTADDR
 #define N_TXTADDR(x) \
-    (/* The address of a QMAGIC file is always one page in, */ \
-     /* with the header in the text.  */ \
-     N_IS_QMAGIC (x) ? PAGE_SIZE + EXEC_BYTES_SIZE : \
-     N_MAGIC(x) != ZMAGIC ? 0 :        /* object file or NMAGIC */\
-     N_SHARED_LIB(x) ? 0 :     \
-     N_HEADER_IN_TEXT(x)  ?    \
-           TEXT_START_ADDR + EXEC_BYTES_SIZE : /* no padding */\
-           TEXT_START_ADDR                     /* a page of padding */\
-    )
+    (/* The address of a QMAGIC file is always one page in, */         \
+     /* with the header in the text.  */                               \
+     N_IS_QMAGIC (x)                                                   \
+     ? (bfd_vma) TARGET_PAGE_SIZE + EXEC_BYTES_SIZE                    \
+     : (N_MAGIC (x) != ZMAGIC                                          \
+       ? (bfd_vma) 0   /* object file or NMAGIC */                     \
+       : (N_SHARED_LIB (x)                                             \
+          ? (bfd_vma) 0                                                \
+          : (N_HEADER_IN_TEXT (x)                                      \
+             ? (bfd_vma) TEXT_START_ADDR + EXEC_BYTES_SIZE             \
+             : (bfd_vma) TEXT_START_ADDR))))
 #endif
 
 /* If N_HEADER_IN_TEXT is not true for ZMAGIC, there is some padding
    to make the text segment start at a certain boundary.  For most
-   systems, this boundary is PAGE_SIZE.  But for Linux, in the
+   systems, this boundary is TARGET_PAGE_SIZE.  But for Linux, in the
    time-honored tradition of crazy ZMAGIC hacks, it is 1024 which is
-   not what PAGE_SIZE needs to be for QMAGIC.  */
+   not what TARGET_PAGE_SIZE needs to be for QMAGIC.  */
 
 #ifndef ZMAGIC_DISK_BLOCK_SIZE
-#define ZMAGIC_DISK_BLOCK_SIZE PAGE_SIZE
+#define ZMAGIC_DISK_BLOCK_SIZE TARGET_PAGE_SIZE
 #endif
 
 #define N_DISK_BLOCK_SIZE(x) \
-  (N_MAGIC(x) == ZMAGIC ? ZMAGIC_DISK_BLOCK_SIZE : PAGE_SIZE)
+  (N_MAGIC(x) == ZMAGIC ? ZMAGIC_DISK_BLOCK_SIZE : TARGET_PAGE_SIZE)
 
 /* Offset in an a.out of the start of the text section. */
 #ifndef N_TXTOFF
-#define N_TXTOFF(x)    \
-    (/* For {O,N,Q}MAGIC, no padding.  */ \
-     N_MAGIC(x) != ZMAGIC ? EXEC_BYTES_SIZE : \
-     N_SHARED_LIB(x) ? 0 : \
-     N_HEADER_IN_TEXT(x) ?     \
-           EXEC_BYTES_SIZE :                   /* no padding */\
-           ZMAGIC_DISK_BLOCK_SIZE              /* a page of padding */\
-    )
+#define N_TXTOFF(x)                                                    \
+    (/* For {O,N,Q}MAGIC, no padding.  */                              \
+     N_MAGIC (x) != ZMAGIC                                             \
+     ? EXEC_BYTES_SIZE                                                 \
+     : (N_SHARED_LIB (x)                                               \
+       ? 0                                                             \
+       : (N_HEADER_IN_TEXT (x)                                         \
+          ? EXEC_BYTES_SIZE            /* no padding */                \
+          : ZMAGIC_DISK_BLOCK_SIZE     /* a page of padding */)))
 #endif
 /* Size of the text section.  It's always as stated, except that we
    offset it to `undo' the adjustment to N_TXTADDR and N_TXTOFF
@@ -171,25 +197,28 @@ struct external_exec
    exec header to be part of the text segment.)  */
 #ifndef N_TXTSIZE
 #define        N_TXTSIZE(x) \
-    (/* For QMAGIC, we don't consider the header part of the text section.  */\
-     N_IS_QMAGIC (x) ? (x).a_text - EXEC_BYTES_SIZE : \
-     (N_MAGIC(x) != ZMAGIC || N_SHARED_LIB(x)) ? (x).a_text : \
-     N_HEADER_IN_TEXT(x)  ?    \
-           (x).a_text - EXEC_BYTES_SIZE:       /* no padding */\
-           (x).a_text                          /* a page of padding */\
-    )
+  (/* For QMAGIC, we don't consider the header part of the text section.  */\
+   N_IS_QMAGIC (x)                                                     \
+   ? (x).a_text - EXEC_BYTES_SIZE                                      \
+   : ((N_MAGIC (x) != ZMAGIC || N_SHARED_LIB (x))                      \
+      ? (x).a_text                                                     \
+      : (N_HEADER_IN_TEXT (x)                                          \
+        ? (x).a_text - EXEC_BYTES_SIZE /* no padding */                \
+        : (x).a_text                   /* a page of padding */ )))
 #endif
 /* The address of the data segment in virtual memory.
    It is the text segment address, plus text segment size, rounded
    up to a N_SEGSIZE boundary for pure or pageable files. */
 #ifndef N_DATADDR
 #define N_DATADDR(x) \
-    (N_MAGIC(x)==OMAGIC? (N_TXTADDR(x)+N_TXTSIZE(x)) \
-     :  (N_SEGSIZE(x) + ((N_TXTADDR(x)+N_TXTSIZE(x)-1) & ~(N_SEGSIZE(x)-1))))
+  (N_MAGIC (x) == OMAGIC                                               \
+   ? (N_TXTADDR (x) + N_TXTSIZE (x))                                   \
+   : (N_SEGSIZE (x) + ((N_TXTADDR (x) + N_TXTSIZE (x) - 1)             \
+                      & ~ (bfd_vma) (N_SEGSIZE (x) - 1))))
 #endif
 /* The address of the BSS segment -- immediately after the data segment.  */
 
-#define N_BSSADDR(x)   (N_DATADDR(x) + (x).a_data)
+#define N_BSSADDR(x)   (N_DATADDR (x) + (x).a_data)
 
 /* Offsets of the various portions of the file after the text segment.  */
 
@@ -206,21 +235,19 @@ struct external_exec
    for NMAGIC.  */
 
 #ifndef N_DATOFF
-#define N_DATOFF(x) \
- (N_TXTOFF(x) + N_TXTSIZE(x))
+#define N_DATOFF(x)    ( N_TXTOFF (x) + N_TXTSIZE (x) )
 #endif
-
 #ifndef N_TRELOFF
-#define N_TRELOFF(x)   ( N_DATOFF(x) + (x).a_data )
+#define N_TRELOFF(x)   ( N_DATOFF (x) + (x).a_data )
 #endif
 #ifndef N_DRELOFF
-#define N_DRELOFF(x)   ( N_TRELOFF(x) + (x).a_trsize )
+#define N_DRELOFF(x)   ( N_TRELOFF (x) + (x).a_trsize )
 #endif
 #ifndef N_SYMOFF
-#define N_SYMOFF(x)    ( N_DRELOFF(x) + (x).a_drsize )
+#define N_SYMOFF(x)    ( N_DRELOFF (x) + (x).a_drsize )
 #endif
 #ifndef N_STROFF
-#define N_STROFF(x)    ( N_SYMOFF(x) + (x).a_syms )
+#define N_STROFF(x)    ( N_SYMOFF (x) + (x).a_syms )
 #endif
 \f
 /* Symbols */
@@ -382,13 +409,29 @@ struct reloc_ext_external {
   bfd_byte r_addend[BYTES_IN_WORD];    /* datum addend                         */
 };
 
+#ifndef RELOC_EXT_BITS_EXTERN_BIG
 #define        RELOC_EXT_BITS_EXTERN_BIG       ((unsigned int) 0x80)
+#endif
+
+#ifndef RELOC_EXT_BITS_EXTERN_LITTLE
 #define        RELOC_EXT_BITS_EXTERN_LITTLE    ((unsigned int) 0x01)
+#endif
 
+#ifndef RELOC_EXT_BITS_TYPE_BIG
 #define        RELOC_EXT_BITS_TYPE_BIG         ((unsigned int) 0x1F)
+#endif
+
+#ifndef RELOC_EXT_BITS_TYPE_SH_BIG
 #define        RELOC_EXT_BITS_TYPE_SH_BIG      0
+#endif
+
+#ifndef RELOC_EXT_BITS_TYPE_LITTLE
 #define        RELOC_EXT_BITS_TYPE_LITTLE      ((unsigned int) 0xF8)
+#endif
+
+#ifndef RELOC_EXT_BITS_TYPE_SH_LITTLE
 #define        RELOC_EXT_BITS_TYPE_SH_LITTLE   3
+#endif
 
 /* Bytes per relocation entry */
 #define        RELOC_EXT_SIZE  (BYTES_IN_WORD + 3 + 1 + BYTES_IN_WORD)
@@ -438,13 +481,13 @@ enum reloc_type
   RELOC_CONST,
   RELOC_CONSTH,
   
-  /* All the new ones I can think of *//*v9*/
+  /* All the new ones I can think of, for sparc v9 */
 
-  RELOC_64,                    /* data[0:63] = addend + sv             *//*v9*/
-  RELOC_DISP64,                        /* data[0:63] = addend - pc + sv        *//*v9*/
-  RELOC_WDISP21,               /* data[0:20] = (addend + sv - pc)>>2   *//*v9*/
-  RELOC_DISP21,                        /* data[0:20] = addend - pc + sv        *//*v9*/
-  RELOC_DISP14,                        /* data[0:13] = addend - pc + sv        *//*v9*/
+  RELOC_64,                    /* data[0:63] = addend + sv             */
+  RELOC_DISP64,                        /* data[0:63] = addend - pc + sv        */
+  RELOC_WDISP21,               /* data[0:20] = (addend + sv - pc)>>2   */
+  RELOC_DISP21,                        /* data[0:20] = addend - pc + sv        */
+  RELOC_DISP14,                        /* data[0:13] = addend - pc + sv        */
   /* Q .
      What are the other ones,
      Since this is a clean slate, can we throw away the ones we dont
This page took 0.025992 seconds and 4 git commands to generate.