Initial revision
This commit is contained in:
John Gilmore
parent
a6ac0c5998
commit
a07cc61341
|
|
@ -0,0 +1,19 @@
|
|||
/* SPARC-specific values for a.out files */
|
||||
|
||||
#define PAGE_SIZE 0x02000 /* 8K. aka NBPG in <sys/param.h> */
|
||||
/* Note that some SPARCs have 4K pages, some 8K, some others. */
|
||||
#define SEGMENT_SIZE PAGE_SIZE
|
||||
#define TEXT_START_ADDR PAGE_SIZE /* Location 0 is not accessible */
|
||||
|
||||
#define N_BADMAG(x) \
|
||||
(N_MAGIC(x) != OMAGIC && N_MAGIC(x) != NMAGIC \
|
||||
&& N_MAGIC(x) != ZMAGIC)
|
||||
|
||||
|
||||
#define N_TXTOFF(x) ( (N_MAGIC((x)) == ZMAGIC) ? 0 : sizeof(struct exec) )
|
||||
#define N_DATOFF(x) ( N_TXTOFF(x) + (x).a_text )
|
||||
#define N_TRELOFF(x) ( N_DATOFF(x) + (x).a_data )
|
||||
#define N_DRELOFF(x) ( N_TRELOFF(x) + (x).a_trsize )
|
||||
#define N_SYMOFF(x) ( N_DRELOFF(x) + (x).a_drsize )
|
||||
#define N_STROFF(x) ( N_SYMOFF(x) + (x).a_syms )
|
||||
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
/* VAX-specific definitions for a.out file header fields. */
|
||||
|
||||
#define PAGE_SIZE 512 /* aka NBPG in <sys/param.h> */
|
||||
#define SEGMENT_SIZE PAGE_SIZE /* rounding between text/data ??! */
|
||||
#define TEXT_START_ADDR 0 /* Text start address: see
|
||||
<machine/vmparam.h> USRTEXT. */
|
||||
#define STACK_END_ADDR 0x80000000-(14+14)*PAGE_SIZE /* see
|
||||
<machine/vmparam.h> USRSTACK. */
|
||||
|
||||
#define N_BADMAG(x) \
|
||||
(N_MAGIC(x) != OMAGIC && N_MAGIC(x) != NMAGIC \
|
||||
&& N_MAGIC(x) != ZMAGIC)
|
||||
|
||||
|
||||
#define N_TXTOFF(x) ( (N_MAGIC((x)) == ZMAGIC) ? 1024 : EXEC_BYTES_SIZE )
|
||||
#define N_DATOFF(x) ( N_TXTOFF(x) + (x).a_text )
|
||||
#define N_TRELOFF(x) ( N_DATOFF(x) + (x).a_data )
|
||||
#define N_DRELOFF(x) ( N_TRELOFF(x) + (x).a_trsize )
|
||||
#define N_SYMOFF(x) ( N_DRELOFF(x) + (x).a_drsize )
|
||||
#define N_STROFF(x) ( N_SYMOFF(x) + (x).a_syms )
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
/* archive file definition for GNU software */
|
||||
|
||||
/* So far this is correct for BSDish archives. Don't forget that
|
||||
files must begin on an even byte boundary. */
|
||||
|
||||
#ifndef __GNU_AR_H__
|
||||
#define __GNU_AR_H__
|
||||
|
||||
#define ARMAG "!<arch>\n" /* For COFF and a.out archives */
|
||||
#define ARMAGB "!<bout>\n" /* For b.out archives */
|
||||
#define SARMAG 8
|
||||
#define ARFMAG "`\n"
|
||||
|
||||
struct ar_hdr {
|
||||
char ar_name[16]; /* name of this member */
|
||||
char ar_date[12]; /* file mtime */
|
||||
char ar_uid[6]; /* owner uid; printed as decimal */
|
||||
char ar_gid[6]; /* owner gid; printed as decimal */
|
||||
char ar_mode[8]; /* file mode, printed as octal */
|
||||
char ar_size[10]; /* file size, printed as decimal */
|
||||
char ar_fmag[2]; /* should contain ARFMAG */
|
||||
};
|
||||
|
||||
#endif /* __GNU_AR_H__ */
|
||||
|
|
@ -0,0 +1,296 @@
|
|||
/*** coff information for 88k bcs */
|
||||
|
||||
/********************** FILE HEADER **********************/
|
||||
|
||||
struct filehdr {
|
||||
unsigned short f_magic; /* magic number */
|
||||
unsigned short f_nscns; /* number of sections */
|
||||
long f_timdat; /* time & date stamp */
|
||||
long f_symptr; /* file pointer to symtab */
|
||||
long f_nsyms; /* number of symtab entries */
|
||||
unsigned short f_opthdr; /* sizeof(optional hdr) */
|
||||
unsigned short f_flags; /* flags */
|
||||
};
|
||||
|
||||
/* Bits for f_flags:
|
||||
* F_RELFLG relocation info stripped from file
|
||||
* F_EXEC file is executable (no unresolved externel references)
|
||||
* F_LNNO line nunbers stripped from file
|
||||
* F_LSYMS local symbols stripped from file
|
||||
* F_AR32WR file has byte ordering of an AR32WR machine (e.g. vax)
|
||||
*/
|
||||
#define F_RELFLG 0000001
|
||||
#define F_EXEC 0000002
|
||||
#define F_LNNO 0000004
|
||||
#define F_LSYMS 0000010
|
||||
#define F_AR32WR 0000400
|
||||
|
||||
|
||||
#define MC88MAGIC 0555 /* 88k BCS executable */
|
||||
#define MC88DMAGIC 0541 /* DG/UX executable */
|
||||
|
||||
|
||||
#define MC88BADMAG(x) (((x).f_magic!=MC88MAGIC) && ((x).f_magic!=MC88DMAGIC))
|
||||
|
||||
#define FILHDR struct filehdr
|
||||
#define FILHSZ sizeof(FILHDR)
|
||||
|
||||
|
||||
/********************** AOUT "OPTIONAL HEADER" **********************/
|
||||
|
||||
|
||||
#define PAGEMAGIC3 0414 /* Split i&d, zero mapped */
|
||||
typedef struct aouthdr {
|
||||
short magic; /* type of file */
|
||||
short vstamp; /* version stamp */
|
||||
unsigned long tsize; /* text size in bytes, padded to FW bdry*/
|
||||
unsigned long dsize; /* initialized data " " */
|
||||
unsigned long bsize; /* uninitialized data " " */
|
||||
|
||||
unsigned long entry; /* entry pt. */
|
||||
unsigned long text_start; /* base of text used for this file */
|
||||
unsigned long data_start; /* base of data used for this file */
|
||||
|
||||
} AOUTHDR;
|
||||
|
||||
|
||||
/* compute size of a header */
|
||||
|
||||
#define AOUTSZ (sizeof(AOUTHDR))
|
||||
|
||||
/********************** STORAGE CLASSES **********************/
|
||||
|
||||
#define C_EFCN -1 /* physical end of function */
|
||||
#define C_NULL 0
|
||||
#define C_AUTO 1 /* automatic variable */
|
||||
#define C_EXT 2 /* external symbol */
|
||||
#define C_STAT 3 /* static */
|
||||
#define C_REG 4 /* register variable */
|
||||
#define C_EXTDEF 5 /* external definition */
|
||||
#define C_LABEL 6 /* label */
|
||||
#define C_ULABEL 7 /* undefined label */
|
||||
#define C_MOS 8 /* member of structure */
|
||||
#define C_ARG 9 /* function argument */
|
||||
#define C_STRTAG 10 /* structure tag */
|
||||
#define C_MOU 11 /* member of union */
|
||||
#define C_UNTAG 12 /* union tag */
|
||||
#define C_TPDEF 13 /* type definition */
|
||||
#define C_USTATIC 14 /* undefined static */
|
||||
#define C_ENTAG 15 /* enumeration tag */
|
||||
#define C_MOE 16 /* member of enumeration */
|
||||
#define C_REGPARM 17 /* register parameter */
|
||||
#define C_FIELD 18 /* bit field */
|
||||
#define C_BLOCK 100 /* ".bb" or ".eb" */
|
||||
#define C_FCN 101 /* ".bf" or ".ef" */
|
||||
#define C_EOS 102 /* end of structure */
|
||||
#define C_FILE 103 /* file name */
|
||||
#define C_LINE 104 /* line # reformatted as symbol table entry */
|
||||
#define C_ALIAS 105 /* duplicate tag */
|
||||
#define C_HIDDEN 106 /* ext symbol in dmert public lib */
|
||||
#define C_SHADOW 107 /* shadow symbol */
|
||||
#define C_VERSION 108 /* coff version symbol */
|
||||
|
||||
|
||||
/********************** SECTION HEADER **********************/
|
||||
|
||||
struct scnhdr {
|
||||
char s_name[8]; /* section name */
|
||||
long s_paddr; /* physical address, aliased s_nlib */
|
||||
long s_vaddr; /* virtual address */
|
||||
long s_size; /* section size */
|
||||
long s_scnptr; /* file ptr to raw data for section */
|
||||
long s_relptr; /* file ptr to relocation */
|
||||
long s_lnnoptr; /* file ptr to line numbers */
|
||||
long s_nreloc; /* number of relocation entries */
|
||||
long s_nlnno; /* number of line number entries*/
|
||||
long s_flags; /* flags */
|
||||
};
|
||||
|
||||
/*
|
||||
* names of "special" sections
|
||||
*/
|
||||
#define _TEXT ".text"
|
||||
#define _DATA ".data"
|
||||
#define _BSS ".bss"
|
||||
|
||||
/*
|
||||
* s_flags "type"
|
||||
*/
|
||||
#define STYP_TEXT 0x20 /* section contains text only */
|
||||
#define STYP_DATA 0x40 /* section contains data only */
|
||||
#define STYP_BSS 0x80 /* section contains bss only */
|
||||
|
||||
#define SCNHDR struct scnhdr
|
||||
#define SCNHSZ sizeof(SCNHDR)
|
||||
|
||||
|
||||
/********************** LINE NUMBERS **********************/
|
||||
|
||||
/* 1 line number entry for every "breakpointable" source line in a section.
|
||||
* Line numbers are grouped on a per function basis; first entry in a function
|
||||
* grouping will have l_lnno = 0 and in place of physical address will be the
|
||||
* symbol table index of the function name.
|
||||
*/
|
||||
struct lineno{
|
||||
union {
|
||||
long l_symndx; /* function name symbol index, iff l_lnno == 0*/
|
||||
long l_paddr; /* (physical) address of line number */
|
||||
} l_addr;
|
||||
|
||||
long l_lnno;
|
||||
|
||||
};
|
||||
|
||||
#define LINENO struct lineno
|
||||
#define LINESZ sizeof(LINENO)
|
||||
|
||||
|
||||
/********************** SYMBOLS **********************/
|
||||
|
||||
#define SYMNMLEN 8 /* # characters in a symbol name */
|
||||
#define FILNMLEN 14 /* # characters in a file name */
|
||||
#define DIMNUM 4 /* # array dimensions in auxiliary entry */
|
||||
|
||||
|
||||
struct syment {
|
||||
union {
|
||||
char _n_name[SYMNMLEN]; /* old COFF version */
|
||||
struct {
|
||||
long _n_zeroes; /* new == 0 */
|
||||
long _n_offset; /* offset into string table */
|
||||
} _n_n;
|
||||
char *_n_nptr[2]; /* allows for overlaying */
|
||||
} _n;
|
||||
long n_value; /* value of symbol */
|
||||
short n_scnum; /* section number */
|
||||
unsigned short n_type; /* type and derived type */
|
||||
char n_sclass; /* storage class */
|
||||
char n_numaux; /* number of aux. entries */
|
||||
char pad2[2]; /* force alignment */
|
||||
};
|
||||
|
||||
#define n_name _n._n_name
|
||||
#define n_zeroes _n._n_n._n_zeroes
|
||||
#define n_offset _n._n_n._n_offset
|
||||
|
||||
/*
|
||||
* Relocatable symbols have number of the section in which they are defined,
|
||||
* or one of the following:
|
||||
*/
|
||||
#define N_UNDEF 0 /* undefined symbol */
|
||||
#define N_ABS -1 /* value of symbol is absolute */
|
||||
#define N_DEBUG -2 /* debugging symbol -- symbol value is meaningless */
|
||||
|
||||
/*
|
||||
* Type of a symbol, in low 4 bits of the word
|
||||
*/
|
||||
#define T_NULL 0
|
||||
#define T_VOID 1 /* function argument (only used by compiler) */
|
||||
#define T_CHAR 2 /* character */
|
||||
#define T_SHORT 3 /* short integer */
|
||||
#define T_INT 4 /* integer */
|
||||
#define T_LONG 5 /* long integer */
|
||||
#define T_FLOAT 6 /* floating point */
|
||||
#define T_DOUBLE 7 /* double word */
|
||||
#define T_STRUCT 8 /* structure */
|
||||
#define T_UNION 9 /* union */
|
||||
#define T_ENUM 10 /* enumeration */
|
||||
#define T_MOE 11 /* member of enumeration*/
|
||||
#define T_UCHAR 12 /* unsigned character */
|
||||
#define T_USHORT 13 /* unsigned short */
|
||||
#define T_UINT 14 /* unsigned integer */
|
||||
#define T_ULONG 15 /* unsigned long */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* derived types
|
||||
*/
|
||||
#define DT_NON 0
|
||||
#define DT_PTR 1 /* pointer */
|
||||
#define DT_FCN 2 /* function */
|
||||
#define DT_ARY 3 /* array */
|
||||
|
||||
#define N_BTMASK 017
|
||||
#define N_TMASK 060
|
||||
#define N_BTSHFT 4
|
||||
#define N_TSHIFT 2
|
||||
|
||||
#define BTYPE(x) ((x) & N_BTMASK)
|
||||
|
||||
|
||||
#define ISPTR(x) (((x) & N_TMASK) == (DT_PTR << N_BTSHFT))
|
||||
#define ISFCN(x) (((x) & N_TMASK) == (DT_FCN << N_BTSHFT))
|
||||
#define ISARY(x) (((x) & N_TMASK) == (DT_ARY << N_BTSHFT))
|
||||
|
||||
#define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
|
||||
|
||||
union auxent {
|
||||
struct {
|
||||
long x_tagndx; /* str, un, or enum tag indx */
|
||||
union {
|
||||
struct {
|
||||
unsigned long x_lnno; /* declaration line number */
|
||||
unsigned long x_size; /* str/union/array size */
|
||||
} x_lnsz;
|
||||
long x_fsize; /* size of function */
|
||||
} x_misc;
|
||||
union {
|
||||
struct { /* if ISFCN, tag, or .bb */
|
||||
long x_lnnoptr; /* ptr to fcn line # */
|
||||
long x_endndx; /* entry ndx past block end */
|
||||
} x_fcn;
|
||||
struct { /* if ISARY, up to 4 dimen. */
|
||||
unsigned short x_dimen[DIMNUM];
|
||||
} x_ary;
|
||||
} x_fcnary;
|
||||
unsigned short x_tvndx; /* tv index */
|
||||
} x_sym;
|
||||
|
||||
union {
|
||||
char x_fname[FILNMLEN];
|
||||
struct {
|
||||
long x_zeroes;
|
||||
long x_offset;
|
||||
} x_n;
|
||||
} x_file;
|
||||
|
||||
struct {
|
||||
long x_scnlen; /* section length */
|
||||
unsigned long x_nreloc; /* # relocation entries */
|
||||
unsigned long x_nlinno; /* # line numbers */
|
||||
} x_scn;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define SYMENT struct syment
|
||||
#define SYMESZ sizeof(SYMENT)
|
||||
#define AUXENT union auxent
|
||||
#define AUXESZ sizeof(AUXENT)
|
||||
|
||||
|
||||
/********************** RELOCATION DIRECTIVES **********************/
|
||||
|
||||
struct reloc {
|
||||
long r_vaddr; /* Virtual address of reference */
|
||||
long r_symndx; /* Index into symbol table */
|
||||
unsigned short r_type; /* Relocation type */
|
||||
unsigned short r_offset;/* Hi 16 bits of constant */
|
||||
};
|
||||
|
||||
/* Only values of r_type GNU/88k cares about */
|
||||
#define R_PCR16L 128
|
||||
#define R_PCR26L 129
|
||||
#define R_VRT16 130
|
||||
#define R_HVRT16 131
|
||||
#define R_LVRT16 132
|
||||
#define R_VRT32 133
|
||||
|
||||
|
||||
|
||||
|
||||
#define RELOC struct reloc
|
||||
#define RELSZ sizeof(RELOC)
|
||||
|
||||
#define DEFAULT_SECTION_ALIGNMENT 8 /* double word */
|
||||
|
|
@ -0,0 +1,855 @@
|
|||
/* A -*- C -*- header file for the bfd library */
|
||||
|
||||
/*** bfd.h -- The only header file required by users of the bfd library */
|
||||
|
||||
/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of BFD, the Binary File Diddler.
|
||||
|
||||
BFD 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 1, or (at your option)
|
||||
any later version.
|
||||
|
||||
BFD 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 BFD; see the file COPYING. If not, write to
|
||||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
/* executable_object_p is gone -- you can check the bfd flags and call
|
||||
access() yourself */
|
||||
|
||||
#ifndef __BFD_H_SEEN__
|
||||
#define __BFD_H_SEEN__
|
||||
|
||||
#include "ansidecl.h"
|
||||
#include "obstack.h"
|
||||
|
||||
/* Make it easier to declare prototypes (puts conditional here) */
|
||||
#ifndef PROTO
|
||||
# if __STDC__
|
||||
# define PROTO(type, name, arglist) type name arglist
|
||||
# else
|
||||
# define PROTO(type, name, arglist) type name ()
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#define BFD_VERSION "1.9"
|
||||
/* forward declaration */
|
||||
typedef struct _bfd_struct bfd;
|
||||
|
||||
/* I'm sure this is going to break something and someone is going to
|
||||
force me to change it. */
|
||||
typedef enum boolean {false, true} boolean;
|
||||
/* FIXME-SOON: I hate it when types are invented for things that
|
||||
already have types. In this case, zero and non-zero are so common
|
||||
that true vs false makes me stop and read code each time I want to
|
||||
know if they mean true there was an error or true the function did
|
||||
something. I can't fix this particularly quickly, so I'll just
|
||||
skirt the issue for now. This WILL change soon. */
|
||||
#define BFD_SUCCESS (true)
|
||||
#define BFD_FAILURE (false)
|
||||
|
||||
/* Try to avoid breaking stuff */
|
||||
typedef long int file_ptr;
|
||||
|
||||
/* This is used to refer to locations inside a section's rawdata */
|
||||
typedef unsigned long int rawdata_offset;
|
||||
|
||||
typedef unsigned long bfd_vma;
|
||||
typedef unsigned long bfd_offset;
|
||||
|
||||
typedef unsigned int flagword; /* 32 bits of flags */
|
||||
|
||||
/** File formats */
|
||||
|
||||
typedef enum bfd_format {
|
||||
bfd_unknown = 0, /* file format is unknown */
|
||||
bfd_object, /* linker/assember/compiler output */
|
||||
bfd_archive, /* object archive file */
|
||||
bfd_core, /* core dump */
|
||||
bfd_type_end} /* marks the end; don't use it! */
|
||||
bfd_format;
|
||||
|
||||
/* Object file flag values */
|
||||
#define NO_FLAGS 0
|
||||
#define HAS_RELOC 001
|
||||
#define EXEC_P 002
|
||||
#define HAS_LINENO 004
|
||||
#define HAS_DEBUG 010
|
||||
#define HAS_SYMS 020
|
||||
#define HAS_LOCALS 040
|
||||
#define DYNAMIC 0100
|
||||
#define WP_TEXT 0200
|
||||
#define D_PAGED 0400
|
||||
|
||||
/* This enum gives the object file's CPU architecture, in a global sense.
|
||||
E.g. what processor family does it belong to? There is another field,
|
||||
which indicates what processor within the family is in use. */
|
||||
enum bfd_architecture {
|
||||
bfd_arch_unknown, /* File arch not known */
|
||||
bfd_arch_obscure, /* File arch known, not one of these */
|
||||
bfd_arch_m68k, /* Motorola 68xxx */
|
||||
bfd_arch_vax, /* DEC Vax */
|
||||
bfd_arch_i960, /* Intel 960 */
|
||||
#define bfd_mach_i960_core 0
|
||||
#define bfd_mach_i960_kb_sb 1
|
||||
#define bfd_mach_i960_mc 2
|
||||
#define bfd_mach_i960_xa 3
|
||||
#define bfd_mach_i960_ca 4
|
||||
#define bfd_mach_i960_ka_sa 5
|
||||
|
||||
bfd_arch_a29k, /* AMD 29000 */
|
||||
bfd_arch_sparc, /* Sun (SPARC International) SPARC */
|
||||
bfd_arch_mips, /* MIPS Rxxxx */
|
||||
bfd_arch_i386, /* Intel 386 */
|
||||
bfd_arch_ns32k, /* National Semiconductor 32xxx */
|
||||
bfd_arch_tahoe, /* CCI/Harris Tahoe */
|
||||
bfd_arch_i860, /* Intel 860 */
|
||||
bfd_arch_romp, /* IBM ROMP RS/6000 */
|
||||
bfd_arch_alliant, /* Alliant */
|
||||
bfd_arch_convex, /* Convex */
|
||||
bfd_arch_m88k, /* Motorola 88xxx */
|
||||
bfd_arch_pyramid, /* Pyramid Technology */
|
||||
bfd_arch_h8_300, /* Hitachi H8/300 */
|
||||
bfd_arch_last,
|
||||
};
|
||||
|
||||
/* symbols and relocation */
|
||||
|
||||
typedef unsigned long symindex;
|
||||
|
||||
#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
|
||||
|
||||
typedef enum {bfd_symclass_unknown = 0,
|
||||
bfd_symclass_fcommon, /* fortran common symbols */
|
||||
bfd_symclass_global, /* global symbol, what a surprise */
|
||||
bfd_symclass_debugger, /* some debugger symbol */
|
||||
bfd_symclass_undefined /* none known */
|
||||
} symclass;
|
||||
|
||||
typedef unsigned long symvalue; /* someday they may be 64-bit qtys */
|
||||
typedef int symtype; /* Who knows, yet? */
|
||||
typedef int bfd_size_type;
|
||||
/* Symbol cache classifications: (Bfd-Symbol-Flag_FOOBAR) */
|
||||
#define BSF_NO_FLAGS 0x00
|
||||
#define BSF_LOCAL 0x01 /* bfd_symclass_unknown */
|
||||
#define BSF_GLOBAL 0x02 /* bfd_symclass_global */
|
||||
#define BSF_IMPORT 0x04
|
||||
#define BSF_EXPORT 0x08
|
||||
#define BSF_UNDEFINED 0x10 /* bfd_symclass_undefined */
|
||||
#define BSF_FORT_COMM 0x20 /* bfd_symclass_fcommon */
|
||||
#define BSF_DEBUGGING 0x40 /* bfd_symclass_debugger */
|
||||
#define BSF_ABSOLUTE 0x80
|
||||
#define BSF_KEEP 0x10000
|
||||
#define BSF_WARNING 0x20000
|
||||
#define BSF_KEEP_G 0x80000
|
||||
#define BSF_WEAK 0x100000
|
||||
#define BSF_CTOR 0x200000 /* Symbol is a con/destructor */
|
||||
#define BSF_FAKE 0x400000 /* SYmbol doesn't really exist */
|
||||
#define BSF_OLD_COMMON 0x800000 /* Symbol used to be common,
|
||||
but now is allocated */
|
||||
/* If symbol is fort_comm, then value is size, and this is the */
|
||||
/* contents */
|
||||
#define BFD_FORT_COMM_DEFAULT_VALUE 0
|
||||
|
||||
/* in some files the type of a symbol sometimes alters its location
|
||||
* in an output file - ie in coff a ISFCN symbol which is also C_EXT
|
||||
* symbol appears where it was declared and not at the end of a section.
|
||||
* This bit is set by the target bfd part to convey this information.
|
||||
*/
|
||||
#define BSF_NOT_AT_END 0x40000
|
||||
|
||||
|
||||
/* general purpose part of a symbol
|
||||
* target specific parts will be found in libcoff.h, liba.out.h etc
|
||||
*/
|
||||
typedef struct symbol_cache_entry
|
||||
{
|
||||
struct _bfd_struct *the_bfd; /* Just a way to find out host type */
|
||||
CONST char *name;
|
||||
symvalue value;
|
||||
flagword flags;
|
||||
struct sec_struct *section;
|
||||
PTR udata; /* Target-specific stuff */
|
||||
} asymbol;
|
||||
|
||||
#define bfd_get_section(x) ((x)->section)
|
||||
#define bfd_get_output_section(x) ((x)->section->output_section)
|
||||
#define bfd_set_section(x,y) ((x)->section) = (y)
|
||||
#define bfd_asymbol_base(x) ((x)->section?((x)->section->vma):0)
|
||||
#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + x->value)
|
||||
#define bfd_asymbol_name(x) ((x)->name)
|
||||
|
||||
|
||||
/* This is a type pun with struct ranlib on purpose! */
|
||||
typedef struct {
|
||||
char *name;
|
||||
file_ptr file_offset; /* look here to find the file */
|
||||
} carsym; /* to make these you call a carsymogen */
|
||||
|
||||
/* Relocation stuff */
|
||||
|
||||
/* Either: sym will point to a symbol and isextern will be 0, *OR*
|
||||
sym will be NULL and isextern will be a symbol type (eg N_TEXT)
|
||||
which means the location should be relocated relative to the
|
||||
segment origin. This is because we won't necessarily have a symbol
|
||||
which is guaranteed to point to the segment origin. */
|
||||
|
||||
typedef enum {
|
||||
bfd_reloc_ok,
|
||||
bfd_reloc_overflow,
|
||||
bfd_reloc_outofrange,
|
||||
bfd_reloc_continue,
|
||||
bfd_reloc_notsupported,
|
||||
bfd_reloc_other,
|
||||
bfd_reloc_undefined,
|
||||
bfd_reloc_dangerous}
|
||||
bfd_reloc_status_enum_type;
|
||||
|
||||
typedef CONST struct rint_struct {
|
||||
unsigned int type;
|
||||
unsigned int rightshift;
|
||||
unsigned int size;
|
||||
unsigned int bitsize;
|
||||
boolean pc_relative;
|
||||
unsigned int bitpos;
|
||||
|
||||
boolean absolute;
|
||||
boolean complain_on_overflow;
|
||||
bfd_reloc_status_enum_type (*special_function)();
|
||||
char *name;
|
||||
boolean partial_inplace;
|
||||
/* Two mask fields,
|
||||
the src_mask is used to select what parts of the read in data are to
|
||||
be used in the relocation sum. Eg, if this was an 8 bit bit of data
|
||||
which we read and relocated, this would be 0x000000ff. When we have
|
||||
relocs which have an addend, such as sun4 extended relocs, the value
|
||||
in the offset part of a relocating field is garbage so we never use
|
||||
it. In this case the mask would be 0x00000000.
|
||||
|
||||
The dst_mask is what parts of the instruction are replaced into the
|
||||
instruction. In most cases src_mask == dst_mask, except in the above
|
||||
special case, where dst_mask would be 0x000000ff, and src_mask would
|
||||
be 0x00000000.
|
||||
*/
|
||||
unsigned int src_mask; /* What things to take from the source */
|
||||
unsigned int dst_mask; /* What things to put into the dest */
|
||||
|
||||
/* Does a pc rel offset already have the offset of the jump from the
|
||||
beginnining of the module in place - eg on the sun3, a pcrel
|
||||
instruction always has a negative number in place, containing the
|
||||
displacement from the beginning of the module. 88k bcs has a zero
|
||||
in there, so you have to work out the offset yourself. */
|
||||
boolean pcrel_offset;
|
||||
} reloc_howto_type;
|
||||
|
||||
#define HOWTO(CODE, RT,SIZE,BITSIZE, PCREL, BITPOS, ABS, OVERFLOW, SF, NAME, INPLACE, MASKSRC, MASKDST, PCRELDONE) \
|
||||
{(unsigned)CODE,RT,SIZE,BITSIZE, PCREL, BITPOS,ABS,OVERFLOW,SF,NAME,INPLACE,MASKSRC,MASKDST,PCRELDONE}
|
||||
|
||||
typedef unsigned char bfd_byte;
|
||||
|
||||
typedef struct reloc_cache_entry
|
||||
{
|
||||
/* A pointer into the canonicalized table for the symbol */
|
||||
asymbol **sym_ptr_ptr;
|
||||
|
||||
rawdata_offset address; /* offset in section */
|
||||
bfd_vma addend; /* addend for relocation value */
|
||||
struct sec_struct *section; /* if sym is null this is the section */
|
||||
reloc_howto_type *howto;
|
||||
|
||||
} arelent;
|
||||
|
||||
typedef struct relent_chain_struct {
|
||||
arelent relent;
|
||||
struct relent_chain_struct *next;
|
||||
} arelent_chain;
|
||||
|
||||
/* Used in generating armaps. Perhaps just a forward definition would do? */
|
||||
struct orl { /* output ranlib */
|
||||
char **name; /* symbol name */
|
||||
file_ptr pos; /* element number or file position */
|
||||
int namidx; /* index into string table */
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* Linenumber stuff */
|
||||
typedef struct lineno_cache_entry {
|
||||
unsigned int line_number; /* Linenumber from start of function*/
|
||||
union {
|
||||
asymbol *sym; /* Function name */
|
||||
unsigned long offset; /* Offset into section */
|
||||
} u;
|
||||
} alent;
|
||||
|
||||
/* object and core file sections */
|
||||
|
||||
/* Section flag definitions */
|
||||
#define SEC_NO_FLAGS 000
|
||||
#define SEC_ALLOC 001
|
||||
#define SEC_LOAD 002
|
||||
#define SEC_RELOC 004
|
||||
#define SEC_BALIGN 010
|
||||
#define SEC_READONLY 020
|
||||
#define SEC_CODE 040
|
||||
#define SEC_DATA 0100
|
||||
#define SEC_ROM 0200
|
||||
#define SEC_CONSTRUCTOR 0400
|
||||
#define SEC_HAS_CONTENTS (0x200)
|
||||
|
||||
typedef struct sec_struct
|
||||
{
|
||||
CONST char *name;
|
||||
struct sec_struct *next;
|
||||
flagword flags;
|
||||
|
||||
bfd_vma vma;
|
||||
bfd_size_type size;
|
||||
|
||||
/* The output_offset is the indent into the output section of
|
||||
this section. If this is the first section to go into
|
||||
an output section, this value will be 0...
|
||||
*/
|
||||
bfd_vma output_offset;
|
||||
struct sec_struct *output_section;
|
||||
unsigned int alignment_power; /* eg 4 aligns to 2^4*/
|
||||
|
||||
arelent *relocation; /* for input files */
|
||||
arelent **orelocation; /* for output files */
|
||||
|
||||
unsigned reloc_count;
|
||||
file_ptr filepos; /* File position of section data */
|
||||
file_ptr rel_filepos; /* File position of relocation info */
|
||||
file_ptr line_filepos;
|
||||
struct user_section_struct *userdata;
|
||||
struct lang_output_section_struct *otheruserdata;
|
||||
int index; /* Which section is it 0..nth */
|
||||
alent *lineno;
|
||||
unsigned int lineno_count;
|
||||
|
||||
/* When a section is being output, this value changes as more
|
||||
* linenumbers are written out */
|
||||
file_ptr moving_line_filepos;
|
||||
|
||||
/* what the section number is in the target world */
|
||||
unsigned int target_index;
|
||||
|
||||
PTR used_by_bfd;
|
||||
|
||||
/* If this is a constructor section then here is a list of relents
|
||||
*/
|
||||
arelent_chain *constructor_chain;
|
||||
} asection;
|
||||
|
||||
#define align_power(addr, align) \
|
||||
( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
|
||||
|
||||
|
||||
|
||||
typedef struct sec_struct *sec_ptr;
|
||||
|
||||
#define bfd_section_name(bfd, ptr) ((ptr)->name)
|
||||
#define bfd_section_size(bfd, ptr) ((ptr)->size)
|
||||
#define bfd_section_vma(bfd, ptr) ((ptr)->vma)
|
||||
#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
|
||||
#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags)
|
||||
#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
|
||||
|
||||
#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (val)), true)
|
||||
#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
|
||||
#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
|
||||
struct stat;
|
||||
|
||||
/** Error handling */
|
||||
|
||||
typedef enum {no_error = 0, system_call_error, invalid_target,
|
||||
wrong_format, invalid_operation, no_memory,
|
||||
no_symbols, no_relocation_info,
|
||||
no_more_archived_files, malformed_archive,
|
||||
symbol_not_found, file_not_recognized,
|
||||
file_ambiguously_recognized, no_contents,
|
||||
bfd_error_nonrepresentable_section,
|
||||
invalid_error_code} bfd_ec;
|
||||
|
||||
extern bfd_ec bfd_error;
|
||||
|
||||
typedef struct {
|
||||
PROTO(void,(* nonrepresentable_section ),(CONST bfd *CONST abfd,
|
||||
CONST char *CONST name));
|
||||
} bfd_error_vector_type;
|
||||
|
||||
PROTO (char *, bfd_errmsg, ());
|
||||
PROTO (void, bfd_perror, (CONST char *message));
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
bfd_print_symbol_name_enum,
|
||||
bfd_print_symbol_type_enum,
|
||||
bfd_print_symbol_all_enum,
|
||||
} bfd_print_symbol_enum_type;
|
||||
|
||||
|
||||
/* The BFD target structure.
|
||||
|
||||
This structure is how to find out everything BFD knows about a target.
|
||||
It includes things like its byte order, name, what routines to call
|
||||
to do various operations, etc.
|
||||
|
||||
Every BFD points to a target structure with its "xvec" member. */
|
||||
|
||||
/* Shortcut for declaring fields which are prototyped function pointers,
|
||||
while avoiding anguish on compilers that don't support protos. */
|
||||
|
||||
#define SDEF(ret, name, arglist) PROTO(ret,(*name),arglist)
|
||||
#define SDEF_FMT(ret, name, arglist) PROTO(ret,(*name[bfd_type_end]),arglist)
|
||||
|
||||
/* These macros are used to dispatch to functions through the bfd_target
|
||||
vector. They are used in a number of macros further down in bfd.h,
|
||||
and are also used when calling various routines by hand inside the
|
||||
bfd implementation. The "arglist" argument must be parenthesized;
|
||||
it contains all the arguments to the called function. */
|
||||
|
||||
#define BFD_SEND(bfd, message, arglist) ((*((bfd)->xvec->message)) arglist)
|
||||
/* For operations which index on the bfd format */
|
||||
#define BFD_SEND_FMT(bfd, message, arglist) \
|
||||
(((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
|
||||
|
||||
/* FIXME, these names should be rationalised with the names of the entry points
|
||||
which call them. Too bad we can't have one macro to define them both! */
|
||||
typedef struct bfd_target
|
||||
{
|
||||
/* identifies the kind of target, eg SunOS4, Ultrix, etc */
|
||||
char *name;
|
||||
|
||||
/* This is bogus. Anything that can be told from the "flavour"
|
||||
by some user program should be an independent attribute that can
|
||||
be queried instead. FIXME. -- gnu@cygnus.com */
|
||||
enum target_flavour_enum {
|
||||
bfd_target_aout_flavour_enum,
|
||||
bfd_target_coff_flavour_enum,
|
||||
bfd_target_ieee_flavour_enum,
|
||||
bfd_target_oasys_flavour_enum,
|
||||
bfd_target_srec_flavour_enum} flavour;
|
||||
|
||||
boolean byteorder_big_p; /* Order of bytes in data sections */
|
||||
boolean header_byteorder_big_p; /* Order of bytes in header */
|
||||
|
||||
flagword object_flags; /* these are the ones that may be set */
|
||||
flagword section_flags; /* ditto */
|
||||
|
||||
char ar_pad_char; /* filenames in archives padded w/this char */
|
||||
unsigned short ar_max_namelen; /* this could be a char too! */
|
||||
|
||||
/* Byte swapping for data */
|
||||
/* Note that these don't take bfd as first arg. Certain other handlers
|
||||
could do the same. */
|
||||
SDEF (long, bfd_getxlong, (bfd_byte *));
|
||||
SDEF (void, bfd_putxlong, (unsigned long, bfd_byte *));
|
||||
SDEF (short, bfd_getxshort, (bfd_byte *));
|
||||
SDEF (void, bfd_putxshort, (int, bfd_byte *));
|
||||
|
||||
/* Byte swapping for headers */
|
||||
SDEF (long, bfd_h_getxlong, (bfd_byte *));
|
||||
SDEF (void, bfd_h_putxlong, (unsigned long, bfd_byte *));
|
||||
SDEF (short, bfd_h_getxshort, (bfd_byte *));
|
||||
SDEF (void, bfd_h_putxshort, (int, bfd_byte *));
|
||||
|
||||
/* Format-dependent */
|
||||
SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));/* file fmt or 0 */
|
||||
SDEF_FMT (boolean, _bfd_set_format, (bfd *)); /* make it an object file. */
|
||||
|
||||
/* All these are defined in JUMP_TABLE */
|
||||
/* Core files */
|
||||
SDEF (char *, _core_file_failing_command, (bfd *));
|
||||
SDEF (int, _core_file_failing_signal, (bfd *));
|
||||
SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *));
|
||||
|
||||
/* Archives */
|
||||
SDEF (boolean, _bfd_slurp_armap, (bfd *));
|
||||
SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *));
|
||||
SDEF (void, _bfd_truncate_arname, (bfd *, CONST char *, char *));
|
||||
SDEF (boolean, write_armap, (bfd *arch, unsigned int elength,
|
||||
struct orl *map, int orl_count, int
|
||||
stridx));
|
||||
|
||||
/* All the standard stuff */
|
||||
SDEF (boolean, _close_and_cleanup, (bfd *)); /* free any allocated data */
|
||||
SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR,
|
||||
file_ptr, int));
|
||||
SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR,
|
||||
file_ptr, int));
|
||||
SDEF (boolean, _new_section_hook, (bfd *, sec_ptr));
|
||||
|
||||
/* Symbols and relocation */
|
||||
SDEF (unsigned int, _get_symtab_upper_bound, (bfd *));
|
||||
SDEF (unsigned int, _bfd_canonicalize_symtab, (bfd *, asymbol **));
|
||||
SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr));
|
||||
SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **,
|
||||
asymbol**));
|
||||
|
||||
/* FIXME: For steve -- clean up later */
|
||||
SDEF (asymbol *, _bfd_make_empty_symbol, (bfd *));
|
||||
SDEF (void, _bfd_print_symbol, (bfd *, PTR, asymbol *,
|
||||
bfd_print_symbol_enum_type));
|
||||
SDEF(alent *, _get_lineno, (bfd *, asymbol *));
|
||||
|
||||
/* This should perhaps be format-dependent, I don't know yet. -gnu */
|
||||
SDEF (boolean, _bfd_set_arch_mach, (bfd *, enum bfd_architecture,
|
||||
unsigned long));
|
||||
|
||||
SDEF (bfd *, openr_next_archived_file, (bfd *arch, bfd *prev));
|
||||
SDEF (boolean, _bfd_find_nearest_line,
|
||||
(bfd *abfd, asection *section, asymbol **symbols,bfd_vma offset,
|
||||
CONST char **file, CONST char **func, unsigned int *line));
|
||||
SDEF (int, _bfd_stat_arch_elt, (bfd *, struct stat *));
|
||||
SDEF (int, _bfd_sizeof_headers, (bfd *, boolean));
|
||||
} bfd_target;
|
||||
|
||||
/* The code that implements targets can initialize a jump table with this
|
||||
macro. It must name all its routines the same way (a prefix plus
|
||||
the standard routine suffix), or it must #define the routines that
|
||||
are not so named, before calling JUMP_TABLE in the initializer. */
|
||||
|
||||
/* Semi-portable string concatenation in cpp */
|
||||
#ifndef CAT
|
||||
#ifdef __STDC__
|
||||
#define CAT(a,b) a##b
|
||||
#else
|
||||
#define CAT(a,b) a/**/b
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define JUMP_TABLE(NAME)\
|
||||
CAT(NAME,_core_file_failing_command),\
|
||||
CAT(NAME,_core_file_failing_signal),\
|
||||
CAT(NAME,_core_file_matches_executable_p),\
|
||||
CAT(NAME,_slurp_armap),\
|
||||
CAT(NAME,_slurp_extended_name_table),\
|
||||
CAT(NAME,_truncate_arname),\
|
||||
CAT(NAME,_write_armap),\
|
||||
CAT(NAME,_close_and_cleanup), \
|
||||
CAT(NAME,_set_section_contents),\
|
||||
CAT(NAME,_get_section_contents),\
|
||||
CAT(NAME,_new_section_hook),\
|
||||
CAT(NAME,_get_symtab_upper_bound),\
|
||||
CAT(NAME,_get_symtab),\
|
||||
CAT(NAME,_get_reloc_upper_bound),\
|
||||
CAT(NAME,_canonicalize_reloc),\
|
||||
CAT(NAME,_make_empty_symbol),\
|
||||
CAT(NAME,_print_symbol),\
|
||||
CAT(NAME,_get_lineno),\
|
||||
CAT(NAME,_set_arch_mach),\
|
||||
CAT(NAME,_openr_next_archived_file),\
|
||||
CAT(NAME,_find_nearest_line),\
|
||||
CAT(NAME,_generic_stat_arch_elt),\
|
||||
CAT(NAME,_sizeof_headers)
|
||||
|
||||
/* User program access to BFD facilities */
|
||||
|
||||
extern CONST short _bfd_host_big_endian;
|
||||
#define HOST_BYTE_ORDER_BIG_P (*(char *)&_bfd_host_big_endian)
|
||||
|
||||
/* The bfd itself */
|
||||
|
||||
#define bfd_get_filename(abfd) ((abfd)->filename)
|
||||
#define bfd_get_format(abfd) ((abfd)->format)
|
||||
#define bfd_get_target(abfd) ((abfd)->xvec->name)
|
||||
#define bfd_get_file_flags(abfd) ((abfd)->flags)
|
||||
#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
|
||||
#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
|
||||
#define bfd_my_archive(abfd) ((abfd)->my_archive);
|
||||
#define bfd_has_map(abfd) ((abfd)->has_armap)
|
||||
#define bfd_header_twiddle_required(abfd) \
|
||||
((((abfd)->xvec->header_byteorder_big_p) \
|
||||
!= (boolean)HOST_BYTE_ORDER_BIG_P) ? true:false)
|
||||
|
||||
#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
|
||||
#define bfd_usrdata(abfd) ((abfd)->usrdata)
|
||||
|
||||
#define bfd_get_start_address(abfd) ((abfd)->start_address)
|
||||
#define bfd_get_symcount(abfd) ((abfd)->symcount)
|
||||
#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
|
||||
#define bfd_count_sections(abfd) ((abfd)->section_count)
|
||||
#define bfd_get_architecture(abfd) ((abfd)->obj_arch)
|
||||
#define bfd_get_machine(abfd) ((abfd)->obj_machine)
|
||||
|
||||
/* Finally! The BFD struct itself. This contains the major data about
|
||||
the file, and contains pointers to the rest of the data.
|
||||
|
||||
To avoid dragging too many header files into every file that
|
||||
includes bfd.h, IOSTREAM has been declared as a "char *", and MTIME
|
||||
as a "long". Their correct types, to which they are cast when used,
|
||||
are "FILE *" and "time_t". If these had been declared as structs
|
||||
rather than typedefs, we wouldn't have this problem. */
|
||||
|
||||
struct _bfd_struct
|
||||
{
|
||||
|
||||
CONST char *filename; /* could be null; filename user opened with */
|
||||
bfd_target *xvec; /* operation jump table */
|
||||
char *iostream; /* stdio FILE *, unless an archive element */
|
||||
|
||||
boolean cacheable; /* iostream can be closed if desired */
|
||||
struct _bfd_struct *lru_prev; /* Used for file caching */
|
||||
struct _bfd_struct *lru_next; /* Used for file caching */
|
||||
file_ptr where; /* Where the file was when closed */
|
||||
boolean opened_once;
|
||||
boolean mtime_set; /* Flag indicating mtime is available */
|
||||
long mtime; /* File modified time */
|
||||
int ifd; /* for output files, channel we locked. */
|
||||
bfd_format format;
|
||||
enum bfd_direction {no_direction = 0,
|
||||
read_direction = 1,
|
||||
write_direction = 2,
|
||||
both_direction = 3} direction;
|
||||
|
||||
flagword flags; /* format_specific */
|
||||
/*
|
||||
Currently my_archive is tested before adding origin to anything. I
|
||||
believe that this can become always an add of origin, with origin set
|
||||
to 0 for non archive files
|
||||
*/
|
||||
|
||||
file_ptr origin; /* for archive contents */
|
||||
boolean output_has_begun; /* cf bfd_set_section_size */
|
||||
asection *sections; /* Pointer to linked list of sections */
|
||||
unsigned int section_count; /* The number of sections */
|
||||
|
||||
/* Some object file stuff */
|
||||
bfd_vma start_address; /* for object files only, of course */
|
||||
unsigned int symcount; /* used for input and output */
|
||||
asymbol **outsymbols; /* symtab for output bfd */
|
||||
enum bfd_architecture obj_arch; /* Architecture of object machine, eg m68k */
|
||||
unsigned long obj_machine; /* Particular machine within arch, e.g. 68010 */
|
||||
|
||||
/* Archive stuff. strictly speaking we don't need all three bfd* vars,
|
||||
but doing so would allow recursive archives! */
|
||||
PTR arelt_data; /* needed if this came from an archive */
|
||||
struct _bfd_struct *my_archive; /* if this is an archive element */
|
||||
struct _bfd_struct *next; /* output chain pointer */
|
||||
struct _bfd_struct *archive_head; /* for output archive */
|
||||
boolean has_armap; /* if an arch; has it an armap? */
|
||||
|
||||
PTR tdata; /* target-specific storage */
|
||||
PTR usrdata; /* application-specific storage */
|
||||
|
||||
/* Should probably be enabled here always, so that library may be changed
|
||||
to switch this on and off, while user code may remain unchanged */
|
||||
#ifdef BFD_LOCKS
|
||||
struct flock *lock;
|
||||
char *actual_name; /* for output files, name given to open() */
|
||||
#endif
|
||||
|
||||
/* Where all the allocated stuff under this BFD goes */
|
||||
struct obstack memory;
|
||||
};
|
||||
|
||||
PROTO(PTR, bfd_alloc, (bfd *abfd, size_t size));
|
||||
PROTO(PTR, bfd_zalloc,(bfd *abfd, size_t size));
|
||||
PROTO(PTR, bfd_realloc,(bfd *abfd, PTR orig, size_t new));
|
||||
PROTO(size_t, bfd_alloc_size,(bfd *abfd));
|
||||
/* FIXME, these are broken! bfd_free references "Y" which is not a parameter.
|
||||
bfd_release frees the mentioned object AND EVERYTHING AFTER IT IN THE
|
||||
OBSTACK! -- gnu@cygnus.com */
|
||||
#define bfd_free(x) (obstack_free(&(x->memory),y))
|
||||
#define bfd_release(x,y) (obstack_free(&(x->memory),y))
|
||||
PROTO (char *, bfd_printable_arch_mach,(enum bfd_architecture, unsigned long));
|
||||
PROTO (char *, bfd_format_string, (bfd_format format));
|
||||
|
||||
PROTO (char**, bfd_target_list, ());
|
||||
PROTO (bfd *, bfd_openr, (CONST char *filename, CONST char *target));
|
||||
PROTO (bfd *, bfd_fdopenr, (CONST char *filename, CONST char *target, int fd));
|
||||
PROTO (bfd *, bfd_openw, (CONST char *filename, CONST char *target));
|
||||
PROTO (bfd *, bfd_create, (CONST char *filename, CONST bfd *abfd));
|
||||
PROTO (boolean, bfd_close, (bfd *abfd));
|
||||
PROTO (long, bfd_get_mtime, (bfd *abfd));
|
||||
PROTO (bfd *, bfd_openr_next_archived_file, (bfd *obfd, bfd *last_file));
|
||||
PROTO (boolean, bfd_set_archive_head, (bfd *output_archive, bfd *new_head));
|
||||
PROTO (boolean, bfd_check_format, (bfd *abfd, bfd_format format));
|
||||
PROTO (boolean, bfd_set_format, (bfd *abfd, bfd_format format));
|
||||
PROTO (char *, bfd_core_file_failing_command, (bfd *abfd));
|
||||
PROTO (int, bfd_core_file_failing_signal, (bfd *abfd));
|
||||
PROTO (boolean, core_file_matches_executable_p, (bfd *core_bfd, bfd *exec_bfd));
|
||||
PROTO (sec_ptr, bfd_get_section_by_name, (bfd *abfd, CONST char *name));
|
||||
PROTO (void, bfd_map_over_sections, (bfd *abfd, void (*operation)(),
|
||||
PTR user_storage));
|
||||
PROTO (sec_ptr, bfd_make_section, (bfd *abfd, CONST char *CONST name));
|
||||
PROTO (boolean, bfd_set_section_flags, (bfd *abfd, sec_ptr section,
|
||||
flagword flags));
|
||||
PROTO (boolean, bfd_set_file_flags, (bfd *abfd, flagword flags));
|
||||
PROTO (boolean, bfd_arch_compatible, (bfd *abfd, bfd *bbfd,
|
||||
enum bfd_architecture *res_arch,
|
||||
unsigned long *res_machine));
|
||||
|
||||
PROTO (boolean, bfd_set_section_size, (bfd *abfd, sec_ptr ptr,
|
||||
unsigned long val));
|
||||
PROTO (boolean, bfd_get_section_contents, (bfd *abfd, sec_ptr section,
|
||||
PTR location,
|
||||
file_ptr offset, int count));
|
||||
PROTO (boolean, bfd_set_section_contents, (bfd *abfd, sec_ptr section,
|
||||
PTR location,
|
||||
file_ptr offset, int count));
|
||||
|
||||
PROTO (unsigned long, bfd_get_next_mapent, (bfd *abfd, symindex prev, carsym **entry));
|
||||
PROTO (bfd *, bfd_get_elt_at_index, (bfd *abfd, int index));
|
||||
PROTO (boolean, bfd_set_symtab, (bfd *abfd, asymbol **location,
|
||||
unsigned int symcount));
|
||||
PROTO (unsigned int, get_reloc_upper_bound, (bfd *abfd, sec_ptr asect));
|
||||
PROTO (unsigned int, bfd_canonicalize_reloc, (bfd *abfd, sec_ptr asect,
|
||||
arelent **location,
|
||||
asymbol **canon));
|
||||
PROTO (void, bfd_set_reloc, (bfd *abfd, sec_ptr asect, arelent **location,
|
||||
unsigned int count));
|
||||
PROTO (boolean, bfd_set_start_address, (bfd *,bfd_vma));
|
||||
|
||||
PROTO (void, bfd_print_symbol_vandf, (PTR, asymbol *));
|
||||
PROTO (bfd_reloc_status_enum_type, bfd_perform_relocation,
|
||||
(bfd *, arelent*, PTR, asection *, bfd*));
|
||||
|
||||
PROTO (bfd_vma, bfd_log2, (bfd_vma));
|
||||
#define bfd_symbol_same_target(abfd, symbol) \
|
||||
( ( ((symbol)->the_bfd->xvec) == (abfd)->xvec) ? true:false)
|
||||
|
||||
PROTO(boolean, bfd_scan_arch_mach,(CONST char *, enum bfd_architecture *,
|
||||
unsigned long *));
|
||||
|
||||
/* For speed we turn calls to these interface routines directly into
|
||||
jumps through the transfer vector. This makes error-checking somewhat
|
||||
confusing; the user basically has to read the documentation since there
|
||||
are no longer prototypes, only declarations in the xfer vector (which
|
||||
should be enough for some compilers).
|
||||
|
||||
To bad the preprocessor is too dumb to allow us to clean this up with
|
||||
a macro. */
|
||||
|
||||
#define bfd_set_arch_mach(abfd, arch, mach) \
|
||||
BFD_SEND (abfd, _bfd_set_arch_mach, (abfd, arch, mach))
|
||||
|
||||
#define bfd_sizeof_headers(abfd, reloc) \
|
||||
BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
|
||||
|
||||
#define bfd_symbol_value(abfd, idx) \
|
||||
BFD_SEND (abfd, _bfd_symbol_value, (abfd, idx))
|
||||
|
||||
#define bfd_symbol_name(abfd, idx) \
|
||||
BFD_SEND (abfd, _bfd_symbol_name, (abfd, idx))
|
||||
|
||||
|
||||
#define bfd_get_first_symbol(abfd) \
|
||||
BFD_SEND (abfd, _bfd_get_first_symbol, (abfd))
|
||||
|
||||
#define bfd_get_next_symbol(abfd, oidx) \
|
||||
BFD_SEND (abfd, _bfd_get_next_symbol, (abfd, oidx))
|
||||
|
||||
#define bfd_classify_symbol(abfd, idx) \
|
||||
BFD_SEND (abfd, _bfd_classify_symbol, (abfd, idx))
|
||||
|
||||
#define bfd_symbol_hasclass(abfd, idx, class) \
|
||||
BFD_SEND (abfd, _bfd_symbol_hasclass, (abfd, idx, class))
|
||||
|
||||
#define get_symtab_upper_bound(abfd) \
|
||||
BFD_SEND (abfd, _get_symtab_upper_bound, (abfd))
|
||||
|
||||
#define bfd_canonicalize_symtab(abfd, location) \
|
||||
BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
|
||||
|
||||
|
||||
#define bfd_make_empty_symbol(abfd) \
|
||||
BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
|
||||
|
||||
#define bfd_print_symbol(abfd, file, symbol, how) \
|
||||
BFD_SEND (abfd, _bfd_print_symbol, (abfd, file, symbol, how))
|
||||
|
||||
#define bfd_get_lineno(abfd, symbol) \
|
||||
BFD_SEND (abfd, _get_lineno, (abfd, symbol))
|
||||
|
||||
#define bfd_stat_arch_elt(abfd, buf) \
|
||||
BFD_SEND(abfd, _bfd_stat_arch_elt, (abfd, buf))
|
||||
|
||||
#define bfd_find_nearest_line(abfd, section, symbols, offset,filename_ptr, func, line_ptr) \
|
||||
BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, section,symbols, offset, filename_ptr, func, line_ptr))
|
||||
|
||||
|
||||
/* Some byte-swapping i/o operations */
|
||||
#define LONG_SIZE 4
|
||||
#define SHORT_SIZE 2
|
||||
#define BYTE_SIZE 1
|
||||
#define bfd_putchar(abfd, val, ptr) (*((char *)ptr) = (char)val)
|
||||
#define bfd_getchar(abfd, ptr) (*((char *)ptr))
|
||||
|
||||
#define bfd_putlong(abfd, val, ptr) BFD_SEND(abfd, bfd_putxlong, (val,ptr))
|
||||
#define bfd_getlong(abfd, ptr) BFD_SEND(abfd, bfd_getxlong, (ptr))
|
||||
|
||||
#define bfd_putshort(abfd, val, ptr) BFD_SEND(abfd, bfd_putxshort, (val,ptr))
|
||||
#define bfd_getshort(abfd, ptr) BFD_SEND(abfd, bfd_getxshort, (ptr))
|
||||
|
||||
#define bfd_h_putchar(abfd, val, ptr) bfd_putchar (abfd, val, ptr)
|
||||
#define bfd_h_getchar(abfd, ptr) bfd_getchar (abfd, ptr)
|
||||
|
||||
#define bfd_h_putlong(abfd, val, ptr) BFD_SEND(abfd, bfd_h_putxlong, (val, (bfd_byte *) ptr))
|
||||
#define bfd_h_getlong(abfd, ptr) BFD_SEND(abfd, bfd_h_getxlong, ((bfd_byte *) ptr))
|
||||
|
||||
#define bfd_h_putshort(abfd, val, ptr) BFD_SEND(abfd, bfd_h_putxshort,(val,ptr))
|
||||
#define bfd_h_getshort(abfd, ptr) BFD_SEND(abfd, bfd_h_getxshort,(ptr))
|
||||
|
||||
/* General purpose one fits all. The do { } while (0) makes a single
|
||||
statement out of it, for use in things like nested if-statements.
|
||||
|
||||
USE OF THESE MACROS IS DISCOURAGED. THEY ASSUME THAT THE HOST AND
|
||||
TARGET FIELD ALIGNMENT AND SIZES ARE THE SAME. TARGET STRUCTS SHOULD
|
||||
BE MODELED AS BYTE ARRAYS INSTEAD, TO AVOID THESE ASSUMPTIONS. */
|
||||
|
||||
#define bfd_h_put_x(abfd, val, ptr) \
|
||||
do { \
|
||||
if (sizeof(*(ptr)) == LONG_SIZE) \
|
||||
bfd_h_putlong (abfd, val, (bfd_byte*)(ptr));\
|
||||
else if (sizeof(*(ptr)) == SHORT_SIZE) \
|
||||
bfd_h_putshort (abfd, val, (bfd_byte *)(ptr));\
|
||||
else if (sizeof(*(ptr)) == BYTE_SIZE) \
|
||||
bfd_h_putchar (abfd, val, (bfd_byte *)(ptr));\
|
||||
else abort(); } while (0)
|
||||
|
||||
#define bfd_h_get_x(abfd, ptr) \
|
||||
((sizeof(*(ptr))==LONG_SIZE) ? bfd_h_getlong (abfd, (bfd_byte *)(ptr)):\
|
||||
(sizeof(*(ptr))==SHORT_SIZE) ? bfd_h_getshort(abfd, (bfd_byte *)(ptr)):\
|
||||
(sizeof(*(ptr))==BYTE_SIZE) ? bfd_h_getchar (abfd, (bfd_byte *)(ptr)):\
|
||||
(abort(),1) )
|
||||
|
||||
#ifdef GNU960
|
||||
|
||||
#define BFD_COFF_FORMAT bfd_target_coff_flavour_enum
|
||||
#define BFD_BOUT_FORMAT bfd_target_aout_flavour_enum
|
||||
|
||||
/*
|
||||
* Return nonzero iff specified bfd is for big-endian target
|
||||
*/
|
||||
#define BFD_BIG_ENDIAN_FILE_P(abfd) \
|
||||
((abfd)->xvec->header_byteorder_big_p == true)
|
||||
|
||||
/*
|
||||
* Return nonzero iff specified bfd is for coff target
|
||||
*/
|
||||
#define BFD_COFF_FILE_P(abfd) ((abfd)->xvec->flavour == BFD_COFF_FORMAT)
|
||||
|
||||
/*
|
||||
* The names of the only targets the GNU/960 release cares about
|
||||
*/
|
||||
#define BFD_BIG_COFF_TARG "coff-Intel-big"
|
||||
#define BFD_LITTLE_COFF_TARG "coff-Intel-little"
|
||||
#define BFD_BIG_BOUT_TARG "b.out.big"
|
||||
#define BFD_LITTLE_BOUT_TARG "b.out.little"
|
||||
|
||||
extern PROTO (char *, bfd_make_targ_name,( enum target_flavour_enum format, int bigendian));
|
||||
|
||||
#endif /* GNU960 */
|
||||
|
||||
#endif /* __BFD_H_SEEN__ */
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
/* $Id$
|
||||
*
|
||||
* This file is a modified version of 'a.out.h'. It is to be used in all
|
||||
* GNU tools modified to support the i80960 (or tools that operate on
|
||||
* object files created by such tools).
|
||||
*
|
||||
* All i80960 development is done in a CROSS-DEVELOPMENT environment. I.e.,
|
||||
* object code is generated on, and executed under the direction of a symbolic
|
||||
* debugger running on, a host system. We do not want to be subject to the
|
||||
* vagaries of which host it is or whether it supports COFF or a.out format,
|
||||
* or anything else. We DO want to:
|
||||
*
|
||||
* o always generate the same format object files, regardless of host.
|
||||
*
|
||||
* o have an 'a.out' header that we can modify for our own purposes
|
||||
* (the 80960 is typically an embedded processor and may require
|
||||
* enhanced linker support that the normal a.out.h header can't
|
||||
* accommodate).
|
||||
*
|
||||
* As for byte-ordering, the following rules apply:
|
||||
*
|
||||
* o Text and data that is actually downloaded to the target is always
|
||||
* in i80960 (little-endian) order.
|
||||
*
|
||||
* o All other numbers (in the header, symbols, relocation directives)
|
||||
* are in host byte-order: object files CANNOT be lifted from a
|
||||
* little-end host and used on a big-endian (or vice versa) without
|
||||
* modification.
|
||||
* ==> THIS IS NO LONGER TRUE USING BFD. WE CAN GENERATE ANY BYTE ORDER
|
||||
* FOR THE HEADER, AND READ ANY BYTE ORDER. PREFERENCE WOULD BE TO
|
||||
* USE LITTLE-ENDIAN BYTE ORDER THROUGHOUT, REGARDLESS OF HOST. <==
|
||||
*
|
||||
* o The downloader ('comm960') takes care to generate a pseudo-header
|
||||
* with correct (i80960) byte-ordering before shipping text and data
|
||||
* off to the NINDY monitor in the target systems. Symbols and
|
||||
* relocation info are never sent to the target.
|
||||
*/
|
||||
|
||||
|
||||
#define BMAGIC 0415
|
||||
/* We don't accept the following (see N_BADMAG macro).
|
||||
* They're just here so GNU code will compile.
|
||||
*/
|
||||
#define OMAGIC 0407 /* old impure format */
|
||||
#define NMAGIC 0410 /* read-only text */
|
||||
#define ZMAGIC 0413 /* demand load format */
|
||||
|
||||
/* FILE HEADER
|
||||
* All 'lengths' are given as a number of bytes.
|
||||
* All 'alignments' are for relinkable files only; an alignment of
|
||||
* 'n' indicates the corresponding segment must begin at an
|
||||
* address that is a multiple of (2**n).
|
||||
*/
|
||||
struct exec {
|
||||
/* Standard stuff */
|
||||
unsigned long a_magic; /* Identifies this as a b.out file */
|
||||
unsigned long a_text; /* Length of text */
|
||||
unsigned long a_data; /* Length of data */
|
||||
unsigned long a_bss; /* Length of runtime uninitialized data area */
|
||||
unsigned long a_syms; /* Length of symbol table */
|
||||
unsigned long a_entry; /* Runtime start address */
|
||||
unsigned long a_trsize; /* Length of text relocation info */
|
||||
unsigned long a_drsize; /* Length of data relocation info */
|
||||
|
||||
/* Added for i960 */
|
||||
unsigned long a_tload; /* Text runtime load address */
|
||||
unsigned long a_dload; /* Data runtime load address */
|
||||
unsigned char a_talign; /* Alignment of text segment */
|
||||
unsigned char a_dalign; /* Alignment of data segment */
|
||||
unsigned char a_balign; /* Alignment of bss segment */
|
||||
unsigned char unused; /* (Just to make struct size a multiple of 4) */
|
||||
};
|
||||
|
||||
#define N_BADMAG(x) (((x).a_magic)!=BMAGIC)
|
||||
#define N_TXTOFF(x) ( sizeof(struct exec) )
|
||||
#define N_DATOFF(x) ( N_TXTOFF(x) + (x).a_text )
|
||||
#define N_TROFF(x) ( N_DATOFF(x) + (x).a_data )
|
||||
#define N_DROFF(x) ( N_TROFF(x) + (x).a_trsize )
|
||||
#define N_SYMOFF(x) ( N_DROFF(x) + (x).a_drsize )
|
||||
#define N_STROFF(x) ( N_SYMOFF(x) + (x).a_syms )
|
||||
|
||||
/* A single entry in the symbol table
|
||||
*/
|
||||
struct nlist {
|
||||
union {
|
||||
char *n_name;
|
||||
struct nlist *n_next;
|
||||
long n_strx; /* Index into string table */
|
||||
} n_un;
|
||||
unsigned char n_type; /* See below */
|
||||
char n_other; /* Used in i80960 support -- see below */
|
||||
short n_desc;
|
||||
unsigned long n_value;
|
||||
};
|
||||
|
||||
|
||||
/* Legal values of n_type
|
||||
*/
|
||||
#define N_UNDF 0 /* Undefined symbol */
|
||||
#define N_ABS 2 /* Absolute symbol */
|
||||
#define N_TEXT 4 /* Text symbol */
|
||||
#define N_DATA 6 /* Data symbol */
|
||||
#define N_BSS 8 /* BSS symbol */
|
||||
#define N_FN 31 /* Filename symbol */
|
||||
|
||||
#define N_EXT 1 /* External symbol (OR'd in with one of above) */
|
||||
#define N_TYPE 036 /* Mask for all the type bits */
|
||||
#define N_STAB 0340 /* Mask for all bits used for SDB entries */
|
||||
|
||||
/* MEANING OF 'n_other'
|
||||
*
|
||||
* If non-zero, the 'n_other' fields indicates either a leaf procedure or
|
||||
* a system procedure, as follows:
|
||||
*
|
||||
* 1 <= n_other <= 32 :
|
||||
* The symbol is the entry point to a system procedure.
|
||||
* 'n_value' is the address of the entry, as for any other
|
||||
* procedure. The system procedure number (which can be used in
|
||||
* a 'calls' instruction) is (n_other-1). These entries come from
|
||||
* '.sysproc' directives.
|
||||
*
|
||||
* n_other == N_CALLNAME
|
||||
* the symbol is the 'call' entry point to a leaf procedure.
|
||||
* The *next* symbol in the symbol table must be the corresponding
|
||||
* 'bal' entry point to the procedure (see following). These
|
||||
* entries come from '.leafproc' directives in which two different
|
||||
* symbols are specified (the first one is represented here).
|
||||
*
|
||||
*
|
||||
* n_other == N_BALNAME
|
||||
* the symbol is the 'bal' entry point to a leaf procedure.
|
||||
* These entries result from '.leafproc' directives in which only
|
||||
* one symbol is specified, or in which the same symbol is
|
||||
* specified twice.
|
||||
*
|
||||
* Note that an N_CALLNAME entry *must* have a corresponding N_BALNAME entry,
|
||||
* but not every N_BALNAME entry must have an N_CALLNAME entry.
|
||||
*/
|
||||
#define N_CALLNAME (-1)
|
||||
#define N_BALNAME (-2)
|
||||
#define IS_CALLNAME(x) (N_CALLNAME == (int)(x))
|
||||
#define IS_BALNAME(x) (N_BALNAME == (int)(x))
|
||||
#define IS_OTHER(x) ((x)>0 && (x) <=32)
|
||||
|
||||
struct relocation_info {
|
||||
int r_address; /* File address of item to be relocated */
|
||||
unsigned
|
||||
r_symbolnum:24,/* Index of symbol on which relocation is based,
|
||||
* if r_extern is set. Otherwise set to
|
||||
* either N_TEXT, N_DATA, or N_BSS to
|
||||
* indicate section on which relocation is
|
||||
* based.
|
||||
*/
|
||||
r_pcrel:1, /* 1 => relocate PC-relative; else absolute
|
||||
* On i960, pc-relative implies 24-bit
|
||||
* address, absolute implies 32-bit.
|
||||
*/
|
||||
r_length:2, /* Number of bytes to relocate:
|
||||
* 0 => 1 byte
|
||||
* 1 => 2 bytes
|
||||
* 2 => 4 bytes -- only value used for i960
|
||||
*/
|
||||
r_extern:1,
|
||||
r_bsr:1, /* Something for the GNU NS32K assembler */
|
||||
r_disp:1, /* Something for the GNU NS32K assembler */
|
||||
r_callj:1, /* 1 if relocation target is an i960 'callj' */
|
||||
nuthin:1; /* Unused */
|
||||
};
|
||||
|
|
@ -0,0 +1,414 @@
|
|||
/*** coff information for 80960. Origins: Intel corp, natch. */
|
||||
|
||||
/* NOTE: Tagentries (cf TAGBITS) are not used by the 960 */
|
||||
|
||||
/********************** FILE HEADER **********************/
|
||||
|
||||
struct filehdr {
|
||||
unsigned short f_magic; /* magic number */
|
||||
unsigned short f_nscns; /* number of sections */
|
||||
long f_timdat; /* time & date stamp */
|
||||
long f_symptr; /* file pointer to symtab */
|
||||
long f_nsyms; /* number of symtab entries */
|
||||
unsigned short f_opthdr; /* sizeof(optional hdr) */
|
||||
unsigned short f_flags; /* flags */
|
||||
};
|
||||
|
||||
/* Bits for f_flags:
|
||||
* F_RELFLG relocation info stripped from file
|
||||
* F_EXEC file is executable (no unresolved external references)
|
||||
* F_LNNO line numbers stripped from file
|
||||
* F_LSYMS local symbols stripped from file
|
||||
* F_AR32WR file has byte ordering of an AR32WR machine (e.g. vax)
|
||||
*/
|
||||
|
||||
#define F_RELFLG (0x0001)
|
||||
#define F_EXEC (0x0002)
|
||||
#define F_LNNO (0x0004)
|
||||
#define F_LSYMS (0x0008)
|
||||
#define F_AR32WR (0x0010)
|
||||
|
||||
/*
|
||||
* Intel 80960 (I960) processor flags.
|
||||
* F_I960TYPE == mask for processor type field.
|
||||
*/
|
||||
|
||||
#define F_I960TYPE (0xf000)
|
||||
#define F_I960CORE (0x1000)
|
||||
#define F_I960KB (0x2000)
|
||||
#define F_I960SB (0x2000)
|
||||
#define F_I960MC (0x3000)
|
||||
#define F_I960XA (0x4000)
|
||||
#define F_I960CA (0x5000)
|
||||
#define F_I960KA (0x6000)
|
||||
#define F_I960SA (0x6000)
|
||||
|
||||
/*
|
||||
* i80960 Magic Numbers
|
||||
*/
|
||||
|
||||
#define I960ROMAGIC (0x160) /* read-only text segments */
|
||||
#define I960RWMAGIC (0x161) /* read-write text segments */
|
||||
|
||||
#define I960BADMAG(x) (((x).f_magic!=I960ROMAGIC) && ((x).f_magic!=I960RWMAGIC))
|
||||
|
||||
#define FILHDR struct filehdr
|
||||
#define FILHSZ sizeof(FILHDR)
|
||||
|
||||
|
||||
/********************** AOUT "OPTIONAL HEADER" **********************/
|
||||
|
||||
typedef struct {
|
||||
unsigned long phys_addr;
|
||||
unsigned long bitarray;
|
||||
} TAGBITS;
|
||||
|
||||
|
||||
/* These appear to be used only by exec(2). I don't know who cares
|
||||
about them in a cross development environment. In any case, this
|
||||
is my collection after researching the issue for a few hours.
|
||||
Apparently, most have these have remained essentially unchanged
|
||||
since v7 days, although a few new ones have been added. xoxorich.
|
||||
Could we have a little more teleology please? -- Gumby */
|
||||
|
||||
#define BAD0MAGIC (0401) /* (?) "lpd (UNIX/RT)" */
|
||||
#define BAD1MAGIC (0405) /* (?) overlay */
|
||||
#define OMAGIC (0407) /* old impure format. data immediately
|
||||
follows text. both sections are rw. */
|
||||
#define NMAGIC (0410) /* split i&d, read-only text */
|
||||
#define A_MAGIC3 (0411) /* (?) "separated I&D" */
|
||||
#define ZMAGIC (0413) /* like NMAGIC, but demand loaded */
|
||||
#define PAGEMAGIC2 (0414) /* (?) like ZMAGIC, but address zero
|
||||
explicitly unmapped. */ /* */
|
||||
#define REGMAGIC (0414) /* (?) a PAGEMAGIC2 alias? */
|
||||
#define PAGEMAGIC3 (0415) /* (?) like ZMAGIC, but address zero mapped. */
|
||||
#define A_MAGIC5 (0437) /* (?) "system overlay, separated I&D" */
|
||||
#define SASMAGIC (010000) /* (?) "Single Address Space" */
|
||||
#define MASMAGIC (020000) /* (?) "Multiple (separate I/D) Addr. Spaces" */
|
||||
typedef struct aouthdr {
|
||||
short magic; /* type of file */
|
||||
short vstamp; /* version stamp */
|
||||
unsigned long tsize; /* text size in bytes, padded to FW bdry*/
|
||||
unsigned long dsize; /* initialized data " " */
|
||||
unsigned long bsize; /* uninitialized data " " */
|
||||
#if U3B
|
||||
unsigned long dum1;
|
||||
unsigned long dum2; /* pad to entry point */
|
||||
#endif
|
||||
unsigned long entry; /* entry pt. */
|
||||
unsigned long text_start; /* base of text used for this file */
|
||||
unsigned long data_start; /* base of data used for this file */
|
||||
unsigned long tagentries; /* number of tag entries to follow */
|
||||
} AOUTHDR;
|
||||
|
||||
/* return a pointer to the tag bits array */
|
||||
|
||||
#define TAGPTR(aout) ((TAGBITS *) (&(aout.tagentries)+1))
|
||||
|
||||
/* compute size of a header */
|
||||
|
||||
/*#define AOUTSZ(aout) (sizeof(AOUTHDR)+(aout.tagentries*sizeof(TAGBITS)))*/
|
||||
#define AOUTSZ (sizeof(AOUTHDR))
|
||||
|
||||
|
||||
/********************** STORAGE CLASSES **********************/
|
||||
|
||||
#define C_EFCN -1 /* physical end of function */
|
||||
#define C_NULL 0
|
||||
#define C_AUTO 1 /* automatic variable */
|
||||
#define C_EXT 2 /* external symbol */
|
||||
#define C_STAT 3 /* static */
|
||||
#define C_REG 4 /* register variable */
|
||||
#define C_EXTDEF 5 /* external definition */
|
||||
#define C_LABEL 6 /* label */
|
||||
#define C_ULABEL 7 /* undefined label */
|
||||
#define C_MOS 8 /* member of structure */
|
||||
#define C_ARG 9 /* function argument */
|
||||
#define C_STRTAG 10 /* structure tag */
|
||||
#define C_MOU 11 /* member of union */
|
||||
#define C_UNTAG 12 /* union tag */
|
||||
#define C_TPDEF 13 /* type definition */
|
||||
#define C_USTATIC 14 /* undefined static */
|
||||
#define C_ENTAG 15 /* enumeration tag */
|
||||
#define C_MOE 16 /* member of enumeration */
|
||||
#define C_REGPARM 17 /* register parameter */
|
||||
#define C_FIELD 18 /* bit field */
|
||||
/* #define C_REGARG 19 */ /* My guess - but Intel specific*/
|
||||
#define C_AUTOARG 19 /* auto argument */
|
||||
#define C_LASTENT 20 /* dummy entry (end of block) */
|
||||
#define C_BLOCK 100 /* ".bb" or ".eb" */
|
||||
#define C_FCN 101 /* ".bf" or ".ef" */
|
||||
#define C_EOS 102 /* end of structure */
|
||||
#define C_FILE 103 /* file name */
|
||||
#define C_LINE 104 /* line # reformatted as symbol table entry */
|
||||
#define C_ALIAS 105 /* duplicate tag */
|
||||
#define C_HIDDEN 106 /* ext symbol in dmert public lib */
|
||||
|
||||
/* New storage classes for 80960 */
|
||||
|
||||
/* C_LEAFPROC is obsolete. Use C_LEAFEXT or C_LEAFSTAT */
|
||||
#define C_LEAFPROC 108 /* Leaf procedure, "call" via BAL */
|
||||
|
||||
#define C_SCALL 107 /* Procedure reachable via system call */
|
||||
#define C_LEAFEXT 108 /* External leaf */
|
||||
#define C_LEAFSTAT 113 /* Static leaf */
|
||||
#define C_OPTVAR 109 /* Optimized variable */
|
||||
#define C_DEFINE 110 /* Preprocessor #define */
|
||||
#define C_PRAGMA 111 /* Advice to compiler or linker */
|
||||
#define C_SEGMENT 112 /* 80960 segment name */
|
||||
|
||||
/********************** SECTION HEADER **********************/
|
||||
|
||||
struct scnhdr {
|
||||
char s_name[8]; /* section name */
|
||||
long s_paddr; /* physical address, aliased s_nlib */
|
||||
long s_vaddr; /* virtual address */
|
||||
long s_size; /* section size */
|
||||
long s_scnptr; /* file ptr to raw data for section */
|
||||
long s_relptr; /* file ptr to relocation */
|
||||
long s_lnnoptr; /* file ptr to line numbers */
|
||||
unsigned short s_nreloc; /* number of relocation entries */
|
||||
unsigned short s_nlnno; /* number of line number entries*/
|
||||
long s_flags; /* flags */
|
||||
unsigned long s_align; /* section alignment */
|
||||
};
|
||||
|
||||
/*
|
||||
* names of "special" sections
|
||||
*/
|
||||
#define _TEXT ".text"
|
||||
#define _DATA ".data"
|
||||
#define _BSS ".bss"
|
||||
|
||||
/*
|
||||
* s_flags "type"
|
||||
*/
|
||||
#define STYP_REG (0x0000) /* "regular": allocated, relocated, loaded */
|
||||
#define STYP_DSECT (0x0001) /* "dummy": relocated only*/
|
||||
#define STYP_NOLOAD (0x0002) /* "noload": allocated, relocated, not loaded */
|
||||
#define STYP_GROUP (0x0004) /* "grouped": formed of input sections */
|
||||
#define STYP_PAD (0x0008) /* "padding": not allocated, not relocated, loaded */
|
||||
#define STYP_COPY (0x0010) /* "copy": for decision function used by field update; not allocated, not relocated,
|
||||
loaded; reloc & lineno entries processed normally */
|
||||
#define STYP_TEXT (0x0020) /* section contains text only */
|
||||
#define S_SHRSEG (0x0020) /* In 3b Update files (output of ogen), sections which appear in SHARED segments of the Pfile
|
||||
will have the S_SHRSEG flag set by ogen, to inform dufr that updating 1 copy of the proc. will
|
||||
update all process invocations. */
|
||||
#define STYP_DATA (0x0040) /* section contains data only */
|
||||
#define STYP_BSS (0x0080) /* section contains bss only */
|
||||
#define S_NEWFCN (0x0100) /* In a minimal file or an update file, a new function (as compared with a replaced function) */
|
||||
#define STYP_INFO (0x0200) /* comment: not allocated not relocated, not loaded */
|
||||
#define STYP_OVER (0x0400) /* overlay: relocated not allocated or loaded */
|
||||
#define STYP_LIB (0x0800) /* for .lib: same as INFO */
|
||||
#define STYP_MERGE (0x2000) /* merge section -- combines with text, data or bss sections only */
|
||||
#define STYP_REVERSE_PAD (0x4000) /* section will be padded with no-op instructions wherever padding is necessary and there is a
|
||||
word of contiguous bytes beginning on a word boundary. */
|
||||
|
||||
#define SCNHDR struct scnhdr
|
||||
#define SCNHSZ sizeof(SCNHDR)
|
||||
|
||||
|
||||
/********************** LINE NUMBERS **********************/
|
||||
|
||||
/* 1 line number entry for every "breakpointable" source line in a section.
|
||||
* Line numbers are grouped on a per function basis; first entry in a function
|
||||
* grouping will have l_lnno = 0 and in place of physical address will be the
|
||||
* symbol table index of the function name.
|
||||
*/
|
||||
struct lineno {
|
||||
union {
|
||||
long l_symndx; /* function name symbol index, iff l_lnno == 0*/
|
||||
long l_paddr; /* (physical) address of line number */
|
||||
} l_addr;
|
||||
unsigned short l_lnno; /* line number */
|
||||
char padding[2]; /* force alignment */
|
||||
};
|
||||
|
||||
#define LINENO struct lineno
|
||||
#define LINESZ sizeof(LINENO)
|
||||
|
||||
|
||||
/********************** SYMBOLS **********************/
|
||||
|
||||
#define SYMNMLEN 8 /* # characters in a symbol name */
|
||||
#define FILNMLEN 14 /* # characters in a file name */
|
||||
#define DIMNUM 4 /* # array dimensions in auxiliary entry */
|
||||
|
||||
struct syment {
|
||||
union {
|
||||
char _n_name[SYMNMLEN]; /* old COFF version */
|
||||
struct {
|
||||
long _n_zeroes; /* new == 0 */
|
||||
long _n_offset; /* offset into string table */
|
||||
} _n_n;
|
||||
char *_n_nptr[2]; /* allows for overlaying */
|
||||
} _n;
|
||||
long n_value; /* value of symbol */
|
||||
short n_scnum; /* section number */
|
||||
unsigned short n_flags; /* copy of flags from filhdr */
|
||||
unsigned long n_type; /* type and derived type */
|
||||
char n_sclass; /* storage class */
|
||||
char n_numaux; /* number of aux. entries */
|
||||
char pad2[2]; /* force alignment */
|
||||
};
|
||||
|
||||
#define n_name _n._n_name
|
||||
#define n_ptr _n._n_nptr[1]
|
||||
#define n_zeroes _n._n_n._n_zeroes
|
||||
#define n_offset _n._n_n._n_offset
|
||||
|
||||
/*
|
||||
* Relocatable symbols have number of the section in which they are defined,
|
||||
* or one of the following:
|
||||
*/
|
||||
#define N_UNDEF ((short)0) /* undefined symbol */
|
||||
#define N_ABS ((short)-1) /* value of symbol is absolute */
|
||||
#define N_DEBUG ((short)-2) /* debugging symbol -- value is meaningless */
|
||||
#define N_TV ((short)-3) /* indicates symbol needs preload transfer vector */
|
||||
#define P_TV ((short)-4) /* indicates symbol needs postload transfer vector*/
|
||||
|
||||
/*
|
||||
* Type of a symbol, in low 4 bits of the word
|
||||
*/
|
||||
#define T_NULL 0
|
||||
#define T_VOID 1 /* function argument (only used by compiler) */
|
||||
#define T_CHAR 2 /* character */
|
||||
#define T_SHORT 3 /* short integer */
|
||||
#define T_INT 4 /* integer */
|
||||
#define T_LONG 5 /* long integer */
|
||||
#define T_FLOAT 6 /* floating point */
|
||||
#define T_DOUBLE 7 /* double word */
|
||||
#define T_STRUCT 8 /* structure */
|
||||
#define T_UNION 9 /* union */
|
||||
#define T_ENUM 10 /* enumeration */
|
||||
#define T_MOE 11 /* member of enumeration*/
|
||||
#define T_UCHAR 12 /* unsigned character */
|
||||
#define T_USHORT 13 /* unsigned short */
|
||||
#define T_UINT 14 /* unsigned integer */
|
||||
#define T_ULONG 15 /* unsigned long */
|
||||
#define T_LNGDBL 16 /* long double */
|
||||
|
||||
/*
|
||||
* derived types, in n_type
|
||||
*/
|
||||
#define DT_NON (0) /* no derived type */
|
||||
#define DT_PTR (1) /* pointer */
|
||||
#define DT_FCN (2) /* function */
|
||||
#define DT_ARY (3) /* array */
|
||||
|
||||
#define N_BTMASK (0x1f)
|
||||
#define N_TMASK (0x60)
|
||||
#define N_BTSHFT (5)
|
||||
#define N_TSHIFT (2)
|
||||
|
||||
#define BTYPE(x) ((x) & N_BTMASK)
|
||||
|
||||
#define ISPTR(x) (((x) & N_TMASK) == (DT_PTR << N_BTSHFT))
|
||||
#define ISFCN(x) (((x) & N_TMASK) == (DT_FCN << N_BTSHFT))
|
||||
#define ISARY(x) (((x) & N_TMASK) == (DT_ARY << N_BTSHFT))
|
||||
|
||||
#define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
|
||||
|
||||
union auxent {
|
||||
struct {
|
||||
long x_tagndx; /* str, un, or enum tag indx */
|
||||
union {
|
||||
struct {
|
||||
unsigned short x_lnno; /* declaration line number */
|
||||
unsigned short x_size; /* str/union/array size */
|
||||
} x_lnsz;
|
||||
long x_fsize; /* size of function */
|
||||
} x_misc;
|
||||
union {
|
||||
struct { /* if ISFCN, tag, or .bb */
|
||||
long x_lnnoptr; /* ptr to fcn line # */
|
||||
long x_endndx; /* entry ndx past block end */
|
||||
} x_fcn;
|
||||
struct { /* if ISARY, up to 4 dimen. */
|
||||
unsigned short x_dimen[DIMNUM];
|
||||
} x_ary;
|
||||
} x_fcnary;
|
||||
unsigned short x_tvndx; /* tv index */
|
||||
} x_sym;
|
||||
|
||||
union {
|
||||
char x_fname[FILNMLEN];
|
||||
struct {
|
||||
long x_zeroes;
|
||||
long x_offset;
|
||||
} x_n;
|
||||
} x_file;
|
||||
|
||||
struct {
|
||||
long x_scnlen; /* section length */
|
||||
unsigned short x_nreloc; /* # relocation entries */
|
||||
unsigned short x_nlinno; /* # line numbers */
|
||||
} x_scn;
|
||||
|
||||
struct {
|
||||
long x_tvfill; /* tv fill value */
|
||||
unsigned short x_tvlen; /* length of .tv */
|
||||
unsigned short x_tvran[2]; /* tv range */
|
||||
} x_tv; /* info about .tv section (in auxent of symbol .tv)) */
|
||||
|
||||
/******************************************
|
||||
* I960-specific *2nd* aux. entry formats
|
||||
******************************************/
|
||||
struct {
|
||||
/* This is a very old typo that keeps getting propagated. */
|
||||
#define x_stdindx x_stindx
|
||||
long x_stindx; /* sys. table entry */
|
||||
} x_sc; /* system call entry */
|
||||
|
||||
struct {
|
||||
unsigned long x_balntry; /* BAL entry point */
|
||||
} x_bal; /* BAL-callable function */
|
||||
|
||||
struct {
|
||||
unsigned long x_timestamp; /* time stamp */
|
||||
char x_idstring[20]; /* producer identity string */
|
||||
} x_ident; /* Producer ident info */
|
||||
|
||||
char a[sizeof(struct syment)]; /* force auxent/syment sizes to match */
|
||||
};
|
||||
|
||||
#define SYMENT struct syment
|
||||
#define SYMESZ sizeof(SYMENT)
|
||||
#define AUXENT union auxent
|
||||
#define AUXESZ sizeof(AUXENT)
|
||||
|
||||
#if VAX || I960
|
||||
# define _ETEXT "_etext"
|
||||
#else
|
||||
# define _ETEXT "etext"
|
||||
#endif
|
||||
|
||||
/********************** RELOCATION DIRECTIVES **********************/
|
||||
|
||||
struct reloc {
|
||||
long r_vaddr; /* Virtual address of reference */
|
||||
long r_symndx; /* Index into symbol table */
|
||||
unsigned short r_type; /* Relocation type */
|
||||
char pad[2]; /* Unused */
|
||||
};
|
||||
|
||||
/* Relevent values for r_type and i960. Would someone please document them */
|
||||
|
||||
#define R_RELLONG (0x11) /* Direct 32-bit relocation */
|
||||
#define R_IPRSHORT (0x18)
|
||||
#define R_IPRMED (0x19) /* 24-bit ip-relative relocation */
|
||||
#define R_IPRLONG (0x1a)
|
||||
#define R_OPTCALL (0x1b) /* 32-bit optimizable call (leafproc/sysproc) */
|
||||
#define R_OPTCALLX (0x1c) /* 64-bit optimizable call (leafproc/sysproc) */
|
||||
#define R_GETSEG (0x1d)
|
||||
#define R_GETPA (0x1e)
|
||||
#define R_TAGWORD (0x1f)
|
||||
|
||||
#define RELOC struct reloc
|
||||
#define RELSZ sizeof(RELOC)
|
||||
|
||||
#define DEFAULT_DATA_SECTION_ALIGNMENT 4
|
||||
#define DEFAULT_BSS_SECTION_ALIGNMENT 4
|
||||
#define DEFAULT_TEXT_SECTION_ALIGNMENT 16
|
||||
/* For new sections we havn't heard of before */
|
||||
#define DEFAULT_SECTION_ALIGNMENT 4
|
||||
|
|
@ -0,0 +1,298 @@
|
|||
/*** coff information for 88k bcs */
|
||||
|
||||
/********************** FILE HEADER **********************/
|
||||
|
||||
struct filehdr {
|
||||
unsigned short f_magic; /* magic number */
|
||||
unsigned short f_nscns; /* number of sections */
|
||||
long f_timdat; /* time & date stamp */
|
||||
long f_symptr; /* file pointer to symtab */
|
||||
long f_nsyms; /* number of symtab entries */
|
||||
unsigned short f_opthdr; /* sizeof(optional hdr) */
|
||||
unsigned short f_flags; /* flags */
|
||||
};
|
||||
|
||||
/* Bits for f_flags:
|
||||
* F_RELFLG relocation info stripped from file
|
||||
* F_EXEC file is executable (no unresolved externel references)
|
||||
* F_LNNO line nunbers stripped from file
|
||||
* F_LSYMS local symbols stripped from file
|
||||
* F_AR32WR file has byte ordering of an AR32WR machine (e.g. vax)
|
||||
*/
|
||||
#define F_RELFLG 0000001
|
||||
#define F_EXEC 0000002
|
||||
#define F_LNNO 0000004
|
||||
#define F_LSYMS 0000010
|
||||
#define F_AR32WR 0x100
|
||||
#define F_AR32W 0x200
|
||||
|
||||
#define MC88MAGIC 0540 /* 88k BCS executable */
|
||||
#define MC88DMAGIC 0541 /* DG/UX executable */
|
||||
#define MC88OMAGIC 0555 /* Object file */
|
||||
|
||||
#define MC88BADMAG(x) (((x).f_magic!=MC88MAGIC) &&((x).f_magic!=MC88DMAGIC) && ((x).f_magic != MC88OMAGIC))
|
||||
|
||||
#define FILHDR struct filehdr
|
||||
#define FILHSZ sizeof(FILHDR)
|
||||
|
||||
|
||||
/********************** AOUT "OPTIONAL HEADER" **********************/
|
||||
|
||||
|
||||
#define PAGEMAGIC3 0414 /* Split i&d, zero mapped */
|
||||
#define PAGEMAGICBCS 0413
|
||||
|
||||
typedef struct aouthdr {
|
||||
short magic; /* type of file */
|
||||
short vstamp; /* version stamp */
|
||||
unsigned long tsize; /* text size in bytes, padded to FW bdry*/
|
||||
unsigned long dsize; /* initialized data " " */
|
||||
unsigned long bsize; /* uninitialized data " " */
|
||||
|
||||
unsigned long entry; /* entry pt. */
|
||||
unsigned long text_start; /* base of text used for this file */
|
||||
unsigned long data_start; /* base of data used for this file */
|
||||
|
||||
} AOUTHDR;
|
||||
|
||||
|
||||
/* compute size of a header */
|
||||
|
||||
#define AOUTSZ (sizeof(AOUTHDR))
|
||||
|
||||
/********************** STORAGE CLASSES **********************/
|
||||
|
||||
#define C_EFCN -1 /* physical end of function */
|
||||
#define C_NULL 0
|
||||
#define C_AUTO 1 /* automatic variable */
|
||||
#define C_EXT 2 /* external symbol */
|
||||
#define C_STAT 3 /* static */
|
||||
#define C_REG 4 /* register variable */
|
||||
#define C_EXTDEF 5 /* external definition */
|
||||
#define C_LABEL 6 /* label */
|
||||
#define C_ULABEL 7 /* undefined label */
|
||||
#define C_MOS 8 /* member of structure */
|
||||
#define C_ARG 9 /* function argument */
|
||||
#define C_STRTAG 10 /* structure tag */
|
||||
#define C_MOU 11 /* member of union */
|
||||
#define C_UNTAG 12 /* union tag */
|
||||
#define C_TPDEF 13 /* type definition */
|
||||
#define C_USTATIC 14 /* undefined static */
|
||||
#define C_ENTAG 15 /* enumeration tag */
|
||||
#define C_MOE 16 /* member of enumeration */
|
||||
#define C_REGPARM 17 /* register parameter */
|
||||
#define C_FIELD 18 /* bit field */
|
||||
#define C_BLOCK 100 /* ".bb" or ".eb" */
|
||||
#define C_FCN 101 /* ".bf" or ".ef" */
|
||||
#define C_EOS 102 /* end of structure */
|
||||
#define C_FILE 103 /* file name */
|
||||
#define C_LINE 104 /* line # reformatted as symbol table entry */
|
||||
#define C_ALIAS 105 /* duplicate tag */
|
||||
#define C_HIDDEN 106 /* ext symbol in dmert public lib */
|
||||
#define C_SHADOW 107 /* shadow symbol */
|
||||
#define C_VERSION 108 /* coff version symbol */
|
||||
|
||||
|
||||
/********************** SECTION HEADER **********************/
|
||||
|
||||
struct scnhdr {
|
||||
char s_name[8]; /* section name */
|
||||
long s_paddr; /* physical address, aliased s_nlib */
|
||||
long s_vaddr; /* virtual address */
|
||||
long s_size; /* section size */
|
||||
long s_scnptr; /* file ptr to raw data for section */
|
||||
long s_relptr; /* file ptr to relocation */
|
||||
long s_lnnoptr; /* file ptr to line numbers */
|
||||
long s_nreloc; /* number of relocation entries */
|
||||
long s_nlnno; /* number of line number entries*/
|
||||
long s_flags; /* flags */
|
||||
};
|
||||
|
||||
/*
|
||||
* names of "special" sections
|
||||
*/
|
||||
#define _TEXT ".text"
|
||||
#define _DATA ".data"
|
||||
#define _BSS ".bss"
|
||||
|
||||
/*
|
||||
* s_flags "type"
|
||||
*/
|
||||
#define STYP_TEXT 0x20 /* section contains text only */
|
||||
#define STYP_DATA 0x40 /* section contains data only */
|
||||
#define STYP_BSS 0x80 /* section contains bss only */
|
||||
|
||||
#define SCNHDR struct scnhdr
|
||||
#define SCNHSZ sizeof(SCNHDR)
|
||||
|
||||
|
||||
/********************** LINE NUMBERS **********************/
|
||||
|
||||
/* 1 line number entry for every "breakpointable" source line in a section.
|
||||
* Line numbers are grouped on a per function basis; first entry in a function
|
||||
* grouping will have l_lnno = 0 and in place of physical address will be the
|
||||
* symbol table index of the function name.
|
||||
*/
|
||||
struct lineno{
|
||||
union {
|
||||
long l_symndx; /* function name symbol index, iff l_lnno == 0*/
|
||||
long l_paddr; /* (physical) address of line number */
|
||||
} l_addr;
|
||||
|
||||
long l_lnno;
|
||||
|
||||
};
|
||||
|
||||
#define LINENO struct lineno
|
||||
#define LINESZ sizeof(LINENO)
|
||||
|
||||
|
||||
/********************** SYMBOLS **********************/
|
||||
|
||||
#define SYMNMLEN 8 /* # characters in a symbol name */
|
||||
#define FILNMLEN 14 /* # characters in a file name */
|
||||
#define DIMNUM 4 /* # array dimensions in auxiliary entry */
|
||||
|
||||
|
||||
struct syment {
|
||||
union {
|
||||
char _n_name[SYMNMLEN]; /* old COFF version */
|
||||
struct {
|
||||
long _n_zeroes; /* new == 0 */
|
||||
long _n_offset; /* offset into string table */
|
||||
} _n_n;
|
||||
char *_n_nptr[2]; /* allows for overlaying */
|
||||
} _n;
|
||||
long n_value; /* value of symbol */
|
||||
short n_scnum; /* section number */
|
||||
unsigned short n_type; /* type and derived type */
|
||||
char n_sclass; /* storage class */
|
||||
char n_numaux; /* number of aux. entries */
|
||||
char pad2[2]; /* force alignment */
|
||||
};
|
||||
|
||||
#define n_name _n._n_name
|
||||
#define n_zeroes _n._n_n._n_zeroes
|
||||
#define n_offset _n._n_n._n_offset
|
||||
|
||||
/*
|
||||
* Relocatable symbols have number of the section in which they are defined,
|
||||
* or one of the following:
|
||||
*/
|
||||
#define N_UNDEF 0 /* undefined symbol */
|
||||
#define N_ABS -1 /* value of symbol is absolute */
|
||||
#define N_DEBUG -2 /* debugging symbol -- symbol value is meaningless */
|
||||
|
||||
/*
|
||||
* Type of a symbol, in low 4 bits of the word
|
||||
*/
|
||||
#define T_NULL 0
|
||||
#define T_VOID 1 /* function argument (only used by compiler) */
|
||||
#define T_CHAR 2 /* character */
|
||||
#define T_SHORT 3 /* short integer */
|
||||
#define T_INT 4 /* integer */
|
||||
#define T_LONG 5 /* long integer */
|
||||
#define T_FLOAT 6 /* floating point */
|
||||
#define T_DOUBLE 7 /* double word */
|
||||
#define T_STRUCT 8 /* structure */
|
||||
#define T_UNION 9 /* union */
|
||||
#define T_ENUM 10 /* enumeration */
|
||||
#define T_MOE 11 /* member of enumeration*/
|
||||
#define T_UCHAR 12 /* unsigned character */
|
||||
#define T_USHORT 13 /* unsigned short */
|
||||
#define T_UINT 14 /* unsigned integer */
|
||||
#define T_ULONG 15 /* unsigned long */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* derived types
|
||||
*/
|
||||
#define DT_NON 0
|
||||
#define DT_PTR 1 /* pointer */
|
||||
#define DT_FCN 2 /* function */
|
||||
#define DT_ARY 3 /* array */
|
||||
|
||||
#define N_BTMASK 017
|
||||
#define N_TMASK 060
|
||||
#define N_BTSHFT 4
|
||||
#define N_TSHIFT 2
|
||||
|
||||
#define BTYPE(x) ((x) & N_BTMASK)
|
||||
|
||||
|
||||
#define ISPTR(x) (((x) & N_TMASK) == (DT_PTR << N_BTSHFT))
|
||||
#define ISFCN(x) (((x) & N_TMASK) == (DT_FCN << N_BTSHFT))
|
||||
#define ISARY(x) (((x) & N_TMASK) == (DT_ARY << N_BTSHFT))
|
||||
|
||||
#define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
|
||||
|
||||
union auxent {
|
||||
struct {
|
||||
long x_tagndx; /* str, un, or enum tag indx */
|
||||
union {
|
||||
struct {
|
||||
unsigned long x_lnno; /* declaration line number */
|
||||
unsigned long x_size; /* str/union/array size */
|
||||
} x_lnsz;
|
||||
long x_fsize; /* size of function */
|
||||
} x_misc;
|
||||
union {
|
||||
struct { /* if ISFCN, tag, or .bb */
|
||||
long x_lnnoptr; /* ptr to fcn line # */
|
||||
long x_endndx; /* entry ndx past block end */
|
||||
} x_fcn;
|
||||
struct { /* if ISARY, up to 4 dimen. */
|
||||
unsigned short x_dimen[DIMNUM];
|
||||
} x_ary;
|
||||
} x_fcnary;
|
||||
unsigned short x_tvndx; /* tv index */
|
||||
} x_sym;
|
||||
|
||||
union {
|
||||
char x_fname[FILNMLEN];
|
||||
struct {
|
||||
long x_zeroes;
|
||||
long x_offset;
|
||||
} x_n;
|
||||
} x_file;
|
||||
|
||||
struct {
|
||||
long x_scnlen; /* section length */
|
||||
unsigned long x_nreloc; /* # relocation entries */
|
||||
unsigned long x_nlinno; /* # line numbers */
|
||||
} x_scn;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define SYMENT struct syment
|
||||
#define SYMESZ 20
|
||||
#define AUXENT union auxent
|
||||
#define AUXESZ 20
|
||||
|
||||
|
||||
/********************** RELOCATION DIRECTIVES **********************/
|
||||
|
||||
struct reloc {
|
||||
long r_vaddr; /* Virtual address of reference */
|
||||
long r_symndx; /* Index into symbol table */
|
||||
unsigned short r_type; /* Relocation type */
|
||||
unsigned short r_offset;/* Hi 16 bits of constant */
|
||||
};
|
||||
|
||||
/* Only values of r_type GNU/88k cares about */
|
||||
#define R_PCR16L 128
|
||||
#define R_PCR26L 129
|
||||
#define R_VRT16 130
|
||||
#define R_HVRT16 131
|
||||
#define R_LVRT16 132
|
||||
#define R_VRT32 133
|
||||
|
||||
|
||||
|
||||
|
||||
#define RELOC struct reloc
|
||||
#define RELSZ sizeof(RELOC)
|
||||
|
||||
#define DEFAULT_SECTION_ALIGNMENT 8 /* double word */
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
#define N_W_VARIABLES 8
|
||||
#define Module_Beginning 0xe0
|
||||
|
||||
typedef struct {
|
||||
char *processor;
|
||||
char *module_name;
|
||||
} ieee_module_begin_type;
|
||||
|
||||
#define Address_Descriptor 0xec
|
||||
typedef struct {
|
||||
bfd_vma number_of_bits_mau;
|
||||
bfd_vma number_of_maus_in_address;
|
||||
|
||||
unsigned char byte_order;
|
||||
#define IEEE_LITTLE 0xcc
|
||||
#define IEEE_BIG 0xcd
|
||||
} ieee_address_descriptor_type;
|
||||
|
||||
typedef union {
|
||||
file_ptr offset[N_W_VARIABLES];
|
||||
struct {
|
||||
file_ptr extension_record;
|
||||
file_ptr environmental_record;
|
||||
file_ptr section_part;
|
||||
file_ptr external_part;
|
||||
file_ptr debug_information_part;
|
||||
file_ptr data_part;
|
||||
file_ptr trailer_part;
|
||||
file_ptr me_record;
|
||||
} r;
|
||||
} ieee_w_variable_type;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
ieee_number_start_enum = 0x00,
|
||||
ieee_number_end_enum=0x7f,
|
||||
ieee_number_repeat_start_enum = 0x80,
|
||||
ieee_number_repeat_end_enum = 0x88,
|
||||
ieee_number_repeat_4_enum = 0x84,
|
||||
ieee_number_repeat_3_enum = 0x83,
|
||||
ieee_number_repeat_2_enum = 0x82,
|
||||
ieee_number_repeat_1_enum = 0x81,
|
||||
ieee_module_beginning_enum = 0xe0,
|
||||
ieee_module_end_enum = 0xe1,
|
||||
ieee_extension_length_1_enum = 0xde,
|
||||
ieee_extension_length_2_enum = 0xdf,
|
||||
ieee_section_type_enum = 0xe6,
|
||||
ieee_section_alignment_enum = 0xe7,
|
||||
ieee_external_symbol_enum = 0xe8,
|
||||
ieee_attribute_record_enum = 0xf1c9,
|
||||
ieee_comma = 0x90,
|
||||
ieee_external_reference_enum = 0xe9,
|
||||
ieee_set_current_section_enum = 0xe5,
|
||||
ieee_address_descriptor_enum = 0xec,
|
||||
ieee_load_constant_bytes_enum = 0xed,
|
||||
ieee_load_with_relocation_enum = 0xe4,
|
||||
|
||||
ieee_variable_A_enum = 0xc1,
|
||||
ieee_variable_B_enum = 0xc2,
|
||||
ieee_variable_C_enum = 0xc3,
|
||||
ieee_variable_D_enum = 0xc4,
|
||||
ieee_variable_E_enum = 0xc5,
|
||||
ieee_variable_F_enum = 0xc6,
|
||||
ieee_variable_G_enum = 0xc7,
|
||||
ieee_variable_H_enum = 0xc8,
|
||||
ieee_variable_I_enum = 0xc9,
|
||||
ieee_variable_J_enum = 0xca,
|
||||
ieee_variable_K_enum = 0xcb,
|
||||
ieee_variable_L_enum = 0xcc,
|
||||
ieee_variable_M_enum = 0xcd,
|
||||
ieee_variable_N_enum = 0xce,
|
||||
ieee_variable_O_enum = 0xcf,
|
||||
ieee_variable_P_enum = 0xd0,
|
||||
ieee_variable_Q_enum = 0xd1,
|
||||
ieee_variable_R_enum = 0xd2,
|
||||
ieee_variable_S_enum = 0xd3,
|
||||
ieee_variable_T_enum = 0xd4,
|
||||
ieee_variable_U_enum = 0xd5,
|
||||
ieee_variable_V_enum = 0xd6,
|
||||
ieee_variable_W_enum = 0xd7,
|
||||
ieee_variable_X_enum = 0xd8,
|
||||
ieee_variable_Y_enum = 0xd9,
|
||||
ieee_variable_Z_enum = 0xda,
|
||||
ieee_function_plus_enum = 0xa5,
|
||||
ieee_function_minus_enum = 0xa6,
|
||||
ieee_function_signed_open_b_enum = 0xba,
|
||||
ieee_function_signed_close_b_enum = 0xbb,
|
||||
|
||||
ieee_function_unsigned_open_b_enum = 0xbc,
|
||||
ieee_function_unsigned_close_b_enum = 0xbd,
|
||||
|
||||
ieee_function_either_open_b_enum = 0xbe,
|
||||
ieee_function_either_close_b_enum = 0xbf,
|
||||
ieee_record_seperator_enum = 0xdb,
|
||||
|
||||
ieee_e2_first_byte_enum = 0xe2,
|
||||
ieee_section_size_enum = 0xe2d3,
|
||||
ieee_physical_region_size_enum = 0xe2c1,
|
||||
ieee_region_base_address_enum = 0xe2c2,
|
||||
ieee_mau_size_enum = 0xe2c6,
|
||||
ieee_m_value_enum = 0xe2cd,
|
||||
ieee_section_base_address_enum = 0xe2cc,
|
||||
ieee_section_offset_enum = 0xe2d2,
|
||||
ieee_value_starting_address_enum = 0xe2c7,
|
||||
ieee_assign_value_to_variable_enum = 0xe2d7,
|
||||
ieee_set_current_pc_enum = 0xe2d0,
|
||||
ieee_value_record_enum = 0xe2c9,
|
||||
ieee_weak_external_reference_enum= 0xf4,
|
||||
|
||||
} ieee_record_enum_type;
|
||||
|
||||
|
||||
typedef struct {
|
||||
unsigned int section_index;
|
||||
unsigned int section_type;
|
||||
char *section_name;
|
||||
unsigned int parent_section_index;
|
||||
unsigned int sibling_section_index;
|
||||
unsigned int context_index;
|
||||
} ieee_section_type;
|
||||
#define IEEE_REFERENCE_BASE 11
|
||||
#define IEEE_PUBLIC_BASE 32
|
||||
#define IEEE_SECTION_NUMBER_BASE 1
|
||||
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
|
||||
/* **** */
|
||||
|
||||
|
||||
typedef struct {
|
||||
int32_type version;
|
||||
char create_date[12];
|
||||
char revision_date[12];
|
||||
uint32_type mod_count;
|
||||
uint32_type mod_tbl_offset;
|
||||
uint32_type sym_tbl_size;
|
||||
uint32_type sym_count;
|
||||
uint32_type sym_tbl_offset;
|
||||
uint32_type xref_count;
|
||||
uint32_type xref_lst_offset;
|
||||
} oasys_archive_header_type;
|
||||
|
||||
typedef struct {
|
||||
int32_type mod_number;
|
||||
char mod_date[12];
|
||||
int32_type mod_size;
|
||||
int32_type dep_count;
|
||||
int32_type depee_count;
|
||||
int32_type sect_count;
|
||||
int32_type file_offset;
|
||||
int32_type mod_name_length;
|
||||
} oasys_module_table_type;
|
||||
|
||||
|
||||
typedef enum {
|
||||
oasys_record_is_end_enum = 0,
|
||||
oasys_record_is_data_enum = 1,
|
||||
oasys_record_is_symbol_enum = 2,
|
||||
oasys_record_is_header_enum = 3,
|
||||
oasys_record_is_named_section_enum = 4,
|
||||
oasys_record_is_com_enum = 5,
|
||||
oasys_record_is_debug_enum = 6,
|
||||
oasys_record_is_section_enum = 7,
|
||||
oasys_record_is_debug_file_enum = 8,
|
||||
oasys_record_is_module_enum = 9,
|
||||
oasys_record_is_local_enum = 10
|
||||
} oasys_record_enum_type;
|
||||
|
||||
|
||||
|
||||
typedef struct {
|
||||
uint8_type length;
|
||||
int8_type check_sum;
|
||||
int8_type type;
|
||||
int8_type fill;
|
||||
} oasys_record_header_type;
|
||||
|
||||
typedef struct {
|
||||
oasys_record_header_type header;
|
||||
uint8e_type relb;
|
||||
uint8e_type addr[4];
|
||||
uint8e_type data[256];
|
||||
} oasys_data_record_type;
|
||||
|
||||
typedef struct {
|
||||
oasys_record_header_type header;
|
||||
int8_type version_number;
|
||||
int8_type rev_number;
|
||||
char module_name[26-6];
|
||||
char description[64-26];
|
||||
} oasys_header_record_type;
|
||||
|
||||
#define OASYS_VERSION_NUMBER 0
|
||||
#define OASYS_REV_NUMBER 0
|
||||
typedef struct {
|
||||
oasys_record_header_type header;
|
||||
int8e_type relb;
|
||||
int8e_type value[4];
|
||||
int8e_type refno[2];
|
||||
char name[64];
|
||||
} oasys_symbol_record_type;
|
||||
|
||||
typedef int8e_type relocation_byte;
|
||||
|
||||
#define RELOCATION_PCREL_BIT 0x80
|
||||
#define RELOCATION_32BIT_BIT 0x40
|
||||
#define RELOCATION_TYPE_BITS 0x30
|
||||
#define RELOCATION_TYPE_ABS 0x00
|
||||
#define RELOCATION_TYPE_REL 0x10
|
||||
#define RELOCATION_TYPE_UND 0x20
|
||||
#define RELOCATION_TYPE_COM 0x30
|
||||
#define RELOCATION_SECT_BITS 0x0f
|
||||
|
||||
typedef struct
|
||||
{
|
||||
oasys_record_header_type header;
|
||||
uint8e_type relb;
|
||||
int8_type value[4];
|
||||
int8_type vma[4];
|
||||
int8_type fill[3];
|
||||
} oasys_section_record_type;
|
||||
|
||||
typedef struct {
|
||||
oasys_record_header_type header;
|
||||
uint8e_type relb;
|
||||
int8e_type entry[4];
|
||||
int8e_type fill[2];
|
||||
int8e_type zero;
|
||||
} oasys_end_record_type;
|
||||
|
||||
|
||||
#define OASYS_MAX_SEC_COUNT 16
|
||||
typedef union
|
||||
{
|
||||
oasys_record_header_type header;
|
||||
oasys_data_record_type data;
|
||||
oasys_section_record_type section;
|
||||
oasys_symbol_record_type symbol;
|
||||
oasys_header_record_type first;
|
||||
oasys_end_record_type end;
|
||||
uint8e_type pad[256];
|
||||
} oasys_record_union_type;
|
||||
|
|
@ -0,0 +1,416 @@
|
|||
/* obstack.h - object stack macros
|
||||
Copyright (C) 1988 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
/* Summary:
|
||||
|
||||
All the apparent functions defined here are macros. The idea
|
||||
is that you would use these pre-tested macros to solve a
|
||||
very specific set of problems, and they would run fast.
|
||||
Caution: no side-effects in arguments please!! They may be
|
||||
evaluated MANY times!!
|
||||
|
||||
These macros operate a stack of objects. Each object starts life
|
||||
small, and may grow to maturity. (Consider building a word syllable
|
||||
by syllable.) An object can move while it is growing. Once it has
|
||||
been "finished" it never changes address again. So the "top of the
|
||||
stack" is typically an immature growing object, while the rest of the
|
||||
stack is of mature, fixed size and fixed address objects.
|
||||
|
||||
These routines grab large chunks of memory, using a function you
|
||||
supply, called `obstack_chunk_alloc'. On occasion, they free chunks,
|
||||
by calling `obstack_chunk_free'. You must define them and declare
|
||||
them before using any obstack macros.
|
||||
|
||||
Each independent stack is represented by a `struct obstack'.
|
||||
Each of the obstack macros expects a pointer to such a structure
|
||||
as the first argument.
|
||||
|
||||
One motivation for this package is the problem of growing char strings
|
||||
in symbol tables. Unless you are "fascist pig with a read-only mind"
|
||||
[Gosper's immortal quote from HAKMEM item 154, out of context] you
|
||||
would not like to put any arbitrary upper limit on the length of your
|
||||
symbols.
|
||||
|
||||
In practice this often means you will build many short symbols and a
|
||||
few long symbols. At the time you are reading a symbol you don't know
|
||||
how long it is. One traditional method is to read a symbol into a
|
||||
buffer, realloc()ating the buffer every time you try to read a symbol
|
||||
that is longer than the buffer. This is beaut, but you still will
|
||||
want to copy the symbol from the buffer to a more permanent
|
||||
symbol-table entry say about half the time.
|
||||
|
||||
With obstacks, you can work differently. Use one obstack for all symbol
|
||||
names. As you read a symbol, grow the name in the obstack gradually.
|
||||
When the name is complete, finalize it. Then, if the symbol exists already,
|
||||
free the newly read name.
|
||||
|
||||
The way we do this is to take a large chunk, allocating memory from
|
||||
low addresses. When you want to build a symbol in the chunk you just
|
||||
add chars above the current "high water mark" in the chunk. When you
|
||||
have finished adding chars, because you got to the end of the symbol,
|
||||
you know how long the chars are, and you can create a new object.
|
||||
Mostly the chars will not burst over the highest address of the chunk,
|
||||
because you would typically expect a chunk to be (say) 100 times as
|
||||
long as an average object.
|
||||
|
||||
In case that isn't clear, when we have enough chars to make up
|
||||
the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
|
||||
so we just point to it where it lies. No moving of chars is
|
||||
needed and this is the second win: potentially long strings need
|
||||
never be explicitly shuffled. Once an object is formed, it does not
|
||||
change its address during its lifetime.
|
||||
|
||||
When the chars burst over a chunk boundary, we allocate a larger
|
||||
chunk, and then copy the partly formed object from the end of the old
|
||||
chunk to the beginning of the new larger chunk. We then carry on
|
||||
accreting characters to the end of the object as we normally would.
|
||||
|
||||
A special macro is provided to add a single char at a time to a
|
||||
growing object. This allows the use of register variables, which
|
||||
break the ordinary 'growth' macro.
|
||||
|
||||
Summary:
|
||||
We allocate large chunks.
|
||||
We carve out one object at a time from the current chunk.
|
||||
Once carved, an object never moves.
|
||||
We are free to append data of any size to the currently
|
||||
growing object.
|
||||
Exactly one object is growing in an obstack at any one time.
|
||||
You can run one obstack per control block.
|
||||
You may have as many control blocks as you dare.
|
||||
Because of the way we do it, you can `unwind' a obstack
|
||||
back to a previous state. (You may remove objects much
|
||||
as you would with a stack.)
|
||||
*/
|
||||
|
||||
|
||||
/* Don't do the contents of this file more than once. */
|
||||
|
||||
#ifndef __OBSTACKS__
|
||||
#define __OBSTACKS__
|
||||
|
||||
/* We use subtraction of (char *)0 instead of casting to int
|
||||
because on word-addressable machines a simple cast to int
|
||||
may ignore the byte-within-word field of the pointer. */
|
||||
|
||||
#ifndef __PTR_TO_INT
|
||||
#define __PTR_TO_INT(P) ((P) - (char *)0)
|
||||
#endif
|
||||
|
||||
#ifndef __INT_TO_PTR
|
||||
#define __INT_TO_PTR(P) ((P) + (char *)0)
|
||||
#endif
|
||||
|
||||
struct _obstack_chunk /* Lives at front of each chunk. */
|
||||
{
|
||||
char *limit; /* 1 past end of this chunk */
|
||||
struct _obstack_chunk *prev; /* address of prior chunk or NULL */
|
||||
char contents[4]; /* objects begin here */
|
||||
};
|
||||
|
||||
struct obstack /* control current object in current chunk */
|
||||
{
|
||||
long chunk_size; /* preferred size to allocate chunks in */
|
||||
struct _obstack_chunk* chunk; /* address of current struct obstack_chunk */
|
||||
char *object_base; /* address of object we are building */
|
||||
char *next_free; /* where to add next char to current object */
|
||||
char *chunk_limit; /* address of char after current chunk */
|
||||
int temp; /* Temporary for some macros. */
|
||||
int alignment_mask; /* Mask of alignment for each object. */
|
||||
#ifdef __STDC__
|
||||
void *(*chunkfun) (); /* User's fcn to allocate a chunk. */
|
||||
#else
|
||||
char *(*chunkfun) (); /* User's fcn to allocate a chunk. */
|
||||
#endif
|
||||
void (*freefun) (); /* User's function to free a chunk. */
|
||||
};
|
||||
|
||||
#ifdef __STDC__
|
||||
|
||||
/* Do the function-declarations after the structs
|
||||
but before defining the macros. */
|
||||
|
||||
void obstack_init (struct obstack *obstack);
|
||||
|
||||
void * obstack_alloc (struct obstack *obstack, int size);
|
||||
|
||||
void * obstack_copy (struct obstack *obstack, void *address, int size);
|
||||
void * obstack_copy0 (struct obstack *obstack, void *address, int size);
|
||||
|
||||
void obstack_free (struct obstack *obstack, void *block);
|
||||
|
||||
void obstack_blank (struct obstack *obstack, int size);
|
||||
|
||||
void obstack_grow (struct obstack *obstack, void *data, int size);
|
||||
void obstack_grow0 (struct obstack *obstack, void *data, int size);
|
||||
|
||||
void obstack_1grow (struct obstack *obstack, int data_char);
|
||||
void obstack_ptr_grow (struct obstack *obstack, void *data);
|
||||
void obstack_int_grow (struct obstack *obstack, int data);
|
||||
|
||||
void * obstack_finish (struct obstack *obstack);
|
||||
|
||||
int obstack_object_size (struct obstack *obstack);
|
||||
|
||||
int obstack_room (struct obstack *obstack);
|
||||
void obstack_1grow_fast (struct obstack *obstack, int data_char);
|
||||
void obstack_ptr_grow_fast (struct obstack *obstack, void *data);
|
||||
void obstack_int_grow_fast (struct obstack *obstack, int data);
|
||||
void obstack_blank_fast (struct obstack *obstack, int size);
|
||||
|
||||
void * obstack_base (struct obstack *obstack);
|
||||
void * obstack_next_free (struct obstack *obstack);
|
||||
int obstack_alignment_mask (struct obstack *obstack);
|
||||
int obstack_chunk_size (struct obstack *obstack);
|
||||
|
||||
#endif /* __STDC__ */
|
||||
|
||||
/* Non-ANSI C cannot really support alternative functions for these macros,
|
||||
so we do not declare them. */
|
||||
|
||||
/* Pointer to beginning of object being allocated or to be allocated next.
|
||||
Note that this might not be the final address of the object
|
||||
because a new chunk might be needed to hold the final size. */
|
||||
|
||||
#define obstack_base(h) ((h)->object_base)
|
||||
|
||||
/* Size for allocating ordinary chunks. */
|
||||
|
||||
#define obstack_chunk_size(h) ((h)->chunk_size)
|
||||
|
||||
/* Pointer to next byte not yet allocated in current chunk. */
|
||||
|
||||
#define obstack_next_free(h) ((h)->next_free)
|
||||
|
||||
/* Mask specifying low bits that should be clear in address of an object. */
|
||||
|
||||
#define obstack_alignment_mask(h) ((h)->alignment_mask)
|
||||
|
||||
#define obstack_init(h) \
|
||||
_obstack_begin ((h), 0, 0, obstack_chunk_alloc, obstack_chunk_free)
|
||||
|
||||
#define obstack_begin(h, size) \
|
||||
_obstack_begin ((h), (size), 0, obstack_chunk_alloc, obstack_chunk_free)
|
||||
|
||||
#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar)
|
||||
|
||||
#define obstack_blank_fast(h,n) ((h)->next_free += (n))
|
||||
|
||||
#if defined (__GNUC__) && defined (__STDC__)
|
||||
|
||||
/* For GNU C, if not -traditional,
|
||||
we can define these macros to compute all args only once
|
||||
without using a global variable.
|
||||
Also, we can avoid using the `temp' slot, to make faster code. */
|
||||
|
||||
#define obstack_object_size(OBSTACK) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
(unsigned) (__o->next_free - __o->object_base); })
|
||||
|
||||
#define obstack_room(OBSTACK) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
(unsigned) (__o->chunk_limit - __o->next_free); })
|
||||
|
||||
#define obstack_grow(OBSTACK,where,length) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
int __len = (length); \
|
||||
((__o->next_free + __len > __o->chunk_limit) \
|
||||
? _obstack_newchunk (__o, __len) : 0); \
|
||||
bcopy (where, __o->next_free, __len); \
|
||||
__o->next_free += __len; \
|
||||
(void) 0; })
|
||||
|
||||
#define obstack_grow0(OBSTACK,where,length) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
int __len = (length); \
|
||||
((__o->next_free + __len + 1 > __o->chunk_limit) \
|
||||
? _obstack_newchunk (__o, __len + 1) : 0), \
|
||||
bcopy (where, __o->next_free, __len), \
|
||||
__o->next_free += __len, \
|
||||
*(__o->next_free)++ = 0; \
|
||||
(void) 0; })
|
||||
|
||||
#define obstack_1grow(OBSTACK,datum) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
((__o->next_free + 1 > __o->chunk_limit) \
|
||||
? _obstack_newchunk (__o, 1) : 0), \
|
||||
*(__o->next_free)++ = (datum); \
|
||||
(void) 0; })
|
||||
|
||||
/* These assume that the obstack alignment is good enough for pointers or ints,
|
||||
and that the data added so far to the current object
|
||||
shares that much alignment. */
|
||||
|
||||
#define obstack_ptr_grow(OBSTACK,datum) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
((__o->next_free + sizeof (void *) > __o->chunk_limit) \
|
||||
? _obstack_newchunk (__o, sizeof (void *)) : 0), \
|
||||
*(*(void ***)&__o->next_free)++ = ((void *)datum); \
|
||||
(void) 0; })
|
||||
|
||||
#define obstack_int_grow(OBSTACK,datum) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
((__o->next_free + sizeof (int) > __o->chunk_limit) \
|
||||
? _obstack_newchunk (__o, sizeof (int)) : 0), \
|
||||
*(*(int **)&__o->next_free)++ = ((int)datum); \
|
||||
(void) 0; })
|
||||
|
||||
#define obstack_ptr_grow_fast(h,aptr) (*(*(void ***)&(h)->next_free)++ = (void *)aptr)
|
||||
#define obstack_int_grow_fast(h,aint) (*(*(int **)&(h)->next_free)++ = (int)aint)
|
||||
|
||||
#define obstack_blank(OBSTACK,length) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
int __len = (length); \
|
||||
((__o->chunk_limit - __o->next_free < __len) \
|
||||
? _obstack_newchunk (__o, __len) : 0); \
|
||||
__o->next_free += __len; \
|
||||
(void) 0; })
|
||||
|
||||
#define obstack_alloc(OBSTACK,length) \
|
||||
({ struct obstack *__h = (OBSTACK); \
|
||||
obstack_blank (__h, (length)); \
|
||||
obstack_finish (__h); })
|
||||
|
||||
#define obstack_copy(OBSTACK,where,length) \
|
||||
({ struct obstack *__h = (OBSTACK); \
|
||||
obstack_grow (__h, (where), (length)); \
|
||||
obstack_finish (__h); })
|
||||
|
||||
#define obstack_copy0(OBSTACK,where,length) \
|
||||
({ struct obstack *__h = (OBSTACK); \
|
||||
obstack_grow0 (__h, (where), (length)); \
|
||||
obstack_finish (__h); })
|
||||
|
||||
#define obstack_finish(OBSTACK) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
void *value = (void *) __o->object_base; \
|
||||
__o->next_free \
|
||||
= __INT_TO_PTR ((__PTR_TO_INT (__o->next_free)+__o->alignment_mask)\
|
||||
& ~ (__o->alignment_mask)); \
|
||||
((__o->next_free - (char *)__o->chunk \
|
||||
> __o->chunk_limit - (char *)__o->chunk) \
|
||||
? (__o->next_free = __o->chunk_limit) : 0); \
|
||||
__o->object_base = __o->next_free; \
|
||||
value; })
|
||||
|
||||
#define obstack_free(OBSTACK, OBJ) \
|
||||
({ struct obstack *__o = (OBSTACK); \
|
||||
void *__obj = (OBJ); \
|
||||
if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \
|
||||
__o->next_free = __o->object_base = __obj; \
|
||||
else (obstack_free) (__o, __obj); })
|
||||
|
||||
#else /* not __GNUC__ or not __STDC__ */
|
||||
|
||||
#define obstack_object_size(h) \
|
||||
(unsigned) ((h)->next_free - (h)->object_base)
|
||||
|
||||
#define obstack_room(h) \
|
||||
(unsigned) ((h)->chunk_limit - (h)->next_free)
|
||||
|
||||
#define obstack_grow(h,where,length) \
|
||||
( (h)->temp = (length), \
|
||||
(((h)->next_free + (h)->temp > (h)->chunk_limit) \
|
||||
? _obstack_newchunk ((h), (h)->temp) : 0), \
|
||||
bcopy (where, (h)->next_free, (h)->temp), \
|
||||
(h)->next_free += (h)->temp)
|
||||
|
||||
#define obstack_grow0(h,where,length) \
|
||||
( (h)->temp = (length), \
|
||||
(((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \
|
||||
? _obstack_newchunk ((h), (h)->temp + 1) : 0), \
|
||||
bcopy (where, (h)->next_free, (h)->temp), \
|
||||
(h)->next_free += (h)->temp, \
|
||||
*((h)->next_free)++ = 0)
|
||||
|
||||
#define obstack_1grow(h,datum) \
|
||||
( (((h)->next_free + 1 > (h)->chunk_limit) \
|
||||
? _obstack_newchunk ((h), 1) : 0), \
|
||||
*((h)->next_free)++ = (datum))
|
||||
|
||||
#define obstack_ptr_grow(h,datum) \
|
||||
( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \
|
||||
? _obstack_newchunk ((h), sizeof (char *)) : 0), \
|
||||
*(*(char ***)&(h)->next_free)++ = ((char *)datum))
|
||||
|
||||
#define obstack_int_grow(h,datum) \
|
||||
( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \
|
||||
? _obstack_newchunk ((h), sizeof (int)) : 0), \
|
||||
*(*(int **)&(h)->next_free)++ = ((int)datum))
|
||||
|
||||
#define obstack_ptr_grow_fast(h,aptr) (*(*(char ***)&(h)->next_free)++ = (char *)aptr)
|
||||
#define obstack_int_grow_fast(h,aint) (*(*(int **)&(h)->next_free)++ = (int)aint)
|
||||
|
||||
#define obstack_blank(h,length) \
|
||||
( (h)->temp = (length), \
|
||||
(((h)->chunk_limit - (h)->next_free < (h)->temp) \
|
||||
? _obstack_newchunk ((h), (h)->temp) : 0), \
|
||||
(h)->next_free += (h)->temp)
|
||||
|
||||
#define obstack_alloc(h,length) \
|
||||
(obstack_blank ((h), (length)), obstack_finish ((h)))
|
||||
|
||||
#define obstack_copy(h,where,length) \
|
||||
(obstack_grow ((h), (where), (length)), obstack_finish ((h)))
|
||||
|
||||
#define obstack_copy0(h,where,length) \
|
||||
(obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
|
||||
|
||||
#define obstack_finish(h) \
|
||||
( (h)->temp = __PTR_TO_INT ((h)->object_base), \
|
||||
(h)->next_free \
|
||||
= __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \
|
||||
& ~ ((h)->alignment_mask)), \
|
||||
(((h)->next_free - (char *)(h)->chunk \
|
||||
> (h)->chunk_limit - (char *)(h)->chunk) \
|
||||
? ((h)->next_free = (h)->chunk_limit) : 0), \
|
||||
(h)->object_base = (h)->next_free, \
|
||||
__INT_TO_PTR ((h)->temp))
|
||||
|
||||
#ifdef __STDC__
|
||||
#define obstack_free(h,obj) \
|
||||
( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \
|
||||
(((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
|
||||
? (int) ((h)->next_free = (h)->object_base \
|
||||
= (h)->temp + (char *) (h)->chunk) \
|
||||
: ((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0)))
|
||||
#else
|
||||
#define obstack_free(h,obj) \
|
||||
( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \
|
||||
(((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
|
||||
? (int) ((h)->next_free = (h)->object_base \
|
||||
= (h)->temp + (char *) (h)->chunk) \
|
||||
: (int) _obstack_free ((h), (h)->temp + (char *) (h)->chunk)))
|
||||
#endif
|
||||
|
||||
#endif /* not __GNUC__ or not __STDC__ */
|
||||
|
||||
/* Declare the external functions we use; they are in obstack.c. */
|
||||
|
||||
#ifdef __STDC__
|
||||
extern int _obstack_newchunk (struct obstack *h, int length);
|
||||
extern int _obstack_free (struct obstack *h, void *obj);
|
||||
extern void _obstack_begin (struct obstack *h, int size, int alignment,
|
||||
void *(*chunkfun) (), void (*freefun) ());
|
||||
#else
|
||||
extern int _obstack_newchunk ();
|
||||
extern int _obstack_free ();
|
||||
extern void _obstack_begin ();
|
||||
#endif
|
||||
|
||||
#endif /* not __OBSTACKS__ */
|
||||
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/* Relocation types for a.out files using reloc_info_extended
|
||||
(SPARC and AMD 29000). */
|
||||
|
||||
#ifndef _RELOC_H_READ_
|
||||
#define _RELOC_H_READ_ 1
|
||||
|
||||
enum reloc_type
|
||||
{
|
||||
RELOC_8, RELOC_16, RELOC_32, /* simple relocations */
|
||||
RELOC_DISP8, RELOC_DISP16, RELOC_DISP32, /* pc-rel displacement */
|
||||
RELOC_WDISP30, RELOC_WDISP22,
|
||||
RELOC_HI22, RELOC_22,
|
||||
RELOC_13, RELOC_LO10,
|
||||
RELOC_SFA_BASE, RELOC_SFA_OFF13,
|
||||
RELOC_BASE10, RELOC_BASE13, RELOC_BASE22, /* P.I.C. (base-relative) */
|
||||
RELOC_PC10, RELOC_PC22, /* for some sort of pc-rel P.I.C. (?) */
|
||||
RELOC_JMP_TBL, /* P.I.C. jump table */
|
||||
RELOC_SEGOFF16, /* reputedly for shared libraries somehow */
|
||||
RELOC_GLOB_DAT, RELOC_JMP_SLOT, RELOC_RELATIVE,
|
||||
|
||||
/* 29K relocation types */
|
||||
RELOC_JUMPTARG, RELOC_CONST, RELOC_CONSTH,
|
||||
|
||||
NO_RELOC
|
||||
};
|
||||
|
||||
#define RELOC_TYPE_NAMES \
|
||||
"8", "16", "32", "DISP8", \
|
||||
"DISP16", "DISP32", "WDISP30", "WDISP22", \
|
||||
"HI22", "22", "13", "LO10", \
|
||||
"SFA_BASE", "SFAOFF13", "BASE10", "BASE13", \
|
||||
"BASE22", "PC10", "PC22", "JMP_TBL", \
|
||||
"SEGOFF16", "GLOB_DAT", "JMP_SLOT", "RELATIVE", \
|
||||
"JUMPTARG", "CONST", "CONSTH", \
|
||||
"NO_RELOC", \
|
||||
"XXX_28", "XXX_29", "XXX_30", "XXX_31"
|
||||
|
||||
#endif /* _RELOC_H_READ_ */
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of BFD, the Binary File Diddler.
|
||||
|
||||
BFD 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 1, or (at your option)
|
||||
any later version.
|
||||
|
||||
BFD 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 BFD; see the file COPYING. If not, write to
|
||||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
/* All the system include files boiled into one place.
|
||||
|
||||
One day, everyone will have the same set of include files..
|
||||
|
||||
This is ugly, but if you can think of a better way of doing this,
|
||||
tell me. steve@cygnus.com
|
||||
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#ifndef _SYSDEP_H
|
||||
#define _SYSDEP_H
|
||||
|
||||
/*
|
||||
The including makefile must define HOST_SYS to be one of these.
|
||||
Each combination of Machine and OS (and maybe OS Version) must
|
||||
have a different number.
|
||||
*/
|
||||
|
||||
#define SUN4_SYS 2
|
||||
#define POSIX_SYS 3
|
||||
#define AIX_SYS 4
|
||||
#define VAX_ULTRIX_SYS 5
|
||||
#define i386_SYSV_SYS 6
|
||||
#define SUN3_SYS 7
|
||||
#define UNKNOWN_SYS 8
|
||||
#define DGUX_SYS 9
|
||||
#define DEC3100_SYS 10
|
||||
#define HP9000_SYS 11
|
||||
|
||||
#include <ansidecl.h>
|
||||
|
||||
#if __STDC__
|
||||
#define PROTO(type, name, arglist) type name arglist
|
||||
#else
|
||||
#define PROTO(type, name, arglist) type name ()
|
||||
#define NO_STDARG
|
||||
#endif
|
||||
|
||||
#ifndef HOST_SYS
|
||||
#define HOST_SYS = Hey_you_HOST_SYS_has_not_been_defined.
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==SUN4_SYS
|
||||
#define HOST_IS_SUN4 1
|
||||
#include <sys/h-sun4.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==DGUX_SYS
|
||||
#include <sys/h-dgux.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==POSIX_SYS
|
||||
#define HOST_IS_POSIX 1
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==AIX_SYS
|
||||
#define HOST_IS_AIX 1
|
||||
#include <sys/h-rs6000.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==VAX_ULTRIX_SYS
|
||||
#define HOST_IS_VAX_ULTRIX 1
|
||||
#include <sys/h-vaxult.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==i386_SYSV_SYS
|
||||
#define HOST_IS_i386_SYSV 1
|
||||
#define USG
|
||||
#include <sys/h-i386v.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==SUN3_SYS
|
||||
#define HOST_IS_SUN3 1
|
||||
#include <sys/h-sun3.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==DEC3100_SYS
|
||||
#define HOST_IS_DEC3100 1
|
||||
#include <sys/h-dec3100.h>
|
||||
#endif
|
||||
|
||||
#if HOST_SYS==HP9000_SYS
|
||||
#define HOST_IS_HP9000 1
|
||||
#define USG
|
||||
#include <sys/h-hp9000.h>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue