(struct bfd_hash_table): Change memory field to PTR.
* bfd.c (struct _bfd): Change memory field to PTR.
* bfd-in2.h: Rebuild.
* libbfd-in.h (bfd_release): Declare as function, don't define as
macro.
* libbfd.h: Rebuild.
* opncls.c: Include "objalloc.h" rather than "obstack.h". Use
objalloc routines rather than obstack routines.
(obstack_chunk_alloc, obstack_chunk_free): Don't define.
(getpagesize): Don't define.
(_bfd_new_bfd): Don't set _bfd_chunksize.
(bfd_openr): Free new bfd and objalloc on failure.
(bfd_fdopenr, bfd_openstreamr, bfd_openw): Likewise.
(bfd_alloc_size): Remove.
(bfd_release): New function.
* hash.c: Include "objalloc.h" rather than "obstack.h". Use
objalloc routines rather than obstack routines.
(obstack_chunk_alloc, obstack_chunk_free): Don't define.
* ecofflink.c: Include "objalloc.h" rather than "obstack.h". Use
objalloc routines rather than obstack routines.
(obstack_chunk_alloc, obstack_chunk_free): Don't define.
(struct accumulate): Change memory to struct objalloc *.
* liboasys.h (oasys_data_type): Remove oasys_obstack field.
* dep-in.sed: Don't remove obstack.h from dependency list.
* Makefile.in: Rebuild dependencies.
(BFD_H_DEPS): Remove obstack.h.
(install): Don't install obstack.h.
* Many files: Don't include "obstack.h".
* VERSION: Bump.
Mon Mar 17 11:32:53 1997 Ian Lance Taylor <ian@cygnus.com>
+ * bfd-in.h: Don't include obstack.h.
+ (struct bfd_hash_table): Change memory field to PTR.
+ * bfd.c (struct _bfd): Change memory field to PTR.
+ * bfd-in2.h: Rebuild.
+ * libbfd-in.h (bfd_release): Declare as function, don't define as
+ macro.
+ * libbfd.h: Rebuild.
+ * opncls.c: Include "objalloc.h" rather than "obstack.h". Use
+ objalloc routines rather than obstack routines.
+ (obstack_chunk_alloc, obstack_chunk_free): Don't define.
+ (getpagesize): Don't define.
+ (_bfd_new_bfd): Don't set _bfd_chunksize.
+ (bfd_openr): Free new bfd and objalloc on failure.
+ (bfd_fdopenr, bfd_openstreamr, bfd_openw): Likewise.
+ (bfd_alloc_size): Remove.
+ (bfd_release): New function.
+ * hash.c: Include "objalloc.h" rather than "obstack.h". Use
+ objalloc routines rather than obstack routines.
+ (obstack_chunk_alloc, obstack_chunk_free): Don't define.
+ * ecofflink.c: Include "objalloc.h" rather than "obstack.h". Use
+ objalloc routines rather than obstack routines.
+ (obstack_chunk_alloc, obstack_chunk_free): Don't define.
+ (struct accumulate): Change memory to struct objalloc *.
+ * liboasys.h (oasys_data_type): Remove oasys_obstack field.
+ * dep-in.sed: Don't remove obstack.h from dependency list.
+ * Makefile.in: Rebuild dependencies.
+ (BFD_H_DEPS): Remove obstack.h.
+ (install): Don't install obstack.h.
+ * Many files: Don't include "obstack.h".
+ * VERSION: Bump.
+
* opncls.c (bfd_alloc_grow, bfd_alloc_finish): Remove.
* libbfd-in.h (bfd_alloc_grow, bfd_alloc_finish): Don't declare.
* libbfd.h: Rebuild.
# Makefile template for Configure for the BFD library.
-# Copyright (C) 1990, 91, 92, 93, 94, 95, 1996
+# Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997
# Free Software Foundation, Inc.
# Written by Cygnus Support.
#
cpu-arc.o \
$(end-sanitize-arc) \
cpu-arm.o \
- $(start-sanitize-d10v) \
cpu-d10v.o \
- $(end-sanitize-d10v) \
$(start-sanitize-d30v) \
cpu-d30v.o \
$(end-sanitize-d30v) \
$(start-sanitize-arc) \
elf32-arc.o \
$(end-sanitize-arc) \
- $(start-sanitize-d10v) \
elf32-d10v.o \
- $(end-sanitize-d10v) \
$(start-sanitize-d30v) \
elf32-d30v.o \
$(end-sanitize-d30v) \
ts=lib`echo $(SHLIB) | sed -e 's/^lib//' | sed -e '$(program_transform_name)'`; \
if [ "$$ts" != "$(SHLIB)" ]; then \
rm -f $$ts; \
- ln -sf $(SHLIB) $$ts; \
+ ln -s $(SHLIB) $$ts; \
else true; fi
rm -f $(SHLINK)
- ln -sf $(SHLIB) $(SHLINK)
+ ln -s $(SHLIB) $(SHLINK)
# This target creates libTARGET-bfd.so.VERSION as a symlink to
# libbfd.so.VERSION. It is used on SunOS, which does not have SONAME.
tf=lib`echo $(SHLIB) | sed -e 's/^lib//' | sed '$(program_transform_name)'`; \
if [ "$$tf" != "$(SHLIB)" ]; then \
rm -f $$tf; \
- ln -sf $(SHLIB) $$tf; \
+ ln -s $(SHLIB) $$tf; \
else true; fi
touch stamp-tshlink
$(MAKE) subdir_do DO=maintainer-clean "DODIRS=$(SUBDIRS)" $(FLAGS_TO_PASS)
$(MAKE) do_maintainer_clean
-BFD_H_DEPS= $(INCDIR)/ansidecl.h $(INCDIR)/obstack.h
+BFD_H_DEPS= $(INCDIR)/ansidecl.h
LOCAL_H_DEPS= libbfd.h sysdep.h config.h
$(BFD_LIBS): $(BFD_H) $(BFD_H_DEPS) $(LOCAL_H_DEPS)
$(BFD_MACHINES): $(BFD_H) $(BFD_H_DEPS) $(LOCAL_H_DEPS)
rm -f $(libdir)/$$tf; \
if [ "$$f" = "$(SHLINK)" ]; then \
ts=lib`echo $(SHLIB) | sed -e 's/^lib//' | sed '$(program_transform_name)'`; \
- ln -sf $$ts $(libdir)/$$tf; \
+ ln -s $$ts $(libdir)/$$tf; \
elif [ "$$f" = "$(SHLIB)" ]; then \
@INSTALL_SHLIB@ \
else \
$(INSTALL_DATA) $(BFD_H) $(includedir)/bfd.h
$(INSTALL_DATA) $(INCDIR)/ansidecl.h $(includedir)/ansidecl.h
$(INSTALL_DATA) $(INCDIR)/bfdlink.h $(includedir)/bfdlink.h
- $(INSTALL_DATA) $(INCDIR)/obstack.h $(includedir)/obstack.h
-if test -z "$(oldincludedir)"; then true; else \
test -d $(oldincludedir) || mkdir $(oldincludedir); \
$(INSTALL_DATA) $(BFD_H) $(oldincludedir)/bfd.h; \
$(INSTALL_DATA) $(INCDIR)/ansidecl.h $(oldincludedir)/ansidecl.h; \
$(INSTALL_DATA) $(INCDIR)/bfdlink.h $(oldincludedir)/bfdlink.h; \
- $(INSTALL_DATA) $(INCDIR)/obstack.h $(oldincludedir)/obstack.h; \
fi
$(MAKE) subdir_do DO=install "DODIRS=$(SUBDIRS)" $(FLAGS_TO_PASS)
$(INCDIR)/elf/arc.h elf32-target.h
end-sanitize-arc:
-start-sanitize-d10v:
elf32-d10v.o: elf32-d10v.c elf-bfd.h $(INCDIR)/elf/common.h \
$(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h \
elf32-target.h
-end-sanitize-d10v:
start-sanitize-d30v:
elf32-d30v.o: elf32-d30v.c elf-bfd.h $(INCDIR)/elf/common.h \
format.o: format.c
init.o: init.c
libbfd.o: libbfd.c
-opncls.o: opncls.c
+opncls.o: opncls.c $(INCDIR)/objalloc.h
reloc.o: reloc.c $(INCDIR)/bfdlink.h
section.o: section.c
syms.o: syms.c $(INCDIR)/bfdlink.h $(INCDIR)/aout/stab_gnu.h \
$(INCDIR)/aout/stab.def
targets.o: targets.c $(INCDIR)/fnmatch.h targmatch.h
-hash.o: hash.c
+hash.o: hash.c $(INCDIR)/objalloc.h
linker.o: linker.c $(INCDIR)/bfdlink.h genlink.h
elf.o: elf.c $(INCDIR)/bfdlink.h elf-bfd.h $(INCDIR)/elf/common.h \
$(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h
libaout.h $(INCDIR)/aout/aout64.h $(INCDIR)/coff/internal.h \
$(INCDIR)/coff/sym.h $(INCDIR)/coff/symconst.h $(INCDIR)/coff/ecoff.h \
libcoff.h libecoff.h
-ecofflink.o: ecofflink.c $(INCDIR)/bfdlink.h $(INCDIR)/aout/stab_gnu.h \
- $(INCDIR)/aout/stab.def $(INCDIR)/coff/internal.h $(INCDIR)/coff/sym.h \
- $(INCDIR)/coff/symconst.h $(INCDIR)/coff/ecoff.h
+ecofflink.o: ecofflink.c $(INCDIR)/bfdlink.h $(INCDIR)/objalloc.h \
+ $(INCDIR)/aout/stab_gnu.h $(INCDIR)/aout/stab.def $(INCDIR)/coff/internal.h \
+ $(INCDIR)/coff/sym.h $(INCDIR)/coff/symconst.h $(INCDIR)/coff/ecoff.h
elf32-gen.o: elf32-gen.c elf-bfd.h $(INCDIR)/elf/common.h \
$(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h $(INCDIR)/bfdlink.h \
elf32-target.h
$(INCDIR)/elf/sparc.h elf32-target.h
elf32.o: elf32.c elfcode.h $(INCDIR)/bfdlink.h elf-bfd.h \
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
- elfcore.h elflink.h
+ $(INCDIR)/fnmatch.h elfcore.h elflink.h
elflink.o: elflink.c $(INCDIR)/bfdlink.h elf-bfd.h \
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h
hp300bsd.o: hp300bsd.c libaout.h $(INCDIR)/bfdlink.h \
$(INCDIR)/elf/sparc.h elf64-target.h
elf64.o: elf64.c elfcode.h $(INCDIR)/bfdlink.h elf-bfd.h \
$(INCDIR)/elf/common.h $(INCDIR)/elf/internal.h $(INCDIR)/elf/external.h \
- elfcore.h elflink.h
+ $(INCDIR)/fnmatch.h elfcore.h elflink.h
evax-alpha.o: evax-alpha.c $(INCDIR)/bfdlink.h evax.h
evax-egsd.o: evax-egsd.c $(INCDIR)/bfdlink.h evax.h
evax-etir.o: evax-etir.c $(INCDIR)/bfdlink.h evax.h
-cygnus-2.7.2
+cygnus-2.7.3
/* BFD semi-generic back-end for a.out binaries.
- Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+ Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
#else
/* We allocate using malloc to make the values easy to free
- later on. If we put them on the obstack it might not be
+ later on. If we put them on the objalloc it might not be
possible to free them. */
syms = ((struct external_nlist *)
bfd_malloc ((size_t) count * EXTERNAL_NLIST_SIZE));
break;
case discard_l:
if ((type & N_STAB) == 0
- && *name == *finfo->info->lprefix
- && (finfo->info->lprefix_len == 1
- || strncmp (name, finfo->info->lprefix,
- finfo->info->lprefix_len) == 0))
+ && bfd_is_local_label_name (input_bfd, name))
skip = true;
break;
case discard_all:
#endif
#include "ansidecl.h"
-#include "obstack.h"
/* These two lines get substitutions done by commands in Makefile.in. */
#define BFD_VERSION "@VERSION@"
struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
struct bfd_hash_table *,
const char *));
- /* An obstack for this hash table. */
- struct obstack memory;
+ /* An objalloc for this hash table. This is a struct objalloc *,
+ but we use PTR to avoid requiring the inclusion of objalloc.h. */
+ PTR memory;
};
/* Initialize a hash table. */
boolean
bfd_close_all_done PARAMS ((bfd *));
-bfd_size_type
-bfd_alloc_size PARAMS ((bfd *abfd));
-
bfd *
bfd_create PARAMS ((CONST char *filename, bfd *templ));
/* Used by the application to hold private data*/
PTR usrdata;
- /* Where all the allocated stuff under this BFD goes */
- struct obstack memory;
+ /* Where all the allocated stuff under this BFD goes. This is a
+ struct objalloc *, but we use PTR to avoid requiring the inclusion of
+ objalloc.h. */
+ PTR memory;
};
typedef enum bfd_error
PTR backend_data;
} bfd_target;
+boolean
+bfd_set_default_target PARAMS ((const char *name));
+
const bfd_target *
bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd));
/* BFD back-end for AMD 29000 COFF binaries.
- Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+ Copyright 1990, 91, 92, 93, 94, 95, 1997 Free Software Foundation, Inc.
Contributed by David Wood at New York University 7/8/91.
This file is part of BFD, the Binary File Descriptor library.
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
-#include "obstack.h"
#include "coff/a29k.h"
#include "coff/internal.h"
#include "libcoff.h"
/* BFD back-end for PowerPC Microsoft Portable Executable files.
- Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+ Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
Original version pieced together by Kim Knuttila (krk@cygnus.com)
#include "sysdep.h"
#include "libbfd.h"
-#include "obstack.h"
#include "coff/powerpc.h"
#include "coff/internal.h"
#define MARK_AS_WRITTEN(x) ((x) |= 1)
#define MAKE_ADDR_AGAIN(x) ((x) &= ~1)
+
+/* Turn on this check if you suspect something amiss in the hash tables */
+#ifdef DEBUG_HASH
+
+/* Need a 7 char string for an eye catcher */
+#define EYE "krkjunk"
+
+#define HASH_CHECK_DCL char eye_catcher[8];
+#define HASH_CHECK_INIT(ret) strcpy(ret->eye_catcher, EYE)
+#define HASH_CHECK(addr) \
+ if (strcmp(addr->eye_catcher, EYE) != 0) \
+ { \
+ fprintf(stderr,\
+ "File %s, line %d, Hash check failure, bad eye %8s\n", \
+ __FILE__, __LINE__, addr->eye_catcher); \
+ abort(); \
+ }
+
+
+#else
+
+#define HASH_CHECK_DCL
+#define HASH_CHECK_INIT(ret)
+#define HASH_CHECK(addr)
+
+#endif
+
/* In order not to add an int to every hash table item for every coff
linker, we define our own hash table, derived from the coff one */
bfd_vma toc_offset; /* Our addition, as required */
int symbol_is_glue;
unsigned long int glue_insn;
- char eye_catcher[8];
+
+ HASH_CHECK_DCL
};
-/* Need a 7 char string for an eye catcher */
-#define EYE "krkjunk"
-
-#define CHECK_EYE(addr) \
- if (strcmp(addr, EYE) != 0) \
- { \
- fprintf(stderr,\
- "File %s, line %d, Hash check failure, bad eye %8s\n", \
- __FILE__, __LINE__, addr); \
- abort(); \
- }
/* PE linker hash table. */
SET_UNALLOCATED(ret->toc_offset);
ret->symbol_is_glue = 0;
ret->glue_insn = 0;
- strcpy(ret->eye_catcher, EYE);
+
+ HASH_CHECK_INIT(ret);
}
return (struct bfd_hash_entry *) ret;
\f
/* The nt loader points the toc register to &toc + 32768, in order to */
-/* use the complete range of a 16-bit displacement (I guess). We have */
-/* to adjust for this when we fix up loads displaced off the toc reg. */
+/* use the complete range of a 16-bit displacement. We have to adjust */
+/* for this when we fix up loads displaced off the toc reg. */
#define TOC_LOAD_ADJUSTMENT (-32768)
#define TOC_SECTION_NAME ".private.toc"
#ifdef COFF_IMAGE_WITH_PE
/* record a toc offset against a symbol */
-static int
+static boolean
ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
bfd *abfd;
struct bfd_link_info *info;
enum toc_type toc_kind;
{
struct ppc_coff_link_hash_entry *h;
- int ret_val;
const char *name;
int *local_syms;
h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
if (h != 0)
{
- CHECK_EYE(h->eye_catcher);
+ HASH_CHECK(h);
}
if (h == 0)
if (IS_UNALLOCATED(local_syms[sym]))
{
local_syms[sym] = global_toc_size;
- ret_val = global_toc_size;
global_toc_size += 4;
/* The size must fit in a 16bit displacment */
- if (global_toc_size >= 65535)
+ if (global_toc_size > 65535)
{
- fprintf(stderr,
- "Exceeded toc size of 65535\n");
- abort();
+ (*_bfd_error_handler) ("TOC overflow");
+ bfd_set_error (bfd_error_file_too_big);
+ return false;
}
-
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "Setting toc_offset for local sym %d to %d\n",
- sym, ret_val);
-#endif
- }
- else
- {
- ret_val = local_syms[sym];
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "toc_offset already set for local sym %d to %d\n",
- sym, ret_val);
-#endif
}
}
else
if (IS_UNALLOCATED(h->toc_offset))
{
h->toc_offset = global_toc_size;
- ret_val = global_toc_size;
global_toc_size += 4;
/* The size must fit in a 16bit displacment */
if (global_toc_size >= 65535)
{
- fprintf(stderr,
- "Exceeded toc size of 65535\n");
- abort();
- }
-
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "Setting toc_offset for sym %d (%s) [h=%p] to %d\n",
- sym, name, h, ret_val);
-#endif
- }
- else
- {
- ret_val = h->toc_offset;
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "toc_offset already set for sym %d (%s) [h=%p] to %d\n",
- sym, name, h, ret_val);
-#endif
- }
- }
-
- return ret_val;
-}
-
-#endif /* COFF_IMAGE_WITH_PE */
-
-#if 0
-
-/* FIXME: record a toc offset against a data-in-toc symbol */
-/* Now, there is currenly some confusion on what this means. In some
- compilers one sees the moral equivalent of:
- .tocd
- define some data
- .text
- refer to the data with a [tocv] qualifier
- In general, one sees something to indicate that a tocd has been
- seen, and that would trigger the allocation of data in toc. The IBM
- docs seem to suggest that anything with the TOCDEFN qualifier should
- never trigger storage allocation. However, in the kernel32.lib that
- we've been using for our test bed, there are a couple of variables
- referenced that fail that test.
-
- So it can't work that way.
-*/
-static int
-ppc_record_data_in_toc_entry(abfd, info, sec, sym, toc_kind)
- bfd *abfd;
- struct bfd_link_info *info;
- asection *sec;
- int sym;
- enum toc_type toc_kind;
-{
- struct ppc_coff_link_hash_entry *h = 0;
- int ret_val;
- const char *name;
-
- int *local_syms;
-
- h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
-
- if (h == 0)
- {
- local_syms = obj_coff_local_toc_table(abfd);
- if (local_syms == 0)
- {
- int i;
- /* allocate a table */
- local_syms =
- (int *) bfd_zalloc (abfd,
- obj_raw_syment_count(abfd) * sizeof(int));
- if (local_syms == 0)
- return false;
- obj_coff_local_toc_table(abfd) = local_syms;
- for (i = 0; i < obj_raw_syment_count(abfd); ++i)
- {
- SET_UNALLOCATED(local_syms[i]);
+ (*_bfd_error_handler) ("TOC overflow");
+ bfd_set_error (bfd_error_file_too_big);
+ return false;
}
}
-
- if (IS_UNALLOCATED(local_syms[sym]))
- {
- local_syms[sym] = global_toc_size;
- ret_val = global_toc_size;
- global_toc_size += 4;
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "Setting data_in_toc_offset for local sym %d to %d\n",
- sym, ret_val);
-#endif
- }
- else
- {
- ret_val = local_syms[sym];
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "data_in_toc_offset already set for local sym %d to %d\n",
- sym, ret_val);
-#endif
- }
- }
- else
- {
- CHECK_EYE(h->eye_catcher);
-
- name = h->root.root.root.string;
-
- /* check to see if there's a toc slot allocated. If not, do it
- here. It will be used in relocate_section */
- if (IS_UNALLOCATED(h->toc_offset))
- {
-#if 0
- h->toc_offset = global_toc_size;
-#endif
- ret_val = global_toc_size;
- /* We're allocating a chunk of the toc, as opposed to a slot */
- /* FIXME: alignment? */
-
- global_toc_size += 4;
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "Setting data_in_toc_offset for sym %d (%s) [h=%p] to %d\n",
- sym, name, h, ret_val);
-#endif
- }
- else
- {
- ret_val = h->toc_offset;
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "data_in_toc_offset already set for sym %d (%s) [h=%p] to %d\n",
- sym, name, h, ret_val);
-#endif
- }
}
- return ret_val;
+ return true;
}
-#endif /* 0 */
-
-#ifdef COFF_IMAGE_WITH_PE
-
/* record a toc offset against a symbol */
static void
ppc_mark_symbol_as_glue(abfd, sym, rel)
struct ppc_coff_link_hash_entry *h;
h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "ppc_mark_symbol_as_glue:\n");
-#endif
- CHECK_EYE(h->eye_catcher);
+
+ HASH_CHECK(h);
h->symbol_is_glue = 1;
h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
#endif /* COFF_IMAGE_WITH_PE */
\f
-#if 0
-
-/* Provided the symbol, returns the value reffed */
-static long get_symbol_value PARAMS ((asymbol *));
-
-static long
-get_symbol_value (symbol)
- asymbol *symbol;
-{
- long relocation = 0;
-
- if (bfd_is_com_section (symbol->section))
- {
- relocation = 0;
- }
- else
- {
- relocation = symbol->value +
- symbol->section->output_section->vma +
- symbol->section->output_offset;
- }
-
- return(relocation);
-}
-
-#endif /* 0 */
/* Return true if this relocation should
appear in the output .reloc section. */
unsigned short r_type;
unsigned long addr = reloc_entry->address ; /*+ input_section->vma*/
- fprintf(stderr, "pe_ppc_reloc (%s)\n", TARGET_LITTLE_NAME);
-
r_type = reloc_entry->howto->type;
if (output_bfd)
bfd_vma relocation;
reloc_howto_type *howto = 0;
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "pe_ppc_relocate_section (%s) for %s in bfd %s\n",
- TARGET_LITTLE_NAME,
- input_section->name,
- input_bfd->filename);
-
-#endif
-
/* If we are performing a relocateable link, we don't need to do a
thing. The caller will take care of adjusting the reloc
addresses and symbol indices. */
unsigned short r_type = EXTRACT_TYPE (rel->r_type);
unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
-#ifdef DEBUG_RELOC
- /* now examine flags */
- if (r_flags != 0)
- {
- fprintf (stderr, "Reloc with flags found!");
- if ( r_flags & IMAGE_REL_PPC_NEG )
- fprintf (stderr, " NEG");
- if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
- fprintf (stderr, " BRTAKEN");
- if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
- fprintf (stderr, " BRNTAKEN");
- if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
- fprintf (stderr, " TOCDEFN");
- fprintf(stderr, "\n");
- }
-#endif
-
symndx = rel->r_symndx;
loc = contents + rel->r_vaddr - input_section->vma;
(obj_coff_sym_hashes (input_bfd)[symndx]);
if (h != 0)
{
- CHECK_EYE(h->eye_catcher);
+ HASH_CHECK(h);
}
sym = syms + symndx;
if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
{
- fprintf(stderr,
- "relocate_section: IMGLUE reloc has no name!\n");
+ /* An IMGLUE reloc must have a name. Something is very wrong. */
abort();
}
}
else
{
- CHECK_EYE(h->eye_catcher);
+ HASH_CHECK(h);
if (h->root.root.type == bfd_link_hash_defined
|| h->root.root.type == bfd_link_hash_defweak)
switch (r_type)
{
default:
- fprintf( stderr,
- "ERROR: during reloc processing -- unsupported reloc %s\n",
- howto->name);
+ (*_bfd_error_handler)
+ ("%s: unsupported relocation type 0x%02x",
+ bfd_get_filename (input_bfd), r_type);
bfd_set_error (bfd_error_bad_value);
- abort();
return false;
case IMAGE_REL_PPC_TOCREL16:
{
{
toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
TOC_SECTION_NAME);
-#ifdef TOC_DEBUG
-
- fprintf(stderr,
- "BFD of toc owner %p (%s), section addr of %s %p\n",
- bfd_of_toc_owner, bfd_of_toc_owner->filename,
- TOC_SECTION_NAME, toc_section);
-#endif
if ( toc_section == NULL )
{
- fprintf(stderr, "No Toc section!\n");
+ /* There is no toc section. Something is very wrong. */
abort();
}
}
again.
*/
MAKE_ADDR_AGAIN(our_toc_offset);
-#ifdef TOC_DEBUG
-
- fprintf(stderr,
- "Not writing out toc_offset of %d for %s\n",
- our_toc_offset, name);
-#endif
}
else
{
/* write out the toc entry */
- record_toc(toc_section, our_toc_offset, priv, strdup(name));
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "Writing out toc_offset "
- "toc_section (%p,%p)+%d val %d for %s\n",
- toc_section,
- toc_section->contents,
- our_toc_offset,
- val,
- name);
-#endif
+ record_toc(toc_section,
+ our_toc_offset,
+ priv,
+ strdup(name));
bfd_put_32(output_bfd,
val,
dll linkage, takes advantage of that and considers
the IAT to be part of the toc, thus saving a load.
*/
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "TOCDEFN is on, (%s) (%p) our_toc_offset = %x, val (%x) vma (%x) off (%x)\n",
- name, h, our_toc_offset,
- val, toc_section->output_section->vma,
- toc_section->output_offset);
-#endif
our_toc_offset = val -
(toc_section->output_section->vma +
toc_section->output_offset);
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- " our_toc_offset set to %x\n", our_toc_offset);
-#endif
-
/* The size must still fit in a 16bit displacment */
if (our_toc_offset >= 65535)
{
- fprintf(stderr,
- "Error: TOCDEFN Relocation of %d for %s exceeded displacement of 65535\n", our_toc_offset, name);
- abort();
+ (*_bfd_error_handler)
+ ("%s: Relocation for %s of %x exceeds Toc size limit",
+ bfd_get_filename (input_bfd), name, our_toc_offset);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
}
record_toc(toc_section, our_toc_offset, pub, strdup(name));
again.
*/
MAKE_ADDR_AGAIN(our_toc_offset);
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "Not writing out toc_offset of %d for %s\n",
- our_toc_offset, name);
-#endif
}
else
{
record_toc(toc_section, our_toc_offset, pub, strdup(name));
-#ifdef TOC_DEBUG
- /* write out the toc entry */
- fprintf(stderr,
- "Writing out toc_offset "
- "toc_section (%p,%p)+%d val %d for %s\n",
- toc_section,
- toc_section->contents,
- our_toc_offset,
- val,
- name);
-#endif
-
/* write out the toc entry */
bfd_put_32(output_bfd,
val,
if (coff_data(output_bfd)->pe)
addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- " Toc Section .reloc candidate addr = %x\n", addr);
-#endif
fwrite (&addr, 1,4, (FILE *) info->base_file);
}
if ( (r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN &&
our_toc_offset > toc_section->_raw_size)
{
- fprintf(stderr,
- "reloc offset is bigger than the toc size!\n");
- abort();
+ (*_bfd_error_handler)
+ ("%s: Relocation exceeds allocated TOC (%x)",
+ bfd_get_filename (input_bfd),
+ toc_section->_raw_size);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
}
/* Now we know the relocation for this toc reference */
if (h->symbol_is_glue == 1)
break;
my_name = h->root.root.root.string;
- fprintf(stderr,
- "Warning: previously missed IMGLUE reloc %s <file %s, section %s>\n",
- howto->name,
- bfd_get_filename(input_bfd),
- input_section->name);
- break;
+ (*_bfd_error_handler)
+ ("%s: Out of order IMGLUE reloc for %s",
+ bfd_get_filename (input_bfd), my_name);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
}
- break;
case IMAGE_REL_PPC_ADDR32NB:
{
"__idata4_magic__",
false, false, true);
import_table_size = myh->root.u.def.value;
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "first computation triggered fta %x, ts %d(%x), its %d(%x)\n",
- first_thunk_address, thunk_size, thunk_size, import_table_size,
- import_table_size);
-#endif
}
if (h == 0)
false, false, true);
if (myh == 0)
{
- fprintf(stderr, "Missing idata magic cookies, this cannot work anyway...\n");
+ /* Missing magic cookies. Something is very wrong. */
abort();
}
"__idata4_magic__",
false, false, true);
import_table_size = myh->root.u.def.value;
-#ifdef DEBUG_RELOC
-
- fprintf(stderr,
- "second computation triggered fta %x, ts %d(%x), its %d(%x)\n",
- first_thunk_address, thunk_size, thunk_size, import_table_size,
- import_table_size);
-#endif
}
}
}
if (coff_data(output_bfd)->pe)
{
-#ifdef DEBUG_RELOC
- bfd_vma before_addr = addr;
-#endif
addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- " adjusted down from %x to %x", before_addr, addr);
-#endif
}
-#ifdef DEBUG_RELOC
- fprintf(stderr, "\n");
-#endif
-
fwrite (&addr, 1,4, (FILE *) info->base_file);
}
}
buf[SYMNMLEN] = '\0';
name = buf;
}
-#if 0
- else
- {
- name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
- if (name == NULL)
- return false;
- }
-#endif
if (! ((*info->callbacks->reloc_overflow)
(info, name, howto->name,
(bfd_vma) 0, input_bfd,
input_section, rel->r_vaddr - input_section->vma)))
{
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "pe_ppc_relocate_section (%s) for %s in bfd %s RETURNING TRUE\n",
- TARGET_LITTLE_NAME,
- input_section->name,
- input_bfd->filename);
-
-#endif
return false;
}
}
}
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "pe_ppc_relocate_section (%s) for %s in bfd %s RETURNING TRUE\n",
- TARGET_LITTLE_NAME,
- input_section->name,
- input_bfd->filename);
-
-#endif
-
return true;
}
if (bfd_of_toc_owner == 0)
{
- fprintf(stderr,
- "There is no bfd that owns the toc section!\n");
+ /* No toc owner? Something is very wrong. */
abort();
}
s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
if (s == NULL)
{
- fprintf(stderr, "No Toc section!\n");
+ /* No toc section? Something is very wrong. */
abort();
}
asection *sec;
struct internal_reloc *i, *rel;
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- "ppc_process_before_allocation: BFD %s\n",
- bfd_get_filename(abfd));
-#endif
-
/* here we have a bfd that is to be included on the link. We have a hook
to do reloc rummaging, before section sizes are nailed down. */
for (; sec != 0; sec = sec->next)
{
- int toc_offset;
-
-#ifdef DEBUG_RELOC
- fprintf(stderr,
- " section %s reloc count %d\n",
- sec->name,
- sec->reloc_count);
-#endif
-
if (sec->reloc_count == 0)
continue;
{
unsigned short r_type = EXTRACT_TYPE (rel->r_type);
unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
+ boolean ok = true;
-#ifdef DEBUG_RELOC
- /* now examine flags */
- if (r_flags != 0)
- {
- fprintf (stderr, "Reloc with flags found!");
- if ( r_flags & IMAGE_REL_PPC_NEG )
- fprintf (stderr, " NEG");
- if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
- fprintf (stderr, " BRTAKEN");
- if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
- fprintf (stderr, " BRNTAKEN");
- if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
- fprintf (stderr, " TOCDEFN");
- fprintf(stderr, "\n");
- }
-#endif
-
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
switch(r_type)
{
case IMAGE_REL_PPC_TOCREL16:
-#if 0
- /* FIXME:
- This remains unimplemented for now, as it currently adds
- un-necessary elements to the toc. All we need to do today
- is not do anything if TOCDEFN is on.
- */
- if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
- toc_offset = ppc_record_data_in_toc_entry(abfd, info, sec,
- rel->r_symndx,
- default_toc);
- else
- toc_offset = ppc_record_toc_entry(abfd, info, sec,
- rel->r_symndx, default_toc);
-#endif
+ /* if TOCDEFN is on, ignore as someone else has allocated the
+ toc entry */
if ( (r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN )
- toc_offset = ppc_record_toc_entry(abfd, info, sec,
- rel->r_symndx, default_toc);
+ ok = ppc_record_toc_entry(abfd, info, sec,
+ rel->r_symndx, default_toc);
+ if (!ok)
+ return false;
break;
case IMAGE_REL_PPC_IMGLUE:
ppc_mark_symbol_as_glue(abfd, rel->r_symndx, rel);
/* the masking process only slices off the bottom byte for r_type. */
if ( r_type > MAX_RELOC_INDEX )
- {
- fprintf(stderr,
- "ppc_coff_rtype2howto: reloc index %d out of range [%d, %ld]\n",
- internal->r_type, 0, (long) MAX_RELOC_INDEX);
- abort();
- }
+ abort();
/* check for absolute crap */
if ( junk != 0 )
- {
- fprintf(stderr,
- "ppc_coff_rtype2howto: reloc index %d contains junk %d\n",
- internal->r_type, junk);
- abort();
- }
-
-#ifdef DEBUG_RELOC
- /* now examine flags */
- if (r_flags != 0)
- {
- fprintf (stderr, "Reloc with flags found!");
- if ( r_flags & IMAGE_REL_PPC_NEG )
- fprintf (stderr, " NEG");
- if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
- fprintf (stderr, " BRTAKEN");
- if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
- fprintf (stderr, " BRNTAKEN");
- if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
- fprintf (stderr, " TOCDEFN");
- fprintf(stderr, "\n");
- }
-#endif
+ abort();
switch(r_type)
{
/* the masking process only slices off the bottom byte for r_type. */
if ( r_type > MAX_RELOC_INDEX )
- {
- fprintf(stderr,
- "coff_ppc_rtype_to_howto: index %d out of range [%d, %ld]\n",
- r_type, 0, (long) MAX_RELOC_INDEX);
- abort();
- }
+ abort();
/* check for absolute crap */
if ( junk != 0 )
- {
- fprintf(stderr,
- "coff_ppc_rtype_to_howto: reloc index %d contains junk %d\n",
- rel->r_type, junk);
- abort();
- }
-
-#ifdef DEBUG_RELOC
- /* now examine flags */
- if (r_flags != 0)
- {
- fprintf (stderr, "Reloc with flags found!");
- if ( r_flags & IMAGE_REL_PPC_NEG )
- fprintf (stderr, " NEG");
- if ( r_flags & IMAGE_REL_PPC_BRTAKEN )
- fprintf (stderr, " BRTAKEN");
- if ( r_flags & IMAGE_REL_PPC_BRNTAKEN )
- fprintf (stderr, " BRNTAKEN");
- if ( r_flags & IMAGE_REL_PPC_TOCDEFN )
- fprintf (stderr, " TOCDEFN");
- fprintf(stderr, "\n");
- }
-#endif
-
+ abort();
+
switch(r_type)
{
case IMAGE_REL_PPC_ADDR32NB:
bfd *abfd;
bfd_reloc_code_real_type code;
{
-
-#ifdef DEBUG_RELOC
- fprintf(stderr, "ppc_coff_reloc_type_lookup for %s\n",
- bfd_get_reloc_code_name(code));
-#endif
-
switch (code)
{
HOW2MAP(BFD_RELOC_32_GOTOFF, IMAGE_REL_PPC_IMGLUE);
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY ;
-#ifdef TOC_DEBUG
- fprintf(stderr,
- "ppc_coff_swap_sym_in_hook: about to create the %s section\n",
- TOC_SECTION_NAME);
-#endif
-
s = bfd_make_section (abfd, TOC_SECTION_NAME);
if (s == NULL
|| !bfd_set_section_flags (abfd, s, flags)
|| !bfd_set_section_alignment (abfd, s, 2))
{
- fprintf(stderr,
- "toc section allocation failed!\n");
+ /* FIXME: set appropriate bfd error */
abort();
}
/* Compute the file positions for all the sections. */
if (! abfd->output_has_begun)
- bfd_coff_compute_section_file_positions (abfd);
+ {
+ if (! bfd_coff_compute_section_file_positions (abfd))
+ return false;
+ }
/* Count the line numbers and relocation entries required for the
output file. Set the file positions for the relocs. */
/* BFD back-end for IBM RS/6000 "XCOFF" files.
- Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+ Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
FIXME: Can someone provide a transliteration of this name into ASCII?
Using the following chars caused a compiler warning on HIUX (so I replaced
them with octal escapes), and isn't useful without an understanding of what
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
-#include "obstack.h"
#include "coff/internal.h"
#include "coff/rs6000.h"
#include "libcoff.h"
static boolean xcoff_mkobject PARAMS ((bfd *));
static boolean xcoff_copy_private_bfd_data PARAMS ((bfd *, bfd *));
+static boolean xcoff_is_local_label_name PARAMS ((bfd *, const char *));
static void xcoff_rtype2howto
PARAMS ((arelent *, struct internal_reloc *));
static reloc_howto_type *xcoff_reloc_type_lookup
bfd *obfd;
{
struct xcoff_tdata *ix, *ox;
+ asection *sec;
if (ibfd->xvec != obfd->xvec)
return true;
ox = xcoff_data (obfd);
ox->full_aouthdr = ix->full_aouthdr;
ox->toc = ix->toc;
- if (ix->toc_section == NULL)
- ox->toc_section = NULL;
+ if (ix->sntoc == 0)
+ ox->sntoc = 0;
else
- ox->toc_section = ix->toc_section->output_section;
- if (ix->entry_section == NULL)
- ox->entry_section = NULL;
+ {
+ sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
+ if (sec == NULL)
+ ox->sntoc = 0;
+ else
+ ox->sntoc = sec->output_section->target_index;
+ }
+ if (ix->snentry == 0)
+ ox->snentry = 0;
else
- ox->entry_section = ix->entry_section->output_section;
+ {
+ sec = coff_section_from_bfd_index (ibfd, ix->snentry);
+ if (sec == NULL)
+ ox->snentry = 0;
+ else
+ ox->snentry = sec->output_section->target_index;
+ }
ox->text_align_power = ix->text_align_power;
ox->data_align_power = ix->data_align_power;
ox->modtype = ix->modtype;
ox->maxstack = ix->maxstack;
return true;
}
+
+/* I don't think XCOFF really has a notion of local labels based on
+ name. This will mean that ld -X doesn't actually strip anything.
+ The AIX native linker does not have a -X option, and it ignores the
+ -x option. */
+
+static boolean
+xcoff_is_local_label_name (abfd, name)
+ bfd *abfd;
+ const char *name;
+{
+ return false;
+}
\f
/* The XCOFF reloc table. Actually, XCOFF relocations specify the
bitsize and whether they are signed or not, along with a
#define coff_mkobject xcoff_mkobject
#define coff_bfd_copy_private_bfd_data xcoff_copy_private_bfd_data
+#define coff_bfd_is_local_label_name xcoff_is_local_label_name
#define coff_bfd_reloc_type_lookup xcoff_reloc_type_lookup
#define coff_relocate_section _bfd_ppc_xcoff_relocate_section
BFD_JUMP_TABLE_RELOCS (coff),
BFD_JUMP_TABLE_WRITE (coff),
BFD_JUMP_TABLE_LINK (_bfd_xcoff),
- BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+ BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
COFF_SWAP_TABLE,
};
return false;
}
- /* We depend on bfd_close to free all the memory on the obstack. */
- /* FIXME if bfd_release is not using obstacks! */
+ /* We depend on bfd_close to free all the memory on the objalloc. */
return true;
}
/* Routines to link ECOFF debugging information.
- Copyright 1993 Free Software Foundation, Inc.
+ Copyright 1993, 94, 95, 96, 1997 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
This file is part of BFD, the Binary File Descriptor library.
#include "sysdep.h"
#include "bfdlink.h"
#include "libbfd.h"
-#include "obstack.h"
+#include "objalloc.h"
#include "aout/stab_gnu.h"
#include "coff/internal.h"
#include "coff/sym.h"
const struct ecoff_debug_swap * const,
struct ecoff_find_line *));
static long fdrtab_lookup PARAMS ((struct ecoff_find_line *, bfd_vma));
-
-/* Obstack allocation and deallocation routines. */
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
+static boolean lookup_line
+ PARAMS ((bfd *, struct ecoff_debug_info * const,
+ const struct ecoff_debug_swap * const, struct ecoff_find_line *));
\f
/* Routines to swap auxiliary information in and out. I am assuming
that the auxiliary information format is always going to be target
struct shuffle *rfd_end;
/* The size of the largest file shuffle. */
unsigned long largest_file_shuffle;
- /* An obstack for debugging information. */
- struct obstack memory;
+ /* An objalloc for debugging information. */
+ struct objalloc *memory;
};
/* Add a file entry to a shuffle list. */
return true;
}
- n = (struct shuffle *) obstack_alloc (&ainfo->memory,
- sizeof (struct shuffle));
+ n = (struct shuffle *) objalloc_alloc (ainfo->memory,
+ sizeof (struct shuffle));
if (!n)
{
bfd_set_error (bfd_error_no_memory);
{
struct shuffle *n;
- n = (struct shuffle *) obstack_alloc (&ainfo->memory,
- sizeof (struct shuffle));
+ n = (struct shuffle *) objalloc_alloc (ainfo->memory,
+ sizeof (struct shuffle));
if (!n)
{
bfd_set_error (bfd_error_no_memory);
output_debug->symbolic_header.issMax = 1;
}
- if (!obstack_begin (&ainfo->memory, 4050))
+ ainfo->memory = objalloc_create ();
+ if (ainfo->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
return NULL;
if (! info->relocateable)
bfd_hash_table_free (&ainfo->str_hash.table);
- obstack_free (&ainfo->memory, (PTR) NULL);
+ objalloc_free (ainfo->memory);
free (ainfo);
}
* sizeof (RFDT)));
sz = (input_symhdr->crfd + input_symhdr->ifdMax) * external_rfd_size;
- rfd_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
+ rfd_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
if (!input_debug->ifdmap || !rfd_out)
{
bfd_set_error (bfd_error_no_memory);
/* Look through the FDR's and copy over all associated debugging
information. */
sz = copied * external_fdr_size;
- fdr_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
+ fdr_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
if (!fdr_out)
{
bfd_set_error (bfd_error_no_memory);
out again. */
fgotfilename = false;
sz = fdr.csym * external_sym_size;
- sym_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
+ sym_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
if (!sym_out)
{
bfd_set_error (bfd_error_no_memory);
output_symhdr->issMax += fdr.cbSs;
}
- if ((output_bfd->xvec->header_byteorder_big_p
- == input_bfd->xvec->header_byteorder_big_p)
+ if ((output_bfd->xvec->header_byteorder
+ == input_bfd->xvec->header_byteorder)
&& input_debug->adjust == (struct ecoff_value_adjust *) NULL)
{
/* The two BFD's have the same endianness, and we don't have
+ fdr.ipdFirst * insz);
end = in + fdr.cpd * insz;
sz = fdr.cpd * outsz;
- out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
+ out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
if (!out)
{
bfd_set_error (bfd_error_no_memory);
+ fdr.ioptBase * insz);
end = in + fdr.copt * insz;
sz = fdr.copt * outsz;
- out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
+ out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
if (!out)
{
bfd_set_error (bfd_error_no_memory);
internal_sym.sc = scUndefined;
internal_sym.index = indexNil;
- external_sym = (PTR) obstack_alloc (&ainfo->memory,
- output_swap->external_sym_size);
+ external_sym = (PTR) objalloc_alloc (ainfo->memory,
+ output_swap->external_sym_size);
if (!external_sym)
{
bfd_set_error (bfd_error_no_memory);
the lang field to be langC. The fBigendian field will
indicate little endian format, but it doesn't matter because
it only applies to aux fields and there are none. */
- external_fdr = (PTR) obstack_alloc (&ainfo->memory,
- output_swap->external_fdr_size);
+ external_fdr = (PTR) objalloc_alloc (ainfo->memory,
+ output_swap->external_fdr_size);
if (!external_fdr)
{
bfd_set_error (bfd_error_no_memory);
return mid;
}
-/* Do the work of find_nearest_line. */
+/* Look up a line given an address, storing the information in
+ LINE_INFO->cache. */
-boolean
-_bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap,
- line_info, filename_ptr, functionname_ptr, retline_ptr)
+static boolean
+lookup_line (abfd, debug_info, debug_swap, line_info)
bfd *abfd;
- asection *section;
- bfd_vma offset;
struct ecoff_debug_info * const debug_info;
const struct ecoff_debug_swap * const debug_swap;
struct ecoff_find_line *line_info;
- const char **filename_ptr;
- const char **functionname_ptr;
- unsigned int *retline_ptr;
{
struct ecoff_fdrtab_entry *tab;
+ bfd_vma offset;
boolean stabs;
FDR *fdr_ptr;
int i;
- offset += section->vma;
+ offset = line_info->cache.start;
/* Build FDR table (sorted by object file's base-address) if we
don't have it already. */
}
lineno += delta;
if (offset < count * 4)
- break;
+ {
+ line_info->cache.stop += count * 4 - offset;
+ break;
+ }
offset -= count * 4;
}
symbols, at least according to gdb/mipsread.c. */
if (fdr_ptr->rss == -1)
{
- *filename_ptr = NULL;
+ line_info->cache.filename = NULL;
if (pdr.isym == -1)
- *functionname_ptr = NULL;
+ line_info->cache.functionname = NULL;
else
{
EXTR proc_ext;
((char *) debug_info->external_ext
+ pdr.isym * debug_swap->external_ext_size),
&proc_ext);
- *functionname_ptr = debug_info->ssext + proc_ext.asym.iss;
+ line_info->cache.functionname = (debug_info->ssext
+ + proc_ext.asym.iss);
}
}
else
{
SYMR proc_sym;
- *filename_ptr = debug_info->ss + fdr_ptr->issBase + fdr_ptr->rss;
+ line_info->cache.filename = (debug_info->ss
+ + fdr_ptr->issBase
+ + fdr_ptr->rss);
(*debug_swap->swap_sym_in)
(abfd,
((char *) debug_info->external_sym
- + (fdr_ptr->isymBase + pdr.isym) * debug_swap->external_sym_size),
+ + ((fdr_ptr->isymBase + pdr.isym)
+ * debug_swap->external_sym_size)),
&proc_sym);
- *functionname_ptr = debug_info->ss + fdr_ptr->issBase + proc_sym.iss;
+ line_info->cache.functionname = (debug_info->ss
+ + fdr_ptr->issBase
+ + proc_sym.iss);
}
if (lineno == ilineNil)
lineno = 0;
- *retline_ptr = lineno;
+ line_info->cache.line_num = lineno;
}
else
{
looking through the symbols until we find both a line number
and a function name which are beyond the address we want. */
- *filename_ptr = NULL;
- *functionname_ptr = NULL;
- *retline_ptr = 0;
+ line_info->cache.filename = NULL;
+ line_info->cache.functionname = NULL;
+ line_info->cache.line_num = 0;
directory_name = NULL;
main_file_name = NULL;
{
low_line_vma = sym.value;
line_file_name = current_file_name;
- *retline_ptr = sym.index;
+ line_info->cache.line_num = sym.index;
}
}
}
- if (*retline_ptr != 0)
+ if (line_info->cache.line_num != 0)
main_file_name = line_file_name;
/* We need to remove the stuff after the colon in the function
colon = strchr (buffer, ':');
if (colon != NULL)
*colon = '\0';
- *functionname_ptr = buffer;
+ line_info->cache.functionname = buffer;
}
if (main_file_name != NULL)
{
if (directory_name == NULL || main_file_name[0] == '/')
- *filename_ptr = main_file_name;
+ line_info->cache.filename = main_file_name;
else
{
sprintf (buffer + funclen, "%s%s", directory_name,
main_file_name);
- *filename_ptr = buffer + funclen;
+ line_info->cache.filename = buffer + funclen;
}
}
}
return true;
}
+
+/* Do the work of find_nearest_line. */
+
+boolean
+_bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap,
+ line_info, filename_ptr, functionname_ptr, retline_ptr)
+ bfd *abfd;
+ asection *section;
+ bfd_vma offset;
+ struct ecoff_debug_info * const debug_info;
+ const struct ecoff_debug_swap * const debug_swap;
+ struct ecoff_find_line *line_info;
+ const char **filename_ptr;
+ const char **functionname_ptr;
+ unsigned int *retline_ptr;
+{
+ offset += section->vma;
+
+ if (line_info->cache.sect == NULL
+ || line_info->cache.sect != section
+ || offset < line_info->cache.start
+ || offset >= line_info->cache.stop)
+ {
+ line_info->cache.sect = section;
+ line_info->cache.start = offset;
+ line_info->cache.stop = offset;
+ if (! lookup_line (abfd, debug_info, debug_swap, line_info))
+ {
+ line_info->cache.sect = NULL;
+ return false;
+ }
+ }
+
+ *filename_ptr = line_info->cache.filename;
+ *functionname_ptr = line_info->cache.functionname;
+ *retline_ptr = line_info->cache.line_num;
+
+ return true;
+}
\f
/* These routines copy symbolic information into a memory buffer.
#include "bfd.h"
#include "sysdep.h"
+#include "objalloc.h"
#include "libbfd.h"
-#include "obstack.h"
#ifndef S_IXUSR
#define S_IXUSR 0100 /* Execute by owner. */
/* fdopen is a loser -- we should use stdio exclusively. Unfortunately
if we do that we can't use fcntl. */
-
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
-
-#ifndef HAVE_GETPAGESIZE
-#define getpagesize() 2048
-#endif
-
+/* FIXME: This is no longer used. */
long _bfd_chunksize = -1;
/* Return a new BFD. All BFD's are allocated through this routine. */
{
bfd *nbfd;
- nbfd = (bfd *)bfd_zmalloc (sizeof (bfd));
- if (!nbfd)
- return 0;
-
- if (_bfd_chunksize <= 0)
- {
- _bfd_chunksize = getpagesize ();
- if (_bfd_chunksize <= 0)
- _bfd_chunksize = 2048;
- /* Leave some slush space, since many malloc implementations
- prepend a header, and may wind up wasting another page
- because of it. */
- _bfd_chunksize -= 32;
- }
+ nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
+ if (nbfd == NULL)
+ return NULL;
- if (!obstack_begin(&nbfd->memory, _bfd_chunksize))
+ nbfd->memory = (PTR) objalloc_create ();
+ if (nbfd->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
- return 0;
+ return NULL;
}
nbfd->arch_info = &bfd_default_arch_struct;
nbfd->direction = no_direction;
nbfd->iostream = NULL;
nbfd->where = 0;
- nbfd->sections = (asection *)NULL;
+ nbfd->sections = (asection *) NULL;
nbfd->format = bfd_unknown;
- nbfd->my_archive = (bfd *)NULL;
+ nbfd->my_archive = (bfd *) NULL;
nbfd->origin = 0;
nbfd->opened_once = false;
nbfd->output_has_begun = false;
nbfd->section_count = 0;
- nbfd->usrdata = (PTR)NULL;
+ nbfd->usrdata = (PTR) NULL;
nbfd->cacheable = false;
nbfd->flags = BFD_NO_FLAGS;
nbfd->mtime_set = false;
{
bfd *nbfd;
- nbfd = _bfd_new_bfd();
+ nbfd = _bfd_new_bfd ();
nbfd->xvec = obfd->xvec;
nbfd->my_archive = obfd;
nbfd->direction = read_direction;
bfd *nbfd;
const bfd_target *target_vec;
- nbfd = _bfd_new_bfd();
+ nbfd = _bfd_new_bfd ();
if (nbfd == NULL)
return NULL;
target_vec = bfd_find_target (target, nbfd);
- if (target_vec == NULL) {
- bfd_set_error (bfd_error_invalid_target);
- return NULL;
- }
+ if (target_vec == NULL)
+ {
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ bfd_set_error (bfd_error_invalid_target);
+ return NULL;
+ }
nbfd->filename = filename;
nbfd->direction = read_direction;
- if (bfd_open_file (nbfd) == NULL) {
- bfd_set_error (bfd_error_system_call); /* File didn't exist, or some such */
- bfd_release(nbfd,0);
- return NULL;
- }
+ if (bfd_open_file (nbfd) == NULL)
+ {
+ /* File didn't exist, or some such */
+ bfd_set_error (bfd_error_system_call);
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
+ }
+
return nbfd;
}
-
/* Don't try to `optimize' this function:
o - We lock using stack space so that interrupting the locking
#endif
if (fdflags == -1) return NULL;
- nbfd = _bfd_new_bfd();
-
+ nbfd = _bfd_new_bfd ();
if (nbfd == NULL)
return NULL;
target_vec = bfd_find_target (target, nbfd);
- if (target_vec == NULL) {
- bfd_set_error (bfd_error_invalid_target);
- return NULL;
- }
+ if (target_vec == NULL)
+ {
+ bfd_set_error (bfd_error_invalid_target);
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
+ }
+
#if defined(VMS) || defined(__GO32__)
nbfd->iostream = (PTR)fopen(filename, FOPEN_RB);
#else
default: abort ();
}
#endif
- if (nbfd->iostream == NULL) {
- (void) obstack_free (&nbfd->memory, (PTR)0);
- return NULL;
- }
+
+ if (nbfd->iostream == NULL)
+ {
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
+ }
/* OK, put everything where it belongs */
be written through, although doing so requires that we end
the previous clause with a preposition. */
/* (O_ACCMODE) parens are to avoid Ultrix header file bug */
- switch (fdflags & (O_ACCMODE)) {
- case O_RDONLY: nbfd->direction = read_direction; break;
- case O_WRONLY: nbfd->direction = write_direction; break;
- case O_RDWR: nbfd->direction = both_direction; break;
- default: abort ();
- }
-
+ switch (fdflags & O_ACCMODE)
+ {
+ case O_RDONLY: nbfd->direction = read_direction; break;
+ case O_WRONLY: nbfd->direction = write_direction; break;
+ case O_RDWR: nbfd->direction = both_direction; break;
+ default: abort ();
+ }
+
if (! bfd_cache_init (nbfd))
- return NULL;
+ {
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
+ }
nbfd->opened_once = true;
return nbfd;
if (target_vec == NULL)
{
bfd_set_error (bfd_error_invalid_target);
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
return NULL;
}
nbfd->direction = read_direction;
if (! bfd_cache_init (nbfd))
- return NULL;
+ {
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
+ }
return nbfd;
}
/* nbfd has to point to head of malloc'ed block so that bfd_close may
reclaim it correctly. */
- nbfd = _bfd_new_bfd();
+ nbfd = _bfd_new_bfd ();
if (nbfd == NULL)
return NULL;
target_vec = bfd_find_target (target, nbfd);
- if (target_vec == NULL) return NULL;
+ if (target_vec == NULL)
+ {
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
+ }
nbfd->filename = filename;
nbfd->direction = write_direction;
- if (bfd_open_file (nbfd) == NULL) {
- bfd_set_error (bfd_error_system_call); /* File not writeable, etc */
- (void) obstack_free (&nbfd->memory, (PTR)0);
- return NULL;
+ if (bfd_open_file (nbfd) == NULL)
+ {
+ bfd_set_error (bfd_error_system_call); /* File not writeable, etc */
+ objalloc_free ((struct objalloc *) nbfd->memory);
+ free (nbfd);
+ return NULL;
}
+
return nbfd;
}
and closed. If the created file is executable, then
<<chmod>> is called to mark it as such.
- All memory attached to the BFD's obstacks is released.
+ All memory attached to the BFD is released.
The file descriptor associated with the BFD is closed (even
if it was passed in to BFD by <<bfd_fdopenr>>).
}
}
- (void) obstack_free (&abfd->memory, (PTR)0);
- (void) free (abfd);
+ objalloc_free ((struct objalloc *) abfd->memory);
+ free (abfd);
return ret;
}
If the created file is executable, then <<chmod>> is called
to mark it as such.
- All memory attached to the BFD's obstacks is released.
+ All memory attached to the BFD is released.
RETURNS
<<true>> is returned if all is ok, otherwise <<false>>.
& (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
}
}
- (void) obstack_free (&abfd->memory, (PTR)0);
- (void) free(abfd);
- return ret;
-}
+ objalloc_free ((struct objalloc *) abfd->memory);
+ free (abfd);
-/*
-FUNCTION
- bfd_alloc_size
-
-SYNOPSIS
- bfd_size_type bfd_alloc_size(bfd *abfd);
-
-DESCRIPTION
- Return the number of bytes in the obstacks connected to @var{abfd}.
-
-*/
-
-bfd_size_type
-bfd_alloc_size (abfd)
- bfd *abfd;
-{
- struct _obstack_chunk *chunk = abfd->memory.chunk;
- size_t size = 0;
- while (chunk) {
- size += chunk->limit - &(chunk->contents[0]);
- chunk = chunk->prev;
- }
- return size;
+ return ret;
}
-
-
/*
FUNCTION
bfd_create
CONST char *filename;
bfd *templ;
{
- bfd *nbfd = _bfd_new_bfd();
- if (nbfd == (bfd *)NULL)
- return (bfd *)NULL;
+ bfd *nbfd;
+
+ nbfd = _bfd_new_bfd ();
+ if (nbfd == NULL)
+ return NULL;
nbfd->filename = filename;
- if(templ) {
+ if (templ)
nbfd->xvec = templ->xvec;
- }
nbfd->direction = no_direction;
- bfd_set_format(nbfd, bfd_object);
+ bfd_set_format (nbfd, bfd_object);
return nbfd;
}
PTR bfd_alloc (bfd *abfd, size_t wanted);
DESCRIPTION
- Allocate a block of @var{wanted} bytes of memory in the obstack
-
attached to <<abfd>> and return a pointer to it.
+ Allocate a block of @var{wanted} bytes of memory attached to
+ <<abfd>> and return a pointer to it.
*/
{
PTR ret;
- ret = obstack_alloc (&(abfd->memory), size);
+ ret = objalloc_alloc (abfd->memory, (unsigned long) size);
if (ret == NULL)
bfd_set_error (bfd_error_no_memory);
return ret;
size_t size;
{
PTR res;
- res = bfd_alloc(abfd, size);
+
+ res = bfd_alloc (abfd, size);
if (res)
- memset(res, 0, (size_t)size);
+ memset (res, 0, size);
return res;
}
+
+/* Free a block allocated for a BFD. */
+
+void
+bfd_release (abfd, block)
+ bfd *abfd;
+ PTR block;
+{
+ objalloc_free_block ((struct objalloc *) abfd->memory, block);
+}
| process_symbol (symbol_table[i]);
| }
- All storage for the symbols themselves is in an obstack
+ All storage for the symbols themselves is in an objalloc
connected to the BFD; it is freed when the BFD is closed.
{
if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
return false;
+ if (sym->name == NULL)
+ return false;
return bfd_is_local_label_name (abfd, sym->name);
}
projects / binutils-gdb.git / commitdiff