rocket-tools/riscv-gnu-toolchain/glibc.git - Unnamed repository; edit this file 'description' to name the repository.

Age	Commit message (Expand)	Author	Files	Lines
2014-02-17	[MicroBlaze]: Move MicroBlaze from ports to sysdeps.	David Holsgrove	1	-0/+1
2014-02-16	ia64: relocate out of ports/ subdir	Mike Frysinger	1	-1/+1
2014-02-12	Relocate alpha from ports to libc	Richard Henderson	1	-1/+1
2014-02-11	Relocate AArch64 from ports to libc.	Marcus Shawcroft	1	-1/+1
2014-02-10	Move mips from ports to libc.	Joseph Myers	1	-2/+2
2014-02-10	Move m68k from ports to libc	Andreas Schwab	1	-1/+1
2014-02-10	Move tilegx, tilepro, and linux-generic from ports to libc.	Chris Metcalf	1	-2/+2
2014-02-08	Move arm from ports to libc.	Joseph Myers	1	-1/+1
2014-02-08	Remove am33 port.	Joseph Myers	1	-1/+0
2013-10-07	Fix careless merge.	Alan Modra	1	-1/+1
2013-10-05	Mention powerpc64le support in NEWS and README, plus bugs fixed.	Alan Modra	1	-2/+2
2013-10-04	Move powerpc ports pieces to libc.	Joseph Myers	1	-2/+1
2013-04-06	i386: Fail at configure time for i386 builds.	Carlos O'Donell	1	-1/+1
2013-01-02	Update miscellaneous copyright dates.	Joseph Myers	1	-1/+1
2012-12-05	Ports-related README updates.	Joseph Myers	1	-4/+3
2012-08-07	Remove pre-2.6.16 Linux kernel support.	Joseph Myers	1	-11/+6
2012-08-03	Remove pre-2.6.0 Linux kernel support (bug 13717).	Joseph Myers	1	-8/+2
2012-06-30	Update NEWS and README.glibc-2.16	Carlos O'Donell	1	-3/+5
2012-04-27	Update README to describe current supported systems.	Joseph Myers	1	-30/+24
2012-03-21	Remove NOTES.	Joseph Myers	1	-4/+0
2011-10-20	Document copyright year range notation in README.	Carlos O'Donell	1	-1/+4
2010-02-10	Some updates to the README file	Ulrich Drepper	1	-9/+12
2009-02-24	[BZ #9895]	Roland McGrath	1	-2/+3
2007-10-17	Remade for stable-2.7cvs/fedora-glibc-20071017T2029	Ulrich Drepper	1	-2/+2
2007-05-15	* version.h (VERSION): Define to 6.glibc-2.6 cvs/glibc-2_6-base cvs/glibc-2_6	Ulrich Drepper	1	-2/+2
2007-01-11	[BZ #2510, BZ #2830, BZ #3137, BZ #3313, BZ #3426, BZ #3465, BZ #3480, BZ #34...	Ulrich Drepper	1	-2/+2
2007-07-31	.	Jakub Jelinek	1	-2/+2
2006-10-02	* elf/rtld.c (dl_main): Don't use prelinking if LD_DYNAMIC_WEAK is	Ulrich Drepper	1	-7/+0
2006-09-29	* version.h (RELEASE): Bump to 2.5.glibc-2.5 cvs/glibc-2_5 cvs/fedora-glibc-20060929T2037	Ulrich Drepper	1	-2/+2
2006-03-06	* version.h (VERSION): 2.4glibc-2.4 cvs/glibc-2_4 cvs/fedora-glibc-20060306T1239	Roland McGrath	1	-46/+88
2004-12-22	(CFLAGS-tst-align.c): Add -mpreferred-stack-boundary=4.	Ulrich Drepper	1	-81/+46
2007-07-12	2.5-18.1	Jakub Jelinek	1	-46/+81
2004-12-19	* version.h (VERSION): 2.3.4.	Roland McGrath	1	-37/+8
2003-12-01	Remade for stable-2.3.3glibc-2.3.3 cvs/glibc-2_3_3	Ulrich Drepper	1	-1/+1
2003-02-21	Remade for stable-2.3.2	Ulrich Drepper	1	-1/+1
2002-10-10	Update.	Ulrich Drepper	1	-1/+1
2002-10-03	Update.	Ulrich Drepper	1	-2/+3
2002-10-02	Update.	Ulrich Drepper	1	-1/+1
2002-09-19	Update	Ulrich Drepper	1	-1/+2
2002-09-03	Update.	Ulrich Drepper	1	-1/+1
2002-08-29	(process_string_arg): Fix typo.	Ulrich Drepper	1	-1/+1
2002-08-28	Update.	Ulrich Drepper	1	-1/+1
2002-08-20	2002-08-20 Brian Youmans <3diff@gnu.org>	Roland McGrath	1	-1/+2
2001-12-06	Remade for development-2.2.90	Geoff Keating	1	-1/+1
2001-07-28	Update.	Ulrich Drepper	1	-1/+1
2001-04-26	Update.	Ulrich Drepper	1	-1/+1
2001-04-09	Update.	Ulrich Drepper	1	-0/+2
2001-03-28	Update.	Ulrich Drepper	1	-1/+2
2001-02-09	(distribute): Add firstobj.c.	Ulrich Drepper	1	-1/+1
2001-01-07	Update.	Ulrich Drepper	1	-1/+1

/* srconv.c -- Sysroff conversion program Copyright (C) 1994-2019 Free Software Foundation, Inc. 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 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ /* Written by Steve Chamberlain (sac@cygnus.com) This program can be used to convert a coff object file into a Hitachi OM/LM (Sysroff) format. All debugging information is preserved */ #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 FOOP1 1 */ 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 segmented_p; static int code; static int ids1[20000]; static int ids2[20000]; static int base1 = 0x18; static int base2 = 0x2018; static int get_member_id (int x) { if (ids2[x]) return ids2[x]; ids2[x] = base2++; return ids2[x]; } static int get_ordinary_id (int x) { if (ids1[x]) return ids1[x]; ids1[x] = base1++; return ids1[x]; } static char * section_translate (char *n) { if (strcmp (n, ".text") == 0) return "P"; if (strcmp (n, ".data") == 0) return "D"; if (strcmp (n, ".bss") == 0) return "B"; return n; } #define DATE "940201073000"; /* Just a time on my birthday */ 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); memcpy (res, name, i); res[i] = 0; return res; } /* IT LEN stuff CS */ static void checksum (FILE *ffile, unsigned char *ptr, int size, int ccode) { int j; int last; int sum = 0; int bytes = size / 8; last = !(ccode & 0xff00); if (size & 0x7) 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. */ ptr[bytes] = ~sum; if (fwrite (ptr, bytes + 1, 1, ffile) != 1) /* FIXME: Return error status. */ fatal (_("Failed to write checksum")); } static void writeINT (int n, unsigned char *ptr, int *idx, int size, FILE *ffile) { int byte = *idx / 8; if (size == -2) size = addrsize; else if (size == -1) size = 0; if (byte > 240) { /* Lets write out that record and do another one. */ checksum (ffile, ptr, *idx, code | 0x1000); *idx = 16; byte = *idx / 8; } switch (size) { case 0: break; case 1: ptr[byte] = n; break; case 2: ptr[byte + 0] = n >> 8; ptr[byte + 1] = n; break; case 4: ptr[byte + 0] = n >> 24; ptr[byte + 1] = n >> 16; ptr[byte + 2] = n >> 8; ptr[byte + 3] = n >> 0; break; default: fatal (_("Unsupported integer write size: %d"), size); } *idx += size * 8; } static void 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. */ old &= ~((~0 >> (8 - bit - size)) & ((1 << size) - 1)); /* Turn on the bits we want. */ old |= (val & ((1 << size) - 1)) << (8 - bit - size); ptr[byte] = old; } static void writeBARRAY (barray data, unsigned char *ptr, int *idx, int size ATTRIBUTE_UNUSED, FILE *ffile) { int i; 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 (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 (ffile, ptr, *idx, code | 0x1000); *idx = 16; i = *idx / 8; } if (size == 0) { /* Variable length string. */ size = strlen (string); ptr[i++] = size; } /* BUG WAITING TO HAPPEN. */ memcpy (ptr + i, string, size); i += size; *idx = i * 8; } #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" }; static char *rname_h8300[] = { "ER0", "ER1", "ER2", "ER3", "ER4", "ER5", "ER6", "ER7", "PC", "CCR" }; static void wr_tr (void) { /* 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 (struct coff_ofile *ptr, struct coff_sfile *sfile, int first, int nsecs ATTRIBUTE_UNUSED) { struct IT_un un; struct coff_symbol *s; un.spare1 = 0; if (bfd_get_file_flags (abfd) & EXEC_P) un.format = FORMAT_LM; else un.format = FORMAT_OM; un.spare1 = 0; /* 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. */ if (first) { for (s = ptr->symbol_list_head; s; s = s->next_in_ofile_list) { if (s->visible->type == coff_vis_ext_def || s->visible->type == coff_vis_common) un.nextdefs++; if (s->visible->type == coff_vis_ext_ref) un.nextrefs++; } } un.tool = toolname; un.tcd = DATE; un.linker = "L_GX00"; un.lcd = DATE; un.name = sfile->name; sysroff_swap_un_out (file, &un); } static void wr_hd (struct coff_ofile *p) { struct IT_hd hd; hd.spare1 = 0; if (bfd_get_file_flags (abfd) & EXEC_P) hd.mt = MTYPE_ABS_LM; else 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 (bfd_get_arch (abfd)) { case bfd_arch_h8300: hd.au = 8; hd.si = 0; hd.spcsz = 32; hd.segsz = 0; hd.segsh = 0; 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 = 0; hd.afl = 4; hd.spcsz = 32; hd.segsz = 0; hd.segsh = 0; hd.cpu = "SH"; addrsize = 4; toolname = "C_SH"; rnames = rname_sh; break; default: fatal (_("Unsupported architecture: %d"), bfd_get_arch (abfd)); } if (! (bfd_get_file_flags(abfd) & EXEC_P)) { hd.ep = 0; } else { hd.ep = 1; hd.uan = 0; hd.sa = 0; hd.sad = 0; hd.address = bfd_get_start_address (abfd); } hd.os = ""; hd.sys = ""; hd.mn = strip_suffix (bfd_get_filename (abfd)); sysroff_swap_hd_out (file, &hd); } static void wr_sh (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *sec) { struct IT_sh sh; sh.unit = 0; sh.section = sec->number; #ifdef FOOP1 sh.section = 0; #endif sysroff_swap_sh_out (file, &sh); } static void wr_ob (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *section) { bfd_size_type i; int first = 1; unsigned char stuff[200]; i = 0; while (i < bfd_get_section_size (section->bfd_section)) { struct IT_ob ob; int todo = 200; /* Copy in 200 byte lumps. */ ob.spare = 0; if (i + todo > bfd_get_section_size (section->bfd_section)) todo = bfd_get_section_size (section->bfd_section) - i; if (first) { ob.saf = 1; if (bfd_get_file_flags (abfd) & EXEC_P) ob.address = section->address; else ob.address = 0; first = 0; } else { ob.saf = 0; } 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 */ ); 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 (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; rl.sign = 0; 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. */ ref = r->symbol; if (ref->visible->type == coff_vis_ext_ref) { 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.op = OP_SEC_REF; rl.secn = ref->where->section->number; rl.copcode_is_3 = 3; rl.alength_is_4 = 4; rl.addend = ref->where->offset - ref->where->section->address; rl.aopcode_is_0x20 = 0x20; } else { rl.bcount = 11; /* Always 11 for us. */ rl.op = OP_SEC_REF; rl.secn = ref->where->section->number; rl.copcode_is_3 = 3; rl.alength_is_4 = 4; rl.addend = -ref->where->section->address; rl.aopcode_is_0x20 = 0x20; } rl.end = 0xff; if ( rl.op == OP_SEC_REF || rl.op == OP_EXT_REF) sysroff_swap_rl_out (file, &rl); } } static void wr_object_body (struct coff_ofile *p) { int i; for (i = 1; i < p->nsections; i++) { wr_sh (p, p->sections + i); wr_ob (p, p->sections + i); wr_rl (p, p->sections + i); } } static void 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; sysroff_swap_dps_out (file, &dps); } static void 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 (int x) { return (int *) (xcalloc (sizeof (int), x)); } static void walk_tree_type_1 (struct coff_sfile *sfile, struct coff_symbol *symbol, struct coff_type *type, int nest) { switch (type->type) { case coff_secdef_type: case coff_basic_type: { struct IT_dbt dbt; switch (type->u.basic) { case T_NULL: case T_VOID: dbt.btype = BTYPE_VOID; 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: dbt.btype = BTYPE_INT; 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: dbt.btype = BTYPE_INT; dbt.sign = SIGN_UNSIGNED; 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); break; } case coff_function_type: { struct IT_dfp dfp; struct coff_symbol *param; dfp.end = 0; dfp.spare = 0; dfp.nparams = type->u.function.parameters->nvars; dfp.neg = 0x1001; walk_tree_type_1 (sfile, symbol, type->u.function.function_returns, nest + 1); sysroff_swap_dfp_out (file, &dfp); for (param = type->u.function.parameters->vars_head; param; param = param->next) walk_tree_symbol (sfile, 0, param, nest); dfp.end = 1; sysroff_swap_dfp_out (file, &dfp); break; } case coff_structdef_type: { 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; dbt.fptype = FPTYPE_NOTSPEC; dbt.sid = get_member_id (type->u.astructdef.idx); dbt.neg = 0x1001; sysroff_swap_dbt_out (file, &dbt); 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); 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); else 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. */ dar.dims = dims; dar.variable = nints (dims); dar.subtype = nints (dims); dar.spare = nints (dims); dar.max_variable = nints (dims); dar.maxspare = nints (dims); dar.max = nints (dims); dar.min_variable = nints (dims); 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; dar.min[j] = 1; /* Why isn't this 0 ? */ } walk_tree_type_1 (sfile, symbol, type->u.array.array_of, nest + 1); 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; dbt.fptype = FPTYPE_NOTSPEC; dbt.sid = get_member_id (type->u.aenumdef.idx); dbt.neg = 0x1001; sysroff_swap_dbt_out (file, &dbt); 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); den.end = 1; sysroff_swap_den_out (file, &den); } break; case coff_enumref_type: { struct IT_dbt dbt; dbt.btype = BTYPE_TAG; dbt.bitsize = type->size; dbt.sign = SIGN_UNSPEC; dbt.fptype = FPTYPE_NOTSPEC; dbt.sid = get_member_id (type->u.aenumref.ref->number); dbt.neg = 0x1001; sysroff_swap_dbt_out (file, &dbt); } break; default: fatal (_("Unrecognised type: %d"), type->type); } } /* 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 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; if (symbol->type->type == coff_function_type) { 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, 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, nest + 1, BLOCK_TYPE_BLOCK); 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 { 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 (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; 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: fatal (_("Unrecognised coff symbol type: %d"), symbol->type->type); } 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.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; 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; #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: fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where); } 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: 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; 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_entag: case coff_where_typedef: break; default: fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where); } if (symbol->where->where == coff_where_register) dsy.reg = rnames[symbol->where->offset]; 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; case coff_vis_regparam: case coff_vis_autoparam: dsy.type = STYPE_PARAMETER; break; 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); } dsy.sfn = 0; dsy.sln = 2; dsy.neg = 0x1001; sysroff_swap_dsy_out (file, &dsy); walk_tree_type (sfile, symbol, symbol->type, nest); } static void 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; if (scope->vars_head || (scope->list_head && scope->list_head->vars_head)) { wr_dps_start (sfile, section, scope, type, nest); if (nest == 0) wr_globals (tree, sfile, nest + 1); for (vars = scope->vars_head; vars; vars = vars->next) 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); wr_dps_end (section, scope, type); } } static void 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 (struct coff_ofile *p, struct coff_sfile *sfile) { if (p->nsections < 4) return; walk_tree_sfile (p->sections + 4, sfile); } static void wr_du (struct coff_ofile *p, struct coff_sfile *sfile, int n) { struct IT_du du; int lim; int i; int j; unsigned int *lowest = (unsigned *) nints (p->nsections); unsigned int *highest = (unsigned *) nints (p->nsections); 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); du.address = nints (du.sections); du.length = nints (du.sections); for (i = 0; i < du.sections; i++) { lowest[i] = ~0; highest[i] = 0; } 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] = sfile->section[src].high - sfile->section[src].low + 1; du.address[dst] = sfile->section[src].low; } else { du.length[dst] = 0; du.address[dst] = 0; } if (debug) { if (sfile->section[src].parent) { printf (" section %6s 0x%08x..0x%08x\n", sfile->section[src].parent->name, du.address[dst], du.address[dst] + du.length[dst] - 1); } } du.sections = dst + 1; } du.tool = "c_gcc"; du.date = DATE; sysroff_swap_du_out (file, &du); } static void wr_dus (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile) { struct IT_dus dus; dus.efn = 0x1001; 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. */ dus.drb[0] = 0; dus.fname[0] = sfile->name; sysroff_swap_dus_out (file, &dus); } /* Find the offset of the .text section for this sfile in the .text section for the output file. */ static int find_base (struct coff_sfile *sfile, struct coff_section *section) { return sfile->section[section->number].low; } static void wr_dln (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile, int n ATTRIBUTE_UNUSED) { /* Count up all the linenumbers */ struct coff_symbol *sy; int lc = 0; struct IT_dln dln; int idx; for (sy = sfile->scope->vars_head; sy; sy = sy->next) { struct coff_type *t = sy->type; if (t->type == coff_function_type) { struct coff_line *l = t->u.function.lines; if (l) lc += l->nlines; } } dln.sfn = nints (lc); dln.sln = nints (lc); dln.cc = 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 = sfile->scope->vars_head; sy; sy = sy->next) { if (sy->type->type == coff_function_type) { 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 (lc) sysroff_swap_dln_out (file, &dln); } /* Write the global symbols out to the debug info. */ static void 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) { if (sy->visible->type == coff_vis_ext_def || sy->visible->type == coff_vis_ext_ref) { /* Only write out symbols if they belong to the current source file. */ if (sy->sfile == sfile) walk_tree_symbol (sfile, 0, sy, 0); } } } static void 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); wr_du (p, sfile, n); wr_dus (p, sfile); wr_program_structure (p, sfile); wr_dln (p, sfile, n); n++; } } static void wr_cs (void) { /* It seems that the CS struct is not normal - the size is wrong heres one I prepared earlier. */ static char b[] = { 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. */ static int wr_sc (struct coff_ofile *ptr, struct coff_sfile *sfile) { int i; 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; }; struct coff_symbol *symbol; struct myinfo *info = (struct myinfo *) calloc (total_sec, sizeof (struct myinfo)); for (i = 0; i < total_sec; i++) { info[i].sec = ptr->sections + i; info[i].symbol = 0; } for (symbol = sfile->scope->vars_head; symbol; symbol = symbol->next) { if (symbol->type->type == coff_secdef_type) { for (i = 0; i < total_sec; i++) { if (symbol->where->section == info[i].sec) { info[i].symbol = symbol; break; } } } } /* Now output all the section info, and fake up some stuff for sections 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 = !(bfd_get_file_flags (abfd) & EXEC_P); sc.addr = 0; sc.length = 0; name = info[i].sec->name; } else { if (bfd_get_file_flags (abfd) & EXEC_P) { sc.format = 0; sc.addr = symbol->where->offset; } else { sc.format = 1; sc.addr = 0; } sc.length = symbol->type->size; name = symbol->name; } sc.align = 4; sc.concat = CONCAT_SIMPLE; sc.read = 3; sc.write = 3; sc.exec = 3; sc.init = 3; sc.mode = 3; sc.spare = 0; 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]) { case 'D': 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 (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) { 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 (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) { if (s->visible->type == coff_vis_ext_def || s->visible->type == coff_vis_common) { struct IT_ed ed; ed.section = s->where->section->number; ed.spare = 0; if (s->where->section->data) { ed.type = ED_TYPE_DATA; } else if (s->where->section->code & SEC_CODE) { ed.type = ED_TYPE_ENTRY; } else { 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); } } } } static void wr_unit_info (struct coff_ofile *ptr) { struct coff_sfile *sfile; int first = 1; for (sfile = ptr->source_head; sfile; sfile = sfile->next) { 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; } } static void wr_module (struct coff_ofile *p) { wr_cs (); wr_hd (p); wr_unit_info (p); wr_object_body (p); wr_debug (p); wr_tr (); } static int 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. */ static void prescan (struct coff_ofile *otree) { struct coff_symbol *s; struct coff_section *common_section; 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 */ common_section->size = align (common_section->size); w->offset = common_section->size + common_section->address; w->section = common_section; common_section->size += s->type->size; common_section->size = align (common_section->size); } } } char *program_name; ATTRIBUTE_NORETURN static void show_usage (FILE *ffile, int status) { 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\ @<file> Read options from <file>\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); } int 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, "dHhVvqn", long_options, (int *) NULL)) != EOF) { switch (opt) { case 'q': quick = 1; break; case 'n': noprescan = 1; break; case 'd': debug = 1; break; case 'H': case 'h': show_usage (stdout, 0); /*NOTREACHED */ case 'v': case 'V': print_version ("srconv"); exit (0); /*NOTREACHED */ case 0: break; default: show_usage (stderr, 1); /*NOTREACHED */ } } /* The input and output files may be named on the command line. */ output_file = NULL; if (optind < ac) { input_file = av[optind]; ++optind; if (optind < ac) { output_file = av[optind]; ++optind; if (optind < ac) show_usage (stderr, 1); if (filename_cmp (input_file, output_file) == 0) { fatal (_("input and output files must be different")); } } } else input_file = 0; if (!input_file) { 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 */ 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') { output_file[len] = 'b'; output_file[len + 1] = 'j'; output_file[len + 2] = 0; } else { strcat (output_file, ".obj"); } } abfd = bfd_openr (input_file, 0); if (!abfd) bfd_fatal (input_file); 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); free (matching); } exit (1); } file = fopen (output_file, FOPEN_WB); if (!file) fatal (_("unable to open output file %s"), output_file); if (debug) printf ("ids %d %d\n", base1, base2); tree = coff_grok (abfd); if (tree) { if (!noprescan) prescan (tree); wr_module (tree); } return 0; }