X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fsrconv.c;h=a421f642e0be73f99a051e1457fab7df607cb219;hb=a712c56a9a2afe0ea5335bf9bf50a638d39b5484;hp=e77a69caea652014c2581398c2dda3f6708f9cb3;hpb=4725d7ae1fc2c303373116ee602c03b887e72014;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/srconv.c b/binutils/srconv.c index e77a69caea..a421f642e0 100644 --- a/binutils/srconv.c +++ b/binutils/srconv.c @@ -1,21 +1,22 @@ /* srconv.c -- Sysroff conversion program - Copyright (C) 1994 Free Software Foundation, Inc. + Copyright (C) 1994-2019 Free Software Foundation, Inc. -This file is part of GNU Binutils. + This file is part of GNU Binutils. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ /* Written by Steve Chamberlain (sac@cygnus.com) @@ -24,79 +25,71 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ All debugging information is preserved */ -#include -#include -#include -#include -#include +#include "sysdep.h" +#include "bfd.h" +#include "bucomm.h" #include "sysroff.h" #include "coffgrok.h" +#include "libiberty.h" +#include "filenames.h" +#include "getopt.h" #include "coff/internal.h" #include "../bfd/libcoff.h" -#define PROGRAM_VERSION "1.3" -/*#define FOOP1 1*/ +/*#define FOOP1 1 */ -static int sh; -static int h8300; -static void wr_cs (); -static void walk_tree_scope (); -static void wr_globals (); +static int addrsize; +static char *toolname; +static char **rnames; + +static void walk_tree_symbol + (struct coff_sfile *, struct coff_section *, struct coff_symbol *, int); +static void walk_tree_scope + (struct coff_section *, struct coff_sfile *, struct coff_scope *, int, int); +static int find_base (struct coff_sfile *, struct coff_section *); +static void wr_globals (struct coff_ofile *, struct coff_sfile *, int); static FILE *file; static bfd *abfd; static int debug = 0; static int quick = 0; - +static int noprescan = 0; static struct coff_ofile *tree; +/* Obsolete ?? + static int absolute_p; + */ -static int absolute_p; static int segmented_p; static int code; -static int ids1[10000]; -static int ids2[10000]; +static int ids1[20000]; +static int ids2[20000]; static int base1 = 0x18; static int base2 = 0x2018; -char * -xcalloc (a, b) - int a; - int b; -{ - char *r = xmalloc (a * b); - memset (r, 0, a * b); - return r; -} - static int -get_member_id (x) - int x; +get_member_id (int x) { if (ids2[x]) - { - return ids2[x]; - } + return ids2[x]; + ids2[x] = base2++; return ids2[x]; } static int -get_ordinary_id (x) - int x; +get_ordinary_id (int x) { if (ids1[x]) - { - return ids1[x]; - } + return ids1[x]; + ids1[x] = base1++; return ids1[x]; } static char * -section_translate (n) - char *n; +section_translate (char *n) { if (strcmp (n, ".text") == 0) return "P"; @@ -107,18 +100,14 @@ section_translate (n) return n; } - - #define DATE "940201073000"; /* Just a time on my birthday */ - -static -char * -strip_suffix (name) - char *name; +static char * +strip_suffix (const char *name) { int i; char *res; + for (i = 0; name[i] != 0 && name[i] != '.'; i++) ; res = (char *) xmalloc (i + 1); @@ -127,59 +116,51 @@ strip_suffix (name) return res; } - /* IT LEN stuff CS */ static void -checksum (file, ptr, size, code) - FILE *file; - char *ptr; - int size; - int code; +checksum (FILE *ffile, unsigned char *ptr, int size, int ccode) { int j; int last; int sum = 0; int bytes = size / 8; - last = !(code & 0xff00); + + last = !(ccode & 0xff00); if (size & 0x7) - abort (); - ptr[0] = code | (last ? 0x80 : 0); + fatal (_("Checksum failure")); + + ptr[0] = ccode | (last ? 0x80 : 0); ptr[1] = bytes + 1; for (j = 0; j < bytes; j++) - { - sum += ptr[j]; - } - /* Glue on a checksum too */ + sum += ptr[j]; + + /* Glue on a checksum too. */ ptr[bytes] = ~sum; - fwrite (ptr, bytes + 1, 1, file); + if (fwrite (ptr, bytes + 1, 1, ffile) != 1) + /* FIXME: Return error status. */ + fatal (_("Failed to write checksum")); } - - static void -writeINT (n, ptr, idx, size, file) - int n; - char *ptr; - int *idx; - int size; - FILE *file; +writeINT (int n, unsigned char *ptr, int *idx, int size, FILE *ffile) { int byte = *idx / 8; if (size == -2) - size = 4; - if (size == -1) + size = addrsize; + else if (size == -1) size = 0; if (byte > 240) { - /* Lets write out that record and do another one */ - checksum (file, ptr, *idx, code | 0x1000); + /* Lets write out that record and do another one. */ + checksum (ffile, ptr, *idx, code | 0x1000); *idx = 16; byte = *idx / 8; } + switch (size) { case 0: @@ -198,77 +179,60 @@ writeINT (n, ptr, idx, size, file) ptr[byte + 3] = n >> 0; break; default: - abort (); + fatal (_("Unsupported integer write size: %d"), size); } *idx += size * 8; } - static void -writeBITS (val, ptr, idx, size) - int val; - char *ptr; - int *idx; - int size; +writeBITS (int val, unsigned char *ptr, int *idx, int size) { int byte = *idx / 8; int bit = *idx % 8; int old; + *idx += size; old = ptr[byte]; - /* Turn off all about to change bits */ + /* Turn off all about to change bits. */ old &= ~((~0 >> (8 - bit - size)) & ((1 << size) - 1)); - /* Turn on the bits we want */ + /* Turn on the bits we want. */ old |= (val & ((1 << size) - 1)) << (8 - bit - size); ptr[byte] = old; } static void -writeBARRAY (data, ptr, idx, size, file) - barray data; - char *ptr; - int *idx; - int size; - FILE *file; +writeBARRAY (barray data, unsigned char *ptr, int *idx, + int size ATTRIBUTE_UNUSED, FILE *ffile) { int i; - writeINT (data.len, ptr, idx, 1, file); - for (i = 0; i < data.len; i++) - { - writeINT (data.data[i], ptr, idx, 1, file); - } - - - + writeINT (data.len, ptr, idx, 1, ffile); + for (i = 0; i < data.len; i++) + writeINT (data.data[i], ptr, idx, 1, ffile); } + static void -writeCHARS (string, ptr, idx, size, file) - char *string; - char *ptr; - int *idx; - int size; - FILE *file; +writeCHARS (char *string, unsigned char *ptr, int *idx, int size, FILE *ffile) { int i = *idx / 8; if (i > 240) { - /* Lets write out that record and do another one */ - checksum (file, ptr, *idx, code | 0x1000); + /* Lets write out that record and do another one. */ + checksum (ffile, ptr, *idx, code | 0x1000); *idx = 16; i = *idx / 8; } if (size == 0) { - /* Variable length string */ + /* Variable length string. */ size = strlen (string); ptr[i++] = size; } - + /* BUG WAITING TO HAPPEN. */ memcpy (ptr + i, string, size); i += size; *idx = i * 8; @@ -277,7 +241,6 @@ writeCHARS (string, ptr, idx, size, file) #define SYSROFF_SWAP_OUT #include "sysroff.c" - static char *rname_sh[] = { "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15" @@ -289,30 +252,43 @@ static char *rname_h8300[] = }; static void -wr_tr () +wr_tr (void) { - struct IT_tr t; - sysroff_swap_tr_out (file, &t); + /* The TR block is not normal - it doesn't have any contents. */ + + static char b[] = + { + 0xff, /* IT */ + 0x03, /* RL */ + 0xfd, /* CS */ + }; + + if (fwrite (b, sizeof (b), 1, file) != 1) + /* FIXME: Return error status. */ + fatal (_("Failed to write TR block")); } static void -wr_un (ptr, sfile, first) - struct coff_ofile *ptr; - struct coff_sfile *sfile; - int first; +wr_un (struct coff_ofile *ptr, struct coff_sfile *sfile, int first, + int nsecs ATTRIBUTE_UNUSED) { struct IT_un un; struct coff_symbol *s; - if (abfd->flags & EXEC_P) + un.spare1 = 0; + + if (bfd_get_file_flags (abfd) & EXEC_P) un.format = FORMAT_LM; else un.format = FORMAT_OM; un.spare1 = 0; - un.nsections = ptr->nsections - 1; /* Don't count the abs section */ + + /* Don't count the abs section. */ + un.nsections = ptr->nsections - 1; + un.nextdefs = 0; un.nextrefs = 0; - /* Count all the undefined and defined variables with global scope */ + /* Count all the undefined and defined variables with global scope. */ if (first) { @@ -326,68 +302,82 @@ wr_un (ptr, sfile, first) un.nextrefs++; } } - if (sh) - { - un.tool = "C_SH"; - } - if (h8300) - { - un.tool = "C_H8/300H"; - } + un.tool = toolname; un.tcd = DATE; un.linker = "L_GX00"; un.lcd = DATE; un.name = sfile->name; - sysroff_swap_un_out (file, &un, 1); + sysroff_swap_un_out (file, &un); } - static void -wr_hd (p) - struct coff_ofile *p; +wr_hd (struct coff_ofile *p) { struct IT_hd hd; - - - if (abfd->flags & EXEC_P) - { - hd.mt = MTYPE_ABS_LM; - } + hd.spare1 = 0; + if (bfd_get_file_flags (abfd) & EXEC_P) + hd.mt = MTYPE_ABS_LM; else - { - hd.mt = MTYPE_OMS_OR_LMS; - } + hd.mt = MTYPE_OMS_OR_LMS; + hd.cd = DATE; hd.nu = p->nsources; /* Always one unit */ hd.code = 0; /* Always ASCII */ hd.ver = "0200"; /* Version 2.00 */ - switch (abfd->arch_info->arch) + + switch (bfd_get_arch (abfd)) { case bfd_arch_h8300: hd.au = 8; - hd.si = 32; - hd.afl = 2; - hd.spcsz = 0; + hd.si = 0; + hd.spcsz = 32; hd.segsz = 0; hd.segsh = 0; - hd.cpu = "H8300H"; - h8300 = 1; + switch (bfd_get_mach (abfd)) + { + case bfd_mach_h8300: + hd.cpu = "H8300"; + hd.afl = 2; + addrsize = 2; + toolname = "C_H8/300"; + break; + case bfd_mach_h8300h: + hd.cpu = "H8300H"; + hd.afl = 4; + addrsize = 4; + toolname = "C_H8/300H"; + break; + case bfd_mach_h8300s: + hd.cpu = "H8300S"; + hd.afl = 4; + addrsize = 4; + toolname = "C_H8/300S"; + break; + default: + fatal (_("Unrecognized H8300 sub-architecture: %ld"), + bfd_get_mach (abfd)); + } + rnames = rname_h8300; break; case bfd_arch_sh: hd.au = 8; - hd.si = 32; - hd.afl = 2; - hd.spcsz = 0; + hd.si = 0; + hd.afl = 4; + hd.spcsz = 32; hd.segsz = 0; hd.segsh = 0; hd.cpu = "SH"; - sh = 1; + addrsize = 4; + toolname = "C_SH"; + rnames = rname_sh; break; + default: + fatal (_("Unsupported architecture: %d"), bfd_get_arch (abfd)); } - if (!abfd->flags & EXEC_P) + if (! (bfd_get_file_flags(abfd) & EXEC_P)) { hd.ep = 0; } @@ -402,15 +392,14 @@ wr_hd (p) hd.os = ""; hd.sys = ""; - hd.mn = strip_suffix (abfd->filename); + hd.mn = strip_suffix (bfd_get_filename (abfd)); + sysroff_swap_hd_out (file, &hd); } static void -wr_sh (p, sec) - struct coff_ofile *p; - struct coff_section *sec; +wr_sh (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *sec) { struct IT_sh sh; sh.unit = 0; @@ -423,26 +412,26 @@ wr_sh (p, sec) static void -wr_ob (p, section) - struct coff_ofile *p; - struct coff_section *section; +wr_ob (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *section) { - int i; + bfd_size_type i; int first = 1; unsigned char stuff[200]; i = 0; - while (i < section->size) + while (i < bfd_section_size (section->bfd_section)) { struct IT_ob ob; - int todo = 200; /* Copy in 200 byte lumps */ - if (i + todo > section->size) - todo = section->size - i; + int todo = 200; /* Copy in 200 byte lumps. */ + + ob.spare = 0; + if (i + todo > bfd_section_size (section->bfd_section)) + todo = bfd_section_size (section->bfd_section) - i; if (first) { ob.saf = 1; - if (abfd->flags & EXEC_P) + if (bfd_get_file_flags (abfd) & EXEC_P) ob.address = section->address; else ob.address = 0; @@ -454,27 +443,47 @@ wr_ob (p, section) ob.saf = 0; } - ob.cpf = 0; /* Never compress */ + ob.cpf = 0; /* Never compress. */ ob.data.len = todo; bfd_get_section_contents (abfd, section->bfd_section, stuff, i, todo); ob.data.data = stuff; - sysroff_swap_ob_out (file, &ob, i + todo < section->size); + sysroff_swap_ob_out (file, &ob /*, i + todo < section->size */ ); i += todo; } + + /* Now fill the rest with blanks. */ + while (i < (bfd_size_type) section->size) + { + struct IT_ob ob; + int todo = 200; /* Copy in 200 byte lumps. */ + + ob.spare = 0; + if (i + todo > (bfd_size_type) section->size) + todo = section->size - i; + ob.saf = 0; + + ob.cpf = 0; /* Never compress. */ + ob.data.len = todo; + memset (stuff, 0, todo); + ob.data.data = stuff; + sysroff_swap_ob_out (file, &ob); + i += todo; + } + /* Now fill the rest with blanks. */ } static void -wr_rl (ptr, sec) - struct coff_ofile *ptr; - struct coff_section *sec; +wr_rl (struct coff_ofile *ptr ATTRIBUTE_UNUSED, struct coff_section *sec) { int nr = sec->nrelocs; int i; + for (i = 0; i < nr; i++) { struct coff_reloc *r = sec->relocs + i; struct coff_symbol *ref; struct IT_rl rl; + rl.apol = 0; rl.boundary = 0; rl.segment = 1; @@ -482,18 +491,19 @@ wr_rl (ptr, sec) rl.check = 0; rl.addr = r->offset; rl.bitloc = 0; - rl.flen = 32; /* SH Specific */ - /* What sort of reloc ? Look in the section to find out */ + rl.flen = 32; /* SH Specific. */ + + /* What sort of reloc ? Look in the section to find out. */ ref = r->symbol; if (ref->visible->type == coff_vis_ext_ref) { - rl.bcount = 4; /* Always 4 for us */ + rl.bcount = 4; /* Always 4 for us. */ rl.op = OP_EXT_REF; rl.symn = ref->er_number; } else if (ref->visible->type == coff_vis_common) { - rl.bcount = 11; /* Always 11 for us */ + rl.bcount = 11; /* Always 11 for us. */ rl.op = OP_SEC_REF; rl.secn = ref->where->section->number; rl.copcode_is_3 = 3; @@ -501,10 +511,9 @@ wr_rl (ptr, sec) rl.addend = ref->where->offset - ref->where->section->address; rl.aopcode_is_0x20 = 0x20; } - else { - rl.bcount = 11; /* Always 11 for us */ + rl.bcount = 11; /* Always 11 for us. */ rl.op = OP_SEC_REF; rl.secn = ref->where->section->number; rl.copcode_is_3 = 3; @@ -512,20 +521,20 @@ wr_rl (ptr, sec) rl.addend = -ref->where->section->address; rl.aopcode_is_0x20 = 0x20; } + rl.end = 0xff; - if (rl.op == OP_SEC_REF + + if ( rl.op == OP_SEC_REF || rl.op == OP_EXT_REF) - { - sysroff_swap_rl_out (file, &rl); - } + sysroff_swap_rl_out (file, &rl); } } static void -wr_object_body (p) - struct coff_ofile *p; +wr_object_body (struct coff_ofile *p) { int i; + for (i = 1; i < p->nsections; i++) { wr_sh (p, p->sections + i); @@ -535,30 +544,36 @@ wr_object_body (p) } static void -wr_dps_start (sfile, section, scope, type, nest) - struct coff_sfile *sfile; - struct coff_section *section; - struct coff_scope *scope; - int type; +wr_dps_start (struct coff_sfile *sfile, + struct coff_section *section ATTRIBUTE_UNUSED, + struct coff_scope *scope, int type, int nest) { struct IT_dps dps; + dps.end = 0; dps.opt = 0; dps.type = type; + if (scope->sec) { dps.san = scope->sec->number; dps.address = scope->offset - find_base (sfile, scope->sec); dps.block_size = scope->size; + if (debug) { printf ("DPS %s %d %x\n", sfile->name, nest, dps.address); - } } + else + { + dps.san = 0; + dps.address = 0; + dps.block_size = 0; + } dps.nesting = nest; dps.neg = 0x1001; @@ -566,31 +581,25 @@ wr_dps_start (sfile, section, scope, type, nest) } static void -wr_dps_end (section, scope, type) - struct coff_section *section; - struct coff_scope *scope; - int type; +wr_dps_end (struct coff_section *section ATTRIBUTE_UNUSED, + struct coff_scope *scope ATTRIBUTE_UNUSED, int type) { struct IT_dps dps; + dps.end = 1; dps.type = type; sysroff_swap_dps_out (file, &dps); } static int * -nints (x) - int x; +nints (int x) { return (int *) (xcalloc (sizeof (int), x)); } -static void walk_tree_symbol (); static void -walk_tree_type_1 (sfile, symbol, type, nest) - struct coff_sfile *sfile; - struct coff_symbol *symbol; - struct coff_type *type; - int nest; +walk_tree_type_1 (struct coff_sfile *sfile, struct coff_symbol *symbol, + struct coff_type *type, int nest) { switch (type->type) { @@ -607,11 +616,13 @@ walk_tree_type_1 (sfile, symbol, type, nest) dbt.sign = BTYPE_UNSPEC; dbt.fptype = FPTYPE_NOTSPEC; break; + case T_CHAR: dbt.btype = BTYPE_CHAR; dbt.sign = BTYPE_UNSPEC; dbt.fptype = FPTYPE_NOTSPEC; break; + case T_SHORT: case T_INT: case T_LONG: @@ -619,23 +630,28 @@ walk_tree_type_1 (sfile, symbol, type, nest) dbt.sign = SIGN_SIGNED; dbt.fptype = FPTYPE_NOTSPEC; break; + case T_FLOAT: dbt.btype = BTYPE_FLOAT; dbt.fptype = FPTYPE_SINGLE; break; + case T_DOUBLE: dbt.btype = BTYPE_FLOAT; dbt.fptype = FPTYPE_DOUBLE; break; + case T_LNGDBL: dbt.btype = BTYPE_FLOAT; dbt.fptype = FPTYPE_EXTENDED; break; + case T_UCHAR: dbt.btype = BTYPE_CHAR; dbt.sign = SIGN_UNSIGNED; dbt.fptype = FPTYPE_NOTSPEC; break; + case T_USHORT: case T_UINT: case T_ULONG: @@ -644,14 +660,18 @@ walk_tree_type_1 (sfile, symbol, type, nest) dbt.fptype = FPTYPE_NOTSPEC; break; } + dbt.bitsize = type->size; dbt.neg = 0x1001; sysroff_swap_dbt_out (file, &dbt); break; } + case coff_pointer_type: { struct IT_dpt dpt; + + dpt.dunno = 0; walk_tree_type_1 (sfile, symbol, type->u.pointer.points_to, nest + 1); dpt.neg = 0x1001; sysroff_swap_dpt_out (file, &dpt); @@ -662,7 +682,9 @@ walk_tree_type_1 (sfile, symbol, type, nest) { struct IT_dfp dfp; struct coff_symbol *param; + dfp.end = 0; + dfp.spare = 0; dfp.nparams = type->u.function.parameters->nvars; dfp.neg = 0x1001; @@ -673,9 +695,8 @@ walk_tree_type_1 (sfile, symbol, type, nest) for (param = type->u.function.parameters->vars_head; param; param = param->next) - { - walk_tree_symbol (sfile, 0, param, nest); - } + walk_tree_symbol (sfile, 0, param, nest); + dfp.end = 1; sysroff_swap_dfp_out (file, &dfp); break; @@ -686,6 +707,8 @@ walk_tree_type_1 (sfile, symbol, type, nest) struct IT_dbt dbt; struct IT_dds dds; struct coff_symbol *member; + + dds.spare = 0; dbt.btype = BTYPE_STRUCT; dbt.bitsize = type->size; dbt.sign = SIGN_UNSPEC; @@ -696,43 +719,43 @@ walk_tree_type_1 (sfile, symbol, type, nest) dds.end = 0; dds.neg = 0x1001; sysroff_swap_dds_out (file, &dds); + for (member = type->u.astructdef.elements->vars_head; member; member = member->next) - { - walk_tree_symbol (sfile, 0, member, nest + 1); - } + walk_tree_symbol (sfile, 0, member, nest + 1); dds.end = 1; sysroff_swap_dds_out (file, &dds); } break; + case coff_structref_type: { struct IT_dbt dbt; + dbt.btype = BTYPE_TAG; dbt.bitsize = type->size; dbt.sign = SIGN_UNSPEC; dbt.fptype = FPTYPE_NOTSPEC; + if (type->u.astructref.ref) - { - dbt.sid = get_member_id (type->u.astructref.ref->number); - } + dbt.sid = get_member_id (type->u.astructref.ref->number); else - { - dbt.sid = 0; - } + dbt.sid = 0; dbt.neg = 0x1001; sysroff_swap_dbt_out (file, &dbt); } break; + case coff_array_type: { struct IT_dar dar; int j; - int dims = 1; /* Only output one dimension at a time */ + int dims = 1; /* Only output one dimension at a time. */ + dar.dims = dims; dar.variable = nints (dims); dar.subtype = nints (dims); @@ -744,10 +767,13 @@ walk_tree_type_1 (sfile, symbol, type, nest) dar.min = nints (dims); dar.minspare = nints (dims); dar.neg = 0x1001; + dar.length = type->size / type->u.array.dim; + for (j = 0; j < dims; j++) { dar.variable[j] = VARIABLE_FIXED; dar.subtype[j] = SUB_INTEGER; + dar.spare[j] = 0; dar.max_variable[j] = 0; dar.max[j] = type->u.array.dim; dar.min_variable[j] = 0; @@ -757,11 +783,13 @@ walk_tree_type_1 (sfile, symbol, type, nest) sysroff_swap_dar_out (file, &dar); } break; + case coff_enumdef_type: { struct IT_dbt dbt; struct IT_den den; struct coff_symbol *member; + dbt.btype = BTYPE_ENUM; dbt.bitsize = type->size; dbt.sign = SIGN_UNSPEC; @@ -772,23 +800,23 @@ walk_tree_type_1 (sfile, symbol, type, nest) den.end = 0; den.neg = 0x1001; + den.spare = 0; sysroff_swap_den_out (file, &den); + for (member = type->u.aenumdef.elements->vars_head; member; member = member->next) - { - walk_tree_symbol (sfile, 0, member, nest + 1); - } + walk_tree_symbol (sfile, 0, member, nest + 1); den.end = 1; sysroff_swap_den_out (file, &den); } break; - break; case coff_enumref_type: { struct IT_dbt dbt; + dbt.btype = BTYPE_TAG; dbt.bitsize = type->size; dbt.sign = SIGN_UNSPEC; @@ -798,321 +826,310 @@ walk_tree_type_1 (sfile, symbol, type, nest) sysroff_swap_dbt_out (file, &dbt); } break; + default: - abort (); + fatal (_("Unrecognised type: %d"), type->type); } } -static void -dty_start () -{ - struct IT_dty dty; - dty.end = 0; - dty.neg = 0x1001; - sysroff_swap_dty_out (file, &dty); -} +/* Obsolete ? + static void + dty_start () + { + struct IT_dty dty; + dty.end = 0; + dty.neg = 0x1001; + dty.spare = 0; + sysroff_swap_dty_out (file, &dty); + } + + static void + dty_stop () + { + struct IT_dty dty; + dty.end = 0; + dty.neg = 0x1001; + dty.end = 1; + sysroff_swap_dty_out (file, &dty); + } + + + static void + dump_tree_structure (sfile, symbol, type, nest) + struct coff_sfile *sfile; + struct coff_symbol *symbol; + struct coff_type *type; + int nest; + { + if (symbol->type->type == coff_function_type) + { + + + } + + } + */ static void -dty_stop () +walk_tree_type (struct coff_sfile *sfile, struct coff_symbol *symbol, + struct coff_type *type, int nest) { struct IT_dty dty; + + dty.spare = 0; dty.end = 0; dty.neg = 0x1001; - dty.end = 1; - sysroff_swap_dty_out (file, &dty); -} - -static void -dump_tree_structure (sfile, symbol, type, nest) - struct coff_sfile *sfile; - struct coff_symbol *symbol; - struct coff_type *type; - int nest; -{ if (symbol->type->type == coff_function_type) { - - - } - -} - - -static void -walk_tree_type (sfile, symbol, type, nest) - - struct - coff_sfile *sfile; - struct coff_symbol *symbol; - struct coff_type *type; - int nest; -{ - if (symbol->type->type == coff_function_type) - { - - struct IT_dty dty; - dty.end = 0; - dty.neg = 0x1001; - sysroff_swap_dty_out (file, &dty); walk_tree_type_1 (sfile, symbol, type, nest); dty.end = 1; sysroff_swap_dty_out (file, &dty); - wr_dps_start (sfile, - symbol->where->section, - symbol->type->u.function.code, + wr_dps_start (sfile, + symbol->where->section, + symbol->type->u.function.code, BLOCK_TYPE_FUNCTION, nest); wr_dps_start (sfile, symbol->where->section, symbol->type->u.function.code, BLOCK_TYPE_BLOCK, nest); walk_tree_scope (symbol->where->section, sfile, - symbol->type->u.function.code, + symbol->type->u.function.code, nest + 1, BLOCK_TYPE_BLOCK); - wr_dps_end (symbol->where->section, - symbol->type->u.function.code, - BLOCK_TYPE_BLOCK, nest); - wr_dps_end (symbol->where->section, - symbol->type->u.function.code, BLOCK_TYPE_FUNCTION, nest); - + wr_dps_end (symbol->where->section, + symbol->type->u.function.code, + BLOCK_TYPE_BLOCK); + wr_dps_end (symbol->where->section, + symbol->type->u.function.code, BLOCK_TYPE_FUNCTION); } else { - struct IT_dty dty; - dty.end = 0; - dty.neg = 0x1001; sysroff_swap_dty_out (file, &dty); walk_tree_type_1 (sfile, symbol, type, nest); dty.end = 1; sysroff_swap_dty_out (file, &dty); } - } - - static void -walk_tree_symbol (sfile, section, symbol, nest) - struct coff_sfile *sfile; - struct coff_section *section; - struct coff_symbol *symbol; - int nest; +walk_tree_symbol (struct coff_sfile *sfile, struct coff_section *section ATTRIBUTE_UNUSED, struct coff_symbol *symbol, int nest) { struct IT_dsy dsy; + memset (&dsy, 0, sizeof(dsy)); + dsy.nesting = nest; - dsy.nesting = nest; + switch (symbol->type->type) + { + case coff_function_type: + dsy.type = STYPE_FUNC; + dsy.assign = 1; + break; - switch (symbol->type->type) - { - case coff_function_type: - dsy.type = STYPE_FUNC; - dsy.assign = 1; - break; - case coff_structref_type: - case coff_pointer_type: - case coff_array_type: - case coff_basic_type: - case coff_enumref_type: - dsy.type = STYPE_VAR; - dsy.assign = 1; - break; - case coff_enumdef_type: - dsy.type = STYPE_TAG; - dsy.assign = 0; - dsy.magic = 2; - break; - case coff_structdef_type: - dsy.type = STYPE_TAG; - dsy.assign = 0; - dsy.magic = symbol->type->u.astructdef.isstruct ? 0 : 1; - break; - case coff_secdef_type: - return; - default: - abort (); - } + case coff_structref_type: + case coff_pointer_type: + case coff_array_type: + case coff_basic_type: + case coff_enumref_type: + dsy.type = STYPE_VAR; + dsy.assign = 1; + break; - if (symbol->where->where == coff_where_member_of_struct) - { - dsy.assign = 0; - dsy.type = STYPE_MEMBER; - } - if (symbol->where->where == coff_where_member_of_enum) - { - dsy.type = STYPE_ENUM; - dsy.assign = 0; - dsy.vallen = 4; - dsy.value = symbol->where->offset; - } + case coff_enumdef_type: + dsy.type = STYPE_TAG; + dsy.assign = 0; + dsy.magic = 2; + break; - if (symbol->type->type == coff_structdef_type - || symbol->where->where == coff_where_entag - || symbol->where->where == coff_where_strtag) - { - dsy.snumber = get_member_id (symbol->number); - } - else - { - dsy.snumber = get_ordinary_id (symbol->number); - } + case coff_structdef_type: + dsy.type = STYPE_TAG; + dsy.assign = 0; + dsy.magic = symbol->type->u.astructdef.isstruct ? 0 : 1; + break; + case coff_secdef_type: + return; - dsy.sname = symbol->name[0] == '_' ? symbol->name + 1 : symbol->name; + default: + fatal (_("Unrecognised coff symbol type: %d"), symbol->type->type); + } - switch (symbol->visible->type) - { - case coff_vis_common: - case coff_vis_ext_def: - dsy.ainfo = AINFO_STATIC_EXT_DEF; - break; - case coff_vis_ext_ref: - dsy.ainfo = AINFO_STATIC_EXT_REF; - break; - case coff_vis_int_def: - dsy.ainfo = AINFO_STATIC_INT; - break; - case coff_vis_auto: - case coff_vis_autoparam: - dsy.ainfo = AINFO_AUTO; - break; - case coff_vis_register: - case coff_vis_regparam: - dsy.ainfo = AINFO_REG; - break; - break; - case coff_vis_tag: - case coff_vis_member_of_struct: - case coff_vis_member_of_enum: - break; - default: - abort (); - } + if (symbol->where->where == coff_where_member_of_struct) + { + dsy.assign = 0; + dsy.type = STYPE_MEMBER; + } - dsy.dlength = symbol->type->size; - switch (symbol->where->where) - { - case coff_where_memory: + if (symbol->where->where == coff_where_member_of_enum) + { + dsy.type = STYPE_ENUM; + dsy.assign = 0; + dsy.evallen = 4; + dsy.evalue = symbol->where->offset; + } + + if (symbol->type->type == coff_structdef_type + || symbol->where->where == coff_where_entag + || symbol->where->where == coff_where_strtag) + { + dsy.snumber = get_member_id (symbol->number); + } + else + { + dsy.snumber = get_ordinary_id (symbol->number); + } + + dsy.sname = symbol->name[0] == '_' ? symbol->name + 1 : symbol->name; + + switch (symbol->visible->type) + { + case coff_vis_common: + case coff_vis_ext_def: + dsy.ainfo = AINFO_STATIC_EXT_DEF; + break; + + case coff_vis_ext_ref: + dsy.ainfo = AINFO_STATIC_EXT_REF; + break; + + case coff_vis_int_def: + dsy.ainfo = AINFO_STATIC_INT; + break; - dsy.section = symbol->where->section->number; + case coff_vis_auto: + case coff_vis_autoparam: + dsy.ainfo = AINFO_AUTO; + break; + + case coff_vis_register: + case coff_vis_regparam: + dsy.ainfo = AINFO_REG; + break; + break; + + case coff_vis_tag: + case coff_vis_member_of_struct: + case coff_vis_member_of_enum: + break; + + default: + fatal (_("Unrecognised coff symbol visibility: %d"), symbol->visible->type); + } + + dsy.dlength = symbol->type->size; + + switch (symbol->where->where) + { + case coff_where_memory: + + dsy.section = symbol->where->section->number; #ifdef FOOP - dsy.section = 0; + dsy.section = 0; #endif - break; - case coff_where_member_of_struct: - case coff_where_member_of_enum: - case coff_where_stack: - case coff_where_register: - case coff_where_unknown: - case coff_where_strtag: - - case coff_where_entag: - case coff_where_typedef: - break; - default: - abort (); - } + break; - switch (symbol->where->where) - { - case coff_where_memory: - dsy.address = symbol->where->offset - find_base (sfile, symbol->where->section); - break; - case coff_where_stack: - dsy.address = symbol->where->offset; - break; - case coff_where_member_of_struct: + case coff_where_member_of_struct: + case coff_where_member_of_enum: + case coff_where_stack: + case coff_where_register: + case coff_where_unknown: + case coff_where_strtag: + case coff_where_entag: + case coff_where_typedef: + break; + default: + fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where); + } - if (symbol->where->bitsize) - { - int bits = (symbol->where->offset * 8 + symbol->where->bitoffset); - dsy.bitunit = 1; - dsy.field_len = symbol->where->bitsize; - dsy.field_off = (bits / 32) * 4; - dsy.field_bitoff = bits % 32; - } - else - { - dsy.bitunit = 0; + switch (symbol->where->where) + { + case coff_where_memory: + dsy.address = symbol->where->offset - find_base (sfile, symbol->where->section); + break; - dsy.field_len = symbol->type->size; - dsy.field_off = symbol->where->offset; - } - break; - case coff_where_member_of_enum: - /* dsy.bitunit = 0; - dsy.field_len = symbol->type->size; - dsy.field_off = symbol->where->offset;*/ - break; - case coff_where_register: - case coff_where_unknown: - case coff_where_strtag: + case coff_where_stack: + dsy.address = symbol->where->offset; + break; - case coff_where_entag: - case coff_where_typedef: - break; - default: - abort (); - } + case coff_where_member_of_struct: + if (symbol->where->bitsize) + { + int bits = (symbol->where->offset * 8 + symbol->where->bitoffset); + dsy.bitunit = 1; + dsy.field_len = symbol->where->bitsize; + dsy.field_off = (bits / 32) * 4; + dsy.field_bitoff = bits % 32; + } + else + { + dsy.bitunit = 0; - if (symbol->where->where == coff_where_register) - { - if (sh) - dsy.reg = rname_sh[symbol->where->offset]; - if (h8300) - dsy.reg = rname_h8300[symbol->where->offset]; - } + dsy.field_len = symbol->type->size; + dsy.field_off = symbol->where->offset; + } + break; - switch (symbol->visible->type) - { - case coff_vis_common: - /* We do this 'cause common C symbols are treated as extdefs */ - case coff_vis_ext_def: - case coff_vis_ext_ref: + case coff_where_member_of_enum: + /* dsy.bitunit = 0; + dsy.field_len = symbol->type->size; + dsy.field_off = symbol->where->offset; */ + break; - dsy.ename = symbol->name; - break; + case coff_where_register: + case coff_where_unknown: + case coff_where_strtag: + case coff_where_entag: + case coff_where_typedef: + break; - case coff_vis_regparam: - case coff_vis_autoparam: - dsy.type = STYPE_PARAMETER; - break; + default: + fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where); + } - case coff_vis_int_def: + if (symbol->where->where == coff_where_register) + dsy.reg = rnames[symbol->where->offset]; - case coff_vis_auto: - case coff_vis_register: - case coff_vis_tag: - case coff_vis_member_of_struct: - case coff_vis_member_of_enum: - break; - default: - abort (); - } + switch (symbol->visible->type) + { + case coff_vis_common: + /* We do this 'cause common C symbols are treated as extdefs. */ + case coff_vis_ext_def: + case coff_vis_ext_ref: + dsy.ename = symbol->name; + break; - dsy.sfn = 0; - dsy.sln = 2; + case coff_vis_regparam: + case coff_vis_autoparam: + dsy.type = STYPE_PARAMETER; + break; - dsy.neg = 0x1001; + case coff_vis_int_def: + case coff_vis_auto: + case coff_vis_register: + case coff_vis_tag: + case coff_vis_member_of_struct: + case coff_vis_member_of_enum: + break; + default: + fatal (_("Unrecognised coff symbol visibility: %d"), symbol->visible->type); + } - sysroff_swap_dsy_out (file, &dsy); + dsy.sfn = 0; + dsy.sln = 2; + dsy.neg = 0x1001; - walk_tree_type (sfile, symbol, symbol->type, nest); -} + sysroff_swap_dsy_out (file, &dsy); + walk_tree_type (sfile, symbol, symbol->type, nest); +} static void -walk_tree_scope (section, sfile, scope, nest, type) - struct coff_section *section; - struct coff_sfile *sfile; - struct coff_scope *scope; - int nest; - int type; +walk_tree_scope (struct coff_section *section, struct coff_sfile *sfile, struct coff_scope *scope, int nest, int type) { struct coff_symbol *vars; struct coff_scope *child; @@ -1126,54 +1143,43 @@ walk_tree_scope (section, sfile, scope, nest, type) wr_globals (tree, sfile, nest + 1); for (vars = scope->vars_head; vars; vars = vars->next) - { - walk_tree_symbol (sfile, section, vars, nest); - } + walk_tree_symbol (sfile, section, vars, nest); for (child = scope->list_head; child; child = child->next) - { - walk_tree_scope (section, sfile, child, nest + 1, BLOCK_TYPE_BLOCK); - } + walk_tree_scope (section, sfile, child, nest + 1, BLOCK_TYPE_BLOCK); wr_dps_end (section, scope, type); } } + static void -walk_tree_sfile (section, sfile) - struct coff_section *section; - struct coff_sfile *sfile; +walk_tree_sfile (struct coff_section *section, struct coff_sfile *sfile) { walk_tree_scope (section, sfile, sfile->scope, 0, BLOCK_TYPE_COMPUNIT); - } static void -wr_program_structure (p, sfile) - struct coff_ofile *p; - struct coff_sfile *sfile; +wr_program_structure (struct coff_ofile *p, struct coff_sfile *sfile) { - + if (p->nsections < 4) + return; walk_tree_sfile (p->sections + 4, sfile); - } static void -wr_du (p, sfile, n) - struct coff_ofile *p; - struct coff_sfile *sfile; - int n; +wr_du (struct coff_ofile *p, struct coff_sfile *sfile, int n) { struct IT_du du; int lim; - struct coff_symbol *symbol; - static int incit = 0x500000; int i; int j; - int used = 0; unsigned int *lowest = (unsigned *) nints (p->nsections); unsigned int *highest = (unsigned *) nints (p->nsections); - du.format = abfd->flags & EXEC_P ? 0 : 1; + + du.format = bfd_get_file_flags (abfd) & EXEC_P ? 0 : 1; du.optimized = 0; + du.stackfrmt = 0; + du.spare = 0; du.unit = n; du.sections = p->nsections - 1; du.san = (int *) xcalloc (sizeof (int), du.sections); @@ -1186,59 +1192,19 @@ wr_du (p, sfile, n) highest[i] = 0; } - /* Look through all the symbols and try and work out the extents in this - source file */ -#if 0 - for (symbol = sfile->scope->vars_head; - symbol; - symbol = symbol->next) - { - if (symbol->type->type == coff_secdef_type) - { - unsigned int low = symbol->where->offset; - unsigned int high = symbol->where->offset + symbol->type->size - 1; - struct coff_section *section = symbol->where->section; - - int sn = section->number; - if (low < lowest[sn]) - lowest[sn] = low; - if (high > highest[sn]) - highest[sn] = high; - } - } - - - for (i = 0; i < du.sections; i++) - { - if (highest[i] == 0) - { - lowest[i] = highest[i] = incit; - } - du.san[used] = i; - du.length[used] = highest[i] - lowest[i]; - du.address[used] = abfd->flags & EXEC_P ? lowest[i] : 0; - if (debug) - { - printf (" section %6s 0x%08x..0x%08x\n", - p->sections[i + 1].name, - lowest[i], - highest[i]); - } - used++; - } - -#endif lim = du.sections; for (j = 0; j < lim; j++) { int src = j; int dst = j; + du.san[dst] = dst; + if (sfile->section[src].init) { - du.length[dst] + du.length[dst] = sfile->section[src].high - sfile->section[src].low + 1; - du.address[dst] + du.address[dst] = sfile->section[src].low; } else @@ -1246,6 +1212,7 @@ wr_du (p, sfile, n) du.length[dst] = 0; du.address[dst] = 0; } + if (debug) { if (sfile->section[src].parent) @@ -1256,6 +1223,7 @@ wr_du (p, sfile, n) du.address[dst] + du.length[dst] - 1); } } + du.sections = dst + 1; } @@ -1266,121 +1234,37 @@ wr_du (p, sfile, n) } static void -wr_dus (p, sfile) - struct coff_ofile *p; - struct coff_sfile *sfile; +wr_dus (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile) { - struct IT_dus dus; - int i; dus.efn = 0x1001; - dus.ns = 1 ; /* p->nsources; sac 14 jul 94 */ + dus.ns = 1; /* p->nsources; sac 14 jul 94 */ dus.drb = nints (dus.ns); dus.fname = (char **) xcalloc (sizeof (char *), dus.ns); dus.spare = nints (dus.ns); dus.ndir = 0; - /* Find the filenames */ -#if 0 - i = 0; - - for (sfile = p->source_head; - sfile; - sfile = sfile->next) - { - dus.drb[i] = 0; - dus.fname[i] = sfile->name; - i++; - } -#else + /* Find the filenames. */ dus.drb[0] = 0; dus.fname[0] = sfile->name; -#endif sysroff_swap_dus_out (file, &dus); } /* Find the offset of the .text section for this sfile in the - .text section for the output file */ + .text section for the output file. */ static int -find_base (sfile, section) - struct coff_sfile *sfile; - struct coff_section *section; +find_base (struct coff_sfile *sfile, struct coff_section *section) { return sfile->section[section->number].low; } -static void -wr_dln (p, sfile, n) - struct coff_ofile *p; - struct coff_sfile *sfile; - int n; +static void +wr_dln (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile, + int n ATTRIBUTE_UNUSED) { -#if 0 - if (n == 0) - { - /* Count up all the linenumbers */ - struct coff_symbol *sy; - int lc = 0; - struct IT_dln dln; - - int idx; - - for (sy = p->symbol_list_head; - sy; - sy = sy->next_in_ofile_list) - { - struct coff_type *t = sy->type; - if (t->type == coff_function_type) - { - struct coff_line *l = t->u.function.lines; - lc += l->nlines; - } - } - - dln.sfn = nints (lc); - dln.sln = nints (lc); - dln.lln = nints (lc); - dln.section = nints (lc); - - dln.from_address = nints (lc); - dln.to_address = nints (lc); - - - dln.neg = 0x1001; - - dln.nln = lc; - - /* Run through once more and fill up the structure */ - idx = 0; - for (sy = p->symbol_list_head; - sy; - sy = sy->next_in_ofile_list) - { - if (sy->type->type == coff_function_type) - { - int i; - struct coff_line *l = sy->type->u.function.lines; - for (i = 0; i < l->nlines; i++) - { - dln.section[idx] = sy->where->section->number; - dln.sfn[idx] = n; - dln.sln[idx] = l->lines[i]; - dln.from_address[idx] = l->addresses[i]; - if (idx) - dln.to_address[idx - 1] = dln.from_address[idx]; - idx++; - } - } - n++; - } - sysroff_swap_dln_out (file, &dln); - } - -#endif -#if 1 /* Count up all the linenumbers */ struct coff_symbol *sy; @@ -1425,38 +1309,38 @@ wr_dln (p, sfile, n) { int i; struct coff_line *l = sy->type->u.function.lines; - if (l) { - int base = find_base (sfile, sy->where->section); - for (i = 0; i < l->nlines; i++) - { - dln.section[idx] = sy->where->section->number; - dln.sfn[idx] = 0; - dln.sln[idx] = l->lines[i]; - dln.from_address[idx] = - l->addresses[i] + sy->where->section->address - base; - dln.cc[idx] = 0; - if (idx) - dln.to_address[idx - 1] = dln.from_address[idx]; - idx++; - - } - dln.to_address[idx - 1] = dln.from_address[idx - 1] + 2; - } + if (l) + { + int base = find_base (sfile, sy->where->section); + for (i = 0; i < l->nlines; i++) + { + dln.section[idx] = sy->where->section->number; + dln.sfn[idx] = 0; + dln.sln[idx] = l->lines[i]; + dln.from_address[idx] = + l->addresses[i] + sy->where->section->address - base; + dln.cc[idx] = 0; + if (idx) + dln.to_address[idx - 1] = dln.from_address[idx]; + idx++; + + } + dln.to_address[idx - 1] = dln.from_address[idx - 1] + 2; + } } } if (lc) sysroff_swap_dln_out (file, &dln); -#endif } -/* Write the global symbols out to the debug info */ +/* Write the global symbols out to the debug info. */ + static void -wr_globals (p, sfile, n) - struct coff_ofile *p; - struct coff_sfile *sfile; - int n; +wr_globals (struct coff_ofile *p, struct coff_sfile *sfile, + int n ATTRIBUTE_UNUSED) { struct coff_symbol *sy; + for (sy = p->symbol_list_head; sy; sy = sy->next_in_ofile_list) @@ -1465,72 +1349,100 @@ wr_globals (p, sfile, n) || sy->visible->type == coff_vis_ext_ref) { /* Only write out symbols if they belong to - the current source file */ + the current source file. */ if (sy->sfile == sfile) walk_tree_symbol (sfile, 0, sy, 0); - } } } static void -wr_debug (p) - struct coff_ofile *p; +wr_debug (struct coff_ofile *p) { struct coff_sfile *sfile; int n = 0; + for (sfile = p->source_head; sfile; sfile = sfile->next) - { if (debug) - { - printf ("%s\n", sfile->name); - } + printf ("%s\n", sfile->name); + wr_du (p, sfile, n); wr_dus (p, sfile); - wr_program_structure (p, sfile, n); + wr_program_structure (p, sfile); wr_dln (p, sfile, n); n++; } } + static void -wr_cs () +wr_cs (void) { /* It seems that the CS struct is not normal - the size is wrong - heres one I prepared earlier.. */ + heres one I prepared earlier. */ static char b[] = - {0x80, 0x21, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x80, 0x80, - 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x80, 0x00, - 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0xde}; - fwrite (b, 1, sizeof (b), file); + { + 0x80, /* IT */ + 0x21, /* RL */ + 0x00, /* number of chars in variable length part */ + 0x80, /* hd */ + 0x00, /* hs */ + 0x80, /* un */ + 0x00, /* us */ + 0x80, /* sc */ + 0x00, /* ss */ + 0x80, /* er */ + 0x80, /* ed */ + 0x80, /* sh */ + 0x80, /* ob */ + 0x80, /* rl */ + 0x80, /* du */ + 0x80, /* dps */ + 0x80, /* dsy */ + 0x80, /* dty */ + 0x80, /* dln */ + 0x80, /* dso */ + 0x80, /* dus */ + 0x00, /* dss */ + 0x80, /* dbt */ + 0x00, /* dpp */ + 0x80, /* dfp */ + 0x80, /* den */ + 0x80, /* dds */ + 0x80, /* dar */ + 0x80, /* dpt */ + 0x00, /* dul */ + 0x00, /* dse */ + 0x00, /* dot */ + 0xDE /* CS */ + }; + + if (fwrite (b, sizeof (b), 1, file) != 1) + /* FIXME: Return error status. */ + fatal (_("Failed to write CS struct")); } /* Write out the SC records for a unit. Create an SC for all the sections which appear in the output file, even - if there isn't an equivalent one on the input */ + if there isn't an equivalent one on the input. */ -static void -wr_sc (ptr, sfile) - struct coff_ofile *ptr; - struct coff_sfile *sfile; +static int +wr_sc (struct coff_ofile *ptr, struct coff_sfile *sfile) { int i; - /* First work out the total number of sections */ - + int scount = 0; + /* First work out the total number of sections. */ int total_sec = ptr->nsections; - struct myinfo { struct coff_section *sec; struct coff_symbol *symbol; - } myinfo; + }; struct coff_symbol *symbol; - struct myinfo *info - = (struct myinfo *) calloc (total_sec, sizeof (struct myinfo)); - + = (struct myinfo *) calloc (total_sec, sizeof (struct myinfo)); for (i = 0; i < total_sec; i++) @@ -1558,29 +1470,28 @@ wr_sc (ptr, sfile) } /* Now output all the section info, and fake up some stuff for sections - we don't have */ - + we don't have. */ for (i = 1; i < total_sec; i++) { struct IT_sc sc; char *name; + symbol = info[i].symbol; + sc.spare = 0; + sc.spare1 = 0; if (!symbol) { - /* Don't have a symbol set aside for this section, which means that nothing - in this file does anything for the section. */ - sc.format = !(abfd->flags & EXEC_P); + /* Don't have a symbol set aside for this section, which means + that nothing in this file does anything for the section. */ + sc.format = !(bfd_get_file_flags (abfd) & EXEC_P); sc.addr = 0; sc.length = 0; name = info[i].sec->name; } else { - unsigned int low = symbol->where->offset; - unsigned int high = symbol->where->offset + symbol->type->size - 1; - - if (abfd->flags & EXEC_P) + if (bfd_get_file_flags (abfd) & EXEC_P) { sc.format = 0; sc.addr = symbol->where->offset; @@ -1595,7 +1506,6 @@ wr_sc (ptr, sfile) } sc.align = 4; - sc.concat = CONCAT_SIMPLE; sc.read = 3; sc.write = 3; @@ -1603,8 +1513,10 @@ wr_sc (ptr, sfile) sc.init = 3; sc.mode = 3; sc.spare = 0; - sc.spare1 = 0; /* If not zero, then it doesn't work */ + sc.segadd = 0; + sc.spare1 = 0; /* If not zero, then it doesn't work. */ sc.name = section_translate (name); + if (strlen (sc.name) == 1) { switch (sc.name[0]) @@ -1613,28 +1525,32 @@ wr_sc (ptr, sfile) case 'B': sc.contents = CONTENTS_DATA; break; + default: sc.contents = CONTENTS_CODE; } } - + else + { + sc.contents = CONTENTS_CODE; + } sysroff_swap_sc_out (file, &sc); - - - + scount++; } - + free (info); + return scount; } +/* Write out the ER records for a unit. */ + static void -wr_er (ptr, sfile, first) - struct coff_ofile *ptr; - struct coff_sfile *sfile; - int first; +wr_er (struct coff_ofile *ptr, struct coff_sfile *sfile ATTRIBUTE_UNUSED, + int first) { int idx = 0; struct coff_symbol *sym; + if (first) { for (sym = ptr->symbol_list_head; sym; sym = sym->next_in_ofile_list) @@ -1642,23 +1558,25 @@ wr_er (ptr, sfile, first) if (sym->visible->type == coff_vis_ext_ref) { struct IT_er er; + + er.spare = 0; er.type = ER_NOTSPEC; er.name = sym->name; sysroff_swap_er_out (file, &er); sym->er_number = idx++; - } } } } +/* Write out the ED records for a unit. */ + static void -wr_ed (ptr, sfile, first) - struct coff_ofile *ptr; - struct coff_file *sfile; - int first; +wr_ed (struct coff_ofile *ptr, struct coff_sfile *sfile ATTRIBUTE_UNUSED, + int first) { struct coff_symbol *s; + if (first) { for (s = ptr->symbol_list_head; s; s = s->next_in_ofile_list) @@ -1669,6 +1587,7 @@ wr_ed (ptr, sfile, first) struct IT_ed ed; ed.section = s->where->section->number; + ed.spare = 0; if (s->where->section->data) { @@ -1683,6 +1602,7 @@ wr_ed (ptr, sfile, first) ed.type = ED_TYPE_NOTSPEC; ed.type = ED_TYPE_DATA; } + ed.address = s->where->offset - s->where->section->address; ed.name = s->name; sysroff_swap_ed_out (file, &ed); @@ -1692,17 +1612,26 @@ wr_ed (ptr, sfile, first) } static void -wr_unit_info (ptr) - struct coff_ofile *ptr; +wr_unit_info (struct coff_ofile *ptr) { struct coff_sfile *sfile; int first = 1; + for (sfile = ptr->source_head; sfile; sfile = sfile->next) { - wr_un (ptr, sfile, first); - wr_sc (ptr, sfile, first); + long p1; + long p2; + int nsecs; + + p1 = ftell (file); + wr_un (ptr, sfile, first, 0); + nsecs = wr_sc (ptr, sfile); + p2 = ftell (file); + fseek (file, p1, SEEK_SET); + wr_un (ptr, sfile, first, nsecs); + fseek (file, p2, SEEK_SET); wr_er (ptr, sfile, first); wr_ed (ptr, sfile, first); first = 0; @@ -1710,8 +1639,7 @@ wr_unit_info (ptr) } static void -wr_module (p) - struct coff_ofile *p; +wr_module (struct coff_ofile *p) { wr_cs (); wr_hd (p); @@ -1722,31 +1650,34 @@ wr_module (p) } static int -align (x) - int x; +align (int x) { return (x + 3) & ~3; } /* Find all the common variables and turn them into - ordinary defs - dunno why, but thats what hitachi does with 'em */ + ordinary defs - dunno why, but thats what hitachi does with 'em. */ static void -prescan (tree) - struct coff_ofile *tree; +prescan (struct coff_ofile *otree) { struct coff_symbol *s; struct coff_section *common_section; - /* Find the common section - always section 3 */ - common_section = tree->sections + 3; - for (s = tree->symbol_list_head; + + if (otree->nsections < 3) + return; + + /* Find the common section - always section 3. */ + common_section = otree->sections + 3; + + for (s = otree->symbol_list_head; s; s = s->next_in_ofile_list) { if (s->visible->type == coff_vis_common) { struct coff_where *w = s->where; - /* s->visible->type = coff_vis_ext_def; leave it as common */ + /* s->visible->type = coff_vis_ext_def; leave it as common */ common_section->size = align (common_section->size); w->offset = common_section->size + common_section->address; w->section = common_section; @@ -1758,47 +1689,57 @@ prescan (tree) char *program_name; -static void -show_usage (file, status) - FILE *file; - int status; +ATTRIBUTE_NORETURN static void +show_usage (FILE *ffile, int status) { - fprintf (file, "Usage: %s [-dhVq] in-file [out-file]\n", program_name); + fprintf (ffile, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name); + fprintf (ffile, _("Convert a COFF object file into a SYSROFF object file\n")); + fprintf (ffile, _(" The options are:\n\ + -q --quick (Obsolete - ignored)\n\ + -n --noprescan Do not perform a scan to convert commons into defs\n\ + -d --debug Display information about what is being done\n\ + @ Read options from \n\ + -h --help Display this information\n\ + -v --version Print the program's version number\n")); + + if (REPORT_BUGS_TO[0] && status == 0) + fprintf (ffile, _("Report bugs to %s\n"), REPORT_BUGS_TO); exit (status); } -static void -show_help () -{ - printf ("%s: Convert a COFF object file into a SYSROFF object file\n", - program_name); - show_usage (stdout, 0); -} - - - int -main (ac, av) - int ac; - char *av[]; +main (int ac, char **av) { int opt; static struct option long_options[] = { {"debug", no_argument, 0, 'd'}, {"quick", no_argument, 0, 'q'}, + {"noprescan", no_argument, 0, 'n'}, {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'V'}, {NULL, no_argument, 0, 0} }; char **matching; char *input_file; - char *output_file; + +#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) + setlocale (LC_MESSAGES, ""); +#endif +#if defined (HAVE_SETLOCALE) + setlocale (LC_CTYPE, ""); +#endif + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + program_name = av[0]; xmalloc_set_program_name (program_name); + bfd_set_error_program_name (program_name); + + expandargv (&ac, &av); - while ((opt = getopt_long (ac, av, "dhVq", long_options, + while ((opt = getopt_long (ac, av, "dHhVvqn", long_options, (int *) NULL)) != EOF) { @@ -1807,21 +1748,26 @@ main (ac, av) case 'q': quick = 1; break; + case 'n': + noprescan = 1; + break; case 'd': debug = 1; break; + case 'H': case 'h': - show_help (); - /*NOTREACHED*/ + show_usage (stdout, 0); + /*NOTREACHED */ + case 'v': case 'V': - printf ("GNU %s version %s\n", program_name, PROGRAM_VERSION); + print_version ("srconv"); exit (0); - /*NOTREACHED*/ + /*NOTREACHED */ case 0: break; default: show_usage (stderr, 1); - /*NOTREACHED*/ + /*NOTREACHED */ } } @@ -1837,31 +1783,30 @@ main (ac, av) ++optind; if (optind < ac) show_usage (stderr, 1); - if (strcmp (input_file, output_file) == 0) + if (filename_cmp (input_file, output_file) == 0) { - fprintf (stderr, - "%s: input and output files must be different\n", - program_name); - exit (1); + fatal (_("input and output files must be different")); } } } + else + input_file = 0; if (!input_file) { - fprintf (stderr, "%s: no input file specified\n", - program_name); - exit (1); + fatal (_("no input file specified")); } if (!output_file) { /* Take a .o off the input file and stick on a .obj. If - it doesn't end in .o, then stick a .obj on anyway */ + it doesn't end in .o, then stick a .obj on anyway */ int len = strlen (input_file); + output_file = xmalloc (len + 5); strcpy (output_file, input_file); + if (len > 3 && output_file[len - 2] == '.' && output_file[len - 1] == 'o') @@ -1884,6 +1829,7 @@ main (ac, av) if (!bfd_check_format_matches (abfd, bfd_object, &matching)) { bfd_nonfatal (input_file); + if (bfd_get_error () == bfd_error_file_ambiguously_recognized) { list_matching_formats (matching); @@ -1892,17 +1838,21 @@ main (ac, av) exit (1); } - file = fopen (output_file, "w"); + file = fopen (output_file, FOPEN_WB); if (!file) - { - fprintf (stderr, "%s: unable to open output file %s\n", - program_name, output_file); - exit (1); - } + fatal (_("unable to open output file %s"), output_file); + + if (debug) + printf ("ids %d %d\n", base1, base2); tree = coff_grok (abfd); - prescan (tree); - wr_module (tree); + if (tree) + { + if (!noprescan) + prescan (tree); + + wr_module (tree); + } return 0; }