/* write.c - emit .o file
- Copyright (C) 1986, 1987, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+ Copyright (C) 1986, 87, 90, 91, 92, 93, 1994 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
#define NOP_OPCODE 0x00
#endif
+#ifndef TC_ADJUST_RELOC_COUNT
+#define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
+#endif
+
+#ifndef TC_FORCE_RELOCATION
+#define TC_FORCE_RELOCATION(FIXP) 0
+#endif
+
#ifndef WORKING_DOT_WORD
extern CONST int md_short_jump_size;
extern CONST int md_long_jump_size;
#endif
+int symbol_table_frozen;
+
+#ifdef BFD_ASSEMBLER
+/* We generally attach relocs to frag chains. However, after we have
+ chained these all together into a segment, any relocs we add after
+ that must be attached to a segment. This will include relocs added
+ in md_estimate_size_for_relax, for example. */
+static int frags_chained = 0;
+#endif
+
#ifndef BFD_ASSEMBLER
#ifndef MANY_SEGMENTS
static struct frag *bss_last_frag; /* Last frag in segment. */
#endif
+#ifndef BFD
static object_headers headers;
-long string_byte_count;
static char *the_object_file;
+#endif
+
+long string_byte_count;
char *next_object_file_charP; /* Tracks object file bytes. */
#ifndef OBJ_VMS
offsetT offset, int pcrel,
int r_type));
#endif
+#if defined (BFD_ASSEMBLER) || !defined (BFD)
static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
+#endif
static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
-void relax_segment PARAMS ((struct frag * seg_frag_root, segT seg_type));
/*
* fix_new()
fixP->fx_pcrel_adjust = 0;
fixP->fx_bit_fixP = 0;
fixP->fx_addnumber = 0;
+ fixP->tc_fix_data = NULL;
+ fixP->fx_tcbit = 0;
+ fixP->fx_done = 0;
#ifdef TC_something
fixP->fx_bsr = 0;
#endif
-#ifdef TC_I960
- fixP->fx_callj = 0;
-#endif
+
+ as_where (&fixP->fx_file, &fixP->fx_line);
/* Usually, we want relocs sorted numerically, but while
comparing to older versions of gas that have relocs
{
#ifdef BFD_ASSEMBLER
- fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
- fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
+ fixS **seg_fix_rootP = (frags_chained
+ ? &seg_info (now_seg)->fix_root
+ : &frchain_now->fix_root);
+ fixS **seg_fix_tailP = (frags_chained
+ ? &seg_info (now_seg)->fix_tail
+ : &frchain_now->fix_tail);
#endif
#ifdef REVERSE_SORT_RELOCS
if (length == 0)
return;
- memcpy (*charPP, fromP, (int) length);
+ memcpy (*charPP, fromP, length);
*charPP += length;
}
struct frchain *frchp;
{
fragS dummy, *prev_frag = &dummy;
+ fixS fix_dummy, *prev_fix = &fix_dummy;
+
for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
{
prev_frag->fr_next = frchp->frch_root;
prev_frag = frchp->frch_last;
+#ifdef BFD_ASSEMBLER
+ if (frchp->fix_root != (fixS *) NULL)
+ {
+ if (seg_info (section)->fix_root == (fixS *) NULL)
+ seg_info (section)->fix_root = frchp->fix_root;
+ prev_fix->fx_next = frchp->fix_root;
+ seg_info (section)->fix_tail = frchp->fix_tail;
+ prev_fix = frchp->fix_tail;
+ }
+#endif
}
prev_frag->fr_next = 0;
return prev_frag;
chain_frchains_together (abfd, section, xxx)
bfd *abfd; /* unused */
segT section;
- char *xxx; /* unused */
+ PTR xxx; /* unused */
{
segment_info_type *info;
subseg_new, so it is possible that seg_info is NULL. */
info = seg_info (section);
if (info != (segment_info_type *) NULL)
- chain_frchains_together_1 (section, info->frchainP);
+ info->frchainP->frch_last
+ = chain_frchains_together_1 (section, info->frchainP);
+
+ /* Now that we've chained the frags together, we must add new fixups
+ to the segment, not to the frag chain. */
+ frags_chained = 1;
}
#endif
#endif /* BFD */
-static void
-cvt_frag_to_fill (x, fragP)
+#if defined (BFD_ASSEMBLER) || !defined (BFD)
+
#ifdef BFD_ASSEMBLER
- segT x;
-#else
- object_headers *x;
-#endif
+static void
+cvt_frag_to_fill (sec, fragP)
+ segT sec;
fragS *fragP;
-{
-#ifdef BFD_ASSEMBLER
- segT sec = x;
#else
- object_headers *headers = x;
+static void
+cvt_frag_to_fill (headers, fragP)
+ object_headers *headers;
+ fragS *fragP;
#endif
-
+{
switch (fragP->fr_type)
{
case rs_align:
HANDLE_ALIGN (fragP);
#endif
fragP->fr_type = rs_fill;
- know (fragP->fr_var == 1);
know (fragP->fr_next != NULL);
-
fragP->fr_offset = (fragP->fr_next->fr_address
- fragP->fr_address
- - fragP->fr_fix);
+ - fragP->fr_fix) / fragP->fr_var;
break;
case rs_fill:
}
}
+#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
+
#ifdef BFD_ASSEMBLER
static void
relax_and_size_seg (abfd, sec, xxx)
bfd *abfd;
asection *sec;
- char *xxx;
+ PTR xxx;
{
flagword flags;
+ fragS *fragp;
+ segment_info_type *seginfo;
+ int x;
+ valueT size, newsize;
flags = bfd_get_section_flags (abfd, sec);
- if (/*flags & SEC_ALLOC*/ 1)
+ seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
+ if (seginfo && seginfo->frchainP)
{
- fragS *fragp;
- segment_info_type *seginfo;
- int x;
- valueT size, newsize;
+ relax_segment (seginfo->frchainP->frch_root, sec);
+ for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
+ cvt_frag_to_fill (sec, fragp);
+ for (fragp = seginfo->frchainP->frch_root;
+ fragp->fr_next;
+ fragp = fragp->fr_next)
+ /* walk to last elt */;
+ size = fragp->fr_address + fragp->fr_fix;
+ }
+ else
+ size = 0;
- seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
- if (seginfo && seginfo->frchainP)
- {
- relax_segment (seginfo->frchainP->frch_root, sec);
- for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
- cvt_frag_to_fill (sec, fragp);
- for (fragp = seginfo->frchainP->frch_root;
- fragp->fr_next;
- fragp = fragp->fr_next)
- /* walk to last elt */;
- size = fragp->fr_address + fragp->fr_fix;
- }
- else
- size = 0;
- if (size > 0)
- {
- flags |= SEC_HAS_CONTENTS;
- /* @@ This is just an approximation. */
- if (seginfo->fix_root)
- flags |= SEC_RELOC;
- else
- flags &= ~SEC_RELOC;
- x = bfd_set_section_flags (abfd, sec, flags);
- assert (x == true);
- }
- size = md_section_align (sec, size);
- x = bfd_set_section_size (abfd, sec, size);
- assert (x == true);
-
- /* If the size had to be rounded up, add some padding in the last
- non-empty frag. */
- newsize = bfd_get_section_size_before_reloc (sec);
- assert (newsize >= size);
- if (size != newsize)
- {
- fragS *last = seginfo->frchainP->frch_last;
- fragp = seginfo->frchainP->frch_root;
- while (fragp->fr_next != last)
- fragp = fragp->fr_next;
- last->fr_address = size;
- fragp->fr_offset += newsize - size;
- }
+ if (size > 0 && ! seginfo->bss)
+ flags |= SEC_HAS_CONTENTS;
+
+ /* @@ This is just an approximation. */
+ if (seginfo && seginfo->fix_root)
+ flags |= SEC_RELOC;
+ else
+ flags &= ~SEC_RELOC;
+ x = bfd_set_section_flags (abfd, sec, flags);
+ assert (x == true);
+
+ newsize = md_section_align (sec, size);
+ x = bfd_set_section_size (abfd, sec, newsize);
+ assert (x == true);
+
+ /* If the size had to be rounded up, add some padding in the last
+ non-empty frag. */
+ assert (newsize >= size);
+ if (size != newsize)
+ {
+ fragS *last = seginfo->frchainP->frch_last;
+ fragp = seginfo->frchainP->frch_root;
+ while (fragp->fr_next != last)
+ fragp = fragp->fr_next;
+ last->fr_address = size;
+ fragp->fr_offset += newsize - size;
}
+
#ifdef tc_frob_section
tc_frob_section (sec);
#endif
{
symbolS *s = fixp->fx_addsy;
if (s)
- fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
- S_GET_NAME (s), s->bsym->section->name,
- S_GET_VALUE (s), fixp->fx_offset);
+ {
+ fprintf (stream, " %08x: %s(%s", fixp, S_GET_NAME (s),
+ s->bsym->section->name);
+ if (s->bsym->flags & BSF_SECTION_SYM)
+ {
+ fprintf (stream, " section sym");
+ if (S_GET_VALUE (s))
+ fprintf (stream, "+%x", S_GET_VALUE (s));
+ }
+ else
+ fprintf (stream, "+%x", S_GET_VALUE (s));
+ fprintf (stream, ")+%x\n", fixp->fx_offset);
+ }
else
fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
fixp = fixp->fx_next;
#define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
#endif
+#ifndef EMIT_SECTION_SYMBOLS
+#define EMIT_SECTION_SYMBOLS 1
+#endif
+
static void
adjust_reloc_syms (abfd, sec, xxx)
bfd *abfd;
asection *sec;
- char *xxx;
+ PTR xxx;
{
segment_info_type *seginfo = seg_info (sec);
fixS *fixp;
dump_section_relocs (abfd, sec, stderr);
for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
- if (fixp->fx_addsy)
+ if (fixp->fx_done)
+ /* ignore it */;
+ else if (fixp->fx_addsy)
{
symbolS *sym = fixp->fx_addsy;
asection *symsec = sym->bsym->section;
- segment_info_type *symseginfo = seg_info (symsec);
- /* If it's one of these sections, assume the symbol is definitely
- going to be output. */
+ /* If it's one of these sections, assume the symbol is
+ definitely going to be output. The code in
+ md_estimate_size_before_relax in tc-mips.c uses this test
+ as well, so if you change this code you should look at that
+ code. */
if (symsec == &bfd_und_section
|| symsec == &bfd_abs_section
|| bfd_is_com_section (symsec))
- continue;
+ {
+ fixp->fx_addsy->sy_used_in_reloc = 1;
+ continue;
+ }
/* Since we're reducing to section symbols, don't attempt to reduce
anything that's already using one. */
- if (sym->bsym == symsec->symbol)
- continue;
+ if (sym->bsym->flags & BSF_SECTION_SYM)
+ {
+ fixp->fx_addsy->sy_used_in_reloc = 1;
+ continue;
+ }
/* Is there some other reason we can't adjust this one? (E.g.,
call/bal links in i960-bout symbols.) */
#ifdef obj_fix_adjustable
if (! obj_fix_adjustable (fixp))
- continue;
+ {
+ fixp->fx_addsy->sy_used_in_reloc = 1;
+ continue;
+ }
#endif
+
+ /* Is there some other (target cpu dependent) reason we can't adjust
+ this one? (E.g. relocations involving function addresses on
+ the PA. */
+#ifdef tc_fix_adjustable
+ if (! tc_fix_adjustable (fixp))
+ {
+ fixp->fx_addsy->sy_used_in_reloc = 1;
+ continue;
+ }
+#endif
+
/* If the section symbol isn't going to be output, the relocs
at least should still work. If not, figure out what to do
when we run into that case. */
fixp->fx_offset += S_GET_VALUE (sym);
if (sym->sy_frag)
fixp->fx_offset += sym->sy_frag->fr_address;
- if (symseginfo->sym)
- fixp->fx_addsy = symseginfo->sym;
- else
- {
- fixp->fx_addsy = symbol_find (symsec->name);
- if (!fixp->fx_addsy)
- {
- fixp->fx_addsy = symbol_make (symsec->name);
- fixp->fx_addsy->bsym = symsec->symbol;
- }
- symseginfo->sym = fixp->fx_addsy;
- }
+ fixp->fx_addsy = section_symbol (symsec);
+ fixp->fx_addsy->sy_used_in_reloc = 1;
+ }
+#if 1/*def RELOC_REQUIRES_SYMBOL*/
+ else
+ {
+ /* There was no symbol required by this relocation. However,
+ BFD doesn't really handle relocations without symbols well.
+ (At least, the COFF support doesn't.) So for now we fake up
+ a local symbol in the absolute section. */
+
+ fixp->fx_addsy = section_symbol (absolute_section);
+ fixp->fx_addsy->sy_used_in_reloc = 1;
}
+#endif
dump_section_relocs (abfd, sec, stderr);
}
write_relocs (abfd, sec, xxx)
bfd *abfd;
asection *sec;
- char *xxx;
+ PTR xxx;
{
segment_info_type *seginfo = seg_info (sec);
- unsigned long offset = 0;
- fragS *frags;
- int i, n;
+ int i;
+ unsigned int n;
arelent **relocs;
fixS *fixp;
+ char *err;
/* If seginfo is NULL, we did not create this section; don't do
anything with it. */
for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
{
arelent *reloc;
- extern arelent *tc_gen_reloc ();
char *data;
bfd_reloc_status_type s;
- if (fixp->fx_addsy == 0)
+ if (fixp->fx_done)
{
- /* @@ Need some other flag to indicate which have already
- been performed... */
n--;
continue;
}
continue;
}
data = fixp->fx_frag->fr_literal + fixp->fx_where;
- /* @@ Assumes max size of reloc is 4. */
- if (fixp->fx_where + 4
+ if (fixp->fx_where + fixp->fx_size
> fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
abort ();
+
+ if (reloc->howto->partial_inplace == false
+ && reloc->howto->pcrel_offset == true
+ && reloc->howto->pc_relative == true)
+ {
+ /* bfd_perform_relocation screws this up */
+ reloc->addend += reloc->address;
+ }
/* Pass bogus address so that when bfd_perform_relocation adds
- `address' back in, it'll come up with `data', which is where
- we want it to operate. */
+ `reloc->address' back in, it'll come up with `data', which is where
+ we want it to operate. We can't just do it by fudging reloc->address,
+ since that might be used in the calculations(?). */
s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
- sec, stdoutput);
+ sec, stdoutput, &err);
switch (s)
{
case bfd_reloc_ok:
break;
+ case bfd_reloc_overflow:
+ as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
+ break;
default:
as_fatal ("bad return from bfd_perform_relocation");
}
for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
{
arelent **reloc;
- extern arelent *tc_gen_reloc ();
char *data;
bfd_reloc_status_type s;
int j;
- if (fixp->fx_addsy == 0)
+ if (fixp->fx_done)
{
- /* @@ Need some other flag to indicate which have already
- been performed... */
n--;
continue;
}
assert(i <= n);
}
data = fixp->fx_frag->fr_literal + fixp->fx_where;
- if (fixp->fx_where + 4
+ if (fixp->fx_where + fixp->fx_size
> fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
abort ();
for (j = 0; reloc[j]; j++)
{
- s = bfd_perform_relocation (stdoutput, reloc[j], data - reloc[j]->address,
- sec, stdoutput);
+ s = bfd_perform_relocation (stdoutput, reloc[j],
+ data - reloc[0]->address,
+ sec, stdoutput, &err);
switch (s)
{
- case bfd_reloc_ok:
- break;
- default:
- as_fatal ("bad return from bfd_perform_relocation");
+ case bfd_reloc_ok:
+ break;
+ default:
+ as_fatal ("bad return from bfd_perform_relocation");
}
}
}
n = i;
#endif
+#ifdef DEBUG4
+ {
+ int i, j, nsyms;
+ asymbol **sympp;
+ sympp = bfd_get_outsymbols (stdoutput);
+ nsyms = bfd_get_symcount (stdoutput);
+ for (i = 0; i < n; i++)
+ if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
+ {
+ for (j = 0; j < nsyms; j++)
+ if (sympp[j] == *relocs[i]->sym_ptr_ptr)
+ break;
+ if (j == nsyms)
+ abort ();
+ }
+ }
+#endif
+
if (n)
bfd_set_reloc (stdoutput, sec, relocs, n);
else
bfd_set_section_flags (abfd, sec,
- bfd_get_section_flags (abfd, sec) & ~SEC_RELOC);
-#ifdef DEBUG2
+ (bfd_get_section_flags (abfd, sec)
+ & (flagword) ~SEC_RELOC));
+
+#ifdef DEBUG3
{
int i;
arelent *r;
write_contents (abfd, sec, xxx)
bfd *abfd;
asection *sec;
- char *xxx;
+ PTR xxx;
{
segment_info_type *seginfo = seg_info (sec);
unsigned long offset = 0;
- fragS *frags;
- int i, n;
- arelent **relocs;
- fixS *fixp;
+ fragS *f;
/* Write out the frags. */
- if (! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
+ if (seginfo == NULL
+ || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
return;
- for (frags = seginfo->frchainP->frch_root;
- frags;
- frags = frags->fr_next)
+ for (f = seginfo->frchainP->frch_root;
+ f;
+ f = f->fr_next)
{
int x;
unsigned long fill_size;
char *fill_literal;
long count;
- assert (frags->fr_type == rs_fill);
- if (frags->fr_fix)
+ assert (f->fr_type == rs_fill);
+ if (f->fr_fix)
{
x = bfd_set_section_contents (stdoutput, sec,
- frags->fr_literal, offset,
- frags->fr_fix);
- assert (x == true);
- offset += frags->fr_fix;
+ f->fr_literal, (file_ptr) offset,
+ (bfd_size_type) f->fr_fix);
+ if (x == false)
+ {
+ bfd_perror (stdoutput->filename);
+ as_perror ("FATAL: Can't write %s", stdoutput->filename);
+ exit (42);
+ }
+ offset += f->fr_fix;
}
- fill_literal = frags->fr_literal + frags->fr_fix;
- fill_size = frags->fr_var;
- count = frags->fr_offset;
+ fill_literal = f->fr_literal + f->fr_fix;
+ fill_size = f->fr_var;
+ count = f->fr_offset;
assert (count >= 0);
if (fill_size && count)
while (count--)
{
x = bfd_set_section_contents (stdoutput, sec,
- fill_literal, offset,
+ fill_literal, (file_ptr) offset,
(bfd_size_type) fill_size);
- assert (x == true);
+ if (x == false)
+ {
+ bfd_perror (stdoutput->filename);
+ as_perror ("FATAL: Can't write %s", stdoutput->filename);
+ exit (42);
+ }
offset += fill_size;
}
}
}
#endif
+#if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
static void
merge_data_into_text ()
{
-#ifdef BFD_ASSEMBLER
+#if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
seg_info (text_section)->frchainP->frch_last->fr_next =
seg_info (data_section)->frchainP->frch_root;
seg_info (text_section)->frchainP->frch_last =
data_fix_root = NULL;
#endif
}
+#endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
#if !defined (BFD_ASSEMBLER) && !defined (BFD)
static void
relax_and_size_all_segments ()
{
+ fragS *fragP;
+
relax_segment (text_frag_root, SEG_TEXT);
relax_segment (data_frag_root, SEG_DATA);
relax_segment (bss_frag_root, SEG_BSS);
bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
H_GET_DATA_SIZE (&headers));
+#endif /* ! OBJ_BOUT */
/* Slide all the frags */
if (bss_frag_root)
} /* for each bss frag */
}
-#endif /* ! OBJ_BOUT */
-
if (bss_last_frag)
H_SET_BSS_SIZE (&headers,
bss_last_frag->fr_address - bss_frag_root->fr_address);
#if defined (BFD_ASSEMBLER) || !defined (BFD)
+#ifdef BFD_ASSEMBLER
+static void
+set_symtab ()
+{
+ int nsyms;
+ asymbol **asympp;
+ symbolS *symp;
+ boolean result;
+ extern PTR bfd_alloc PARAMS ((bfd *, size_t));
+
+ /* Count symbols. We can't rely on a count made by the loop in
+ write_object_file, because *_frob_file may add a new symbol or
+ two. */
+ nsyms = 0;
+ for (symp = symbol_rootP; symp; symp = symbol_next (symp))
+ nsyms++;
+
+ if (nsyms)
+ {
+ int i;
+
+ asympp = (asymbol **) bfd_alloc (stdoutput,
+ nsyms * sizeof (asymbol *));
+ symp = symbol_rootP;
+ for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
+ {
+ asympp[i] = symp->bsym;
+ symp->written = 1;
+ }
+ }
+ else
+ asympp = 0;
+ result = bfd_set_symtab (stdoutput, asympp, nsyms);
+ assert (result == true);
+ symbol_table_frozen = 1;
+}
+#endif
+
void
write_object_file ()
{
- register struct frchain *frchainP; /* Track along all frchains. */
- register fragS *fragP; /* Track along all frags. */
-#if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
- long object_file_size;
+ struct frchain *frchainP; /* Track along all frchains. */
+#if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
+ fragS *fragP; /* Track along all frags. */
#endif
/* Do we really want to write it? */
n_errs = had_errors ();
/* The -Z flag indicates that an object file should be generated,
regardless of warnings and errors. */
- if (flagseen['Z'])
+ if (flag_always_generate_output)
{
if (n_warns || n_errs)
as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
}
#ifdef OBJ_VMS
- /*
- * Under VMS we try to be compatible with VAX-11 "C". Thus, we
- * call a routine to check for the definition of the procedure
- * "_main", and if so -- fix it up so that it can be program
- * entry point.
- */
+ /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
+ a routine to check for the definition of the procedure "_main",
+ and if so -- fix it up so that it can be program entry point. */
VMS_Check_For_Main ();
#endif /* VMS */
#endif
for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
{
-#ifdef BFD_ASSEMBLER
subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
-#else
- subseg_new (frchainP->frch_seg, frchainP->frch_subseg);
-#endif
frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
/* frag_align will have left a new frag.
Use this last frag for an empty ".fill".
data frags into the text segment. Do this before relaxing so
we know to take advantage of -R and make shorter addresses. */
#if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
- if (flagseen['R'])
+ if (flag_readonly_data_in_text)
{
merge_data_into_text ();
}
#ifndef BFD_ASSEMBLER
#ifndef OBJ_VMS
{ /* not vms */
+ long object_file_size;
/*
* Scan every FixS performing fixups. We had to wait until now to do
* this because md_convert_frag() may have made some fixSs.
/* Write the data to the file */
output_file_append (the_object_file, object_file_size, out_file_name);
#endif
-
- output_file_close (out_file_name);
} /* non vms output */
#else /* VMS */
/*
#endif /* VMS */
#else /* BFD_ASSEMBLER */
-#ifdef obj_check_file_symbols
- obj_check_file_symbols ();
-#endif
-
bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
/* Set up symbol table, and write it out. */
if (symbol_rootP)
{
- int i = 0, n;
symbolS *symp;
for (symp = symbol_rootP; symp; symp = symbol_next (symp))
{
- int keep = 0;
+ int punt = 0;
if (! symp->sy_resolved)
{
symp->bsym->flags,
segment_name (symp->bsym->section));
#endif
- {
- int punt = 0;
+
#ifdef obj_frob_symbol
- obj_frob_symbol (symp, punt);
- if (punt)
- goto punt_it;
+ obj_frob_symbol (symp, punt);
#endif
#ifdef tc_frob_symbol
+ if (! punt || symp->sy_used_in_reloc)
tc_frob_symbol (symp, punt);
- if (punt)
- goto punt_it;
#endif
- }
- /* If we don't want to keep this symbol, splice it out of the
- chain now. */
- if (S_IS_LOCAL (symp))
+
+ /* If we don't want to keep this symbol, splice it out of
+ the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
+ want section symbols. Otherwise, we skip local symbols
+ and symbols that the frob_symbol macros told us to punt,
+ but we keep such symbols if they are used in relocs. */
+ if ((! EMIT_SECTION_SYMBOLS
+ && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
+ /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
+ opposites. Sometimes the former checks flags and the
+ latter examines the name... */
+ || (!S_IS_EXTERN (symp)
+ && (S_IS_LOCAL (symp) || punt)
+ && ! symp->sy_used_in_reloc))
{
- symbolS *prev, *next;
- punt_it:
- prev = symbol_previous (symp);
- next = symbol_next (symp);
-#ifdef DEBUG_SYMS
- verify_symbol_chain_2 (symp);
-#endif
- if (prev)
- {
- symbol_next (prev) = next;
- symp = prev;
- }
- else if (symp == symbol_rootP)
- symbol_rootP = next;
- else
- abort ();
- if (next)
- symbol_previous (next) = prev;
- else
- symbol_lastP = prev;
-#ifdef DEBUG_SYMS
- if (prev)
- verify_symbol_chain_2 (prev);
- else if (next)
- verify_symbol_chain_2 (next);
-#endif
+ symbol_remove (symp, &symbol_rootP, &symbol_lastP);
+ /* After symbol_remove, symbol_next(symp) still returns
+ the one that came after it in the chain. So we don't
+ need to do any extra cleanup work here. */
+
continue;
}
+ /* Make sure we really got a value for the symbol. */
+ if (! symp->sy_resolved)
+ {
+ as_bad ("can't resolve value for symbol \"%s\"",
+ S_GET_NAME (symp));
+ symp->sy_resolved = 1;
+ }
+
/* Set the value into the BFD symbol. Up til now the value
has only been kept in the gas symbolS struct. */
symp->bsym->value = S_GET_VALUE (symp);
-
- i++;
- }
- n = i;
- if (n)
- {
- asymbol **asympp;
- boolean result;
- extern PTR bfd_alloc PARAMS ((bfd *, size_t));
-
- asympp = (asymbol **) bfd_alloc (stdoutput,
- n * sizeof (asymbol *));
- symp = symbol_rootP;
- for (i = 0; i < n; i++, symp = symbol_next (symp))
- {
- asympp[i] = symp->bsym;
- symp->written = 1;
- }
- result = bfd_set_symtab (stdoutput, asympp, n);
- assert (result == true);
}
}
+ /* Now do any format-specific adjustments to the symbol table, such
+ as adding file symbols. */
+#ifdef obj_adjust_symtab
+ obj_adjust_symtab ();
+#endif
-#ifdef obj_frob_file
- /* If obj_frob_file changes the symbol value at this point, it is
+ /* Now that all the sizes are known, and contents correct, we can
+ start writing to the file. */
+ set_symtab ();
+
+ /* If *_frob_file changes the symbol value at this point, it is
responsible for moving the changed value into symp->bsym->value
as well. Hopefully all symbol value changing can be done in
- {obj,tc}_frob_symbol. */
+ *_frob_symbol. */
+#ifdef tc_frob_file
+ tc_frob_file ();
+#endif
+#ifdef obj_frob_file
obj_frob_file ();
#endif
- /* Now that all the sizes are known, and contents correct, we can
- start writing the file. */
bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
-
- output_file_close (out_file_name);
#endif /* BFD_ASSEMBLER */
}
#endif /* ! BFD */
* these frag addresses may not be the same as final object-file addresses.
*/
+#ifndef md_relax_frag
+
/* Subroutines of relax_segment. */
static int
is_dnrange (f1, f2)
return 0;
}
+#endif /* ! defined (md_relax_frag) */
+
/* Relax_align. Advance location counter to next address that has 'alignment'
lowest order bits all 0s, return size of adjustment made. */
static relax_addressT
break;
case rs_align:
- address += relax_align (address, (int) fragP->fr_offset);
+ {
+ int offset = relax_align (address, (int) fragP->fr_offset);
+ if (offset % fragP->fr_var != 0)
+ {
+ as_bad ("alignment padding (%d bytes) not a multiple of %ld",
+ offset, (long) fragP->fr_var);
+ offset -= (offset % fragP->fr_var);
+ }
+ address += offset;
+ }
break;
case rs_org:
symbolS *symbolP;
long target;
long after;
- long aim;
was_address = fragP->fr_address;
address = fragP->fr_address += stretch;
+ S_GET_VALUE (lie->sub)));
if (offset <= -32768 || offset >= 32767)
{
- if (flagseen['K'])
+ if (flag_warn_displacement)
{
char buf[50];
- sprint_value (buf, lie->addnum);
+ sprint_value (buf, (addressT) lie->addnum);
as_warn (".word %s-%s+%s didn't fit",
S_GET_NAME (lie->add),
S_GET_NAME (lie->sub),
break;
case rs_machine_dependent:
+#ifdef md_relax_frag
+ growth = md_relax_frag (fragP, stretch);
+#else
+ /* The default way to relax a frag is to look through
+ md_relax_table. */
{
const relax_typeS *this_type;
const relax_typeS *start_type;
relax_substateT next_state;
relax_substateT this_state;
+ long aim;
this_state = fragP->fr_subtype;
start_type = this_type = md_relax_table + this_state;
if (symbolP)
{
+#ifndef DIFF_EXPR_OK
#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
|| (S_GET_SEGMENT (symbolP) == SEG_DATA)
|| (S_GET_SEGMENT (symbolP) == SEG_TEXT));
#endif
know (symbolP->sy_frag);
+#endif
know (!(S_GET_SEGMENT (symbolP) == absolute_section)
|| symbolP->sy_frag == &zero_address_frag);
target +=
if (growth != 0)
fragP->fr_subtype = this_state;
}
+#endif
break;
default:
*/
} /* relax_segment() */
+#if defined (BFD_ASSEMBLER) || !defined (BFD)
+
/* fixup_segment()
Go through all the fixS's in a segment and see which ones can be
register fixS *fixP;
segT this_segment_type; /* N_TYPE bits for segment. */
{
- register long seg_reloc_count;
- register symbolS *add_symbolP;
- register symbolS *sub_symbolP;
+ long seg_reloc_count = 0;
+ symbolS *add_symbolP;
+ symbolS *sub_symbolP;
valueT add_number;
- register int size;
- register char *place;
- register long where;
- register char pcrel;
- register fragS *fragP;
- register segT add_symbol_segment = absolute_section;
-
- seg_reloc_count = 0;
- /* If the linker is doing the relaxing, we must not do any fixups */
+ int size;
+ char *place;
+ long where;
+ char pcrel;
+ fragS *fragP;
+ segT add_symbol_segment = absolute_section;
+
+ /* If the linker is doing the relaxing, we must not do any fixups.
+
+ Well, strictly speaking that's not true -- we could do any that are
+ PC-relative and don't cross regions that could change size. And for the
+ i960 (the only machine for which we've got a relaxing linker right now),
+ we might be able to turn callx/callj into bal anyways in cases where we
+ know the maximum displacement. */
if (linkrelax)
- for (; fixP; fixP = fixP->fx_next)
- seg_reloc_count++;
- else
- for (; fixP; fixP = fixP->fx_next)
- {
- fragP = fixP->fx_frag;
- know (fragP);
- where = fixP->fx_where;
- place = fragP->fr_literal + where;
- size = fixP->fx_size;
- add_symbolP = fixP->fx_addsy;
-#ifdef TC_I960
- if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
- {
- /* Relocation should be done via the associated 'bal'
- entry point symbol. */
+ {
+ for (; fixP; fixP = fixP->fx_next)
+ seg_reloc_count++;
+ TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
+ return seg_reloc_count;
+ }
- if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
- {
- as_bad ("No 'bal' entry point for leafproc %s",
- S_GET_NAME (add_symbolP));
- continue;
- }
- fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
- }
+ for (; fixP; fixP = fixP->fx_next)
+ {
+ fragP = fixP->fx_frag;
+ know (fragP);
+ where = fixP->fx_where;
+ place = fragP->fr_literal + where;
+ size = fixP->fx_size;
+ add_symbolP = fixP->fx_addsy;
+#ifdef TC_VALIDATE_FIX
+ TC_VALIDATE_FIX (fixP, this_segment_type, skip);
#endif
- sub_symbolP = fixP->fx_subsy;
- add_number = fixP->fx_offset;
- pcrel = fixP->fx_pcrel;
-
- if (add_symbolP)
- add_symbol_segment = S_GET_SEGMENT (add_symbolP);
-
- if (sub_symbolP)
- {
- if (!add_symbolP)
- {
- /* Its just -sym */
- if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
- as_bad ("Negative of non-absolute symbol %s",
- S_GET_NAME (sub_symbolP));
-
+ sub_symbolP = fixP->fx_subsy;
+ add_number = fixP->fx_offset;
+ pcrel = fixP->fx_pcrel;
+
+ if (add_symbolP)
+ add_symbol_segment = S_GET_SEGMENT (add_symbolP);
+
+ if (sub_symbolP)
+ {
+ if (!add_symbolP)
+ {
+ /* Its just -sym */
+ if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
add_number -= S_GET_VALUE (sub_symbolP);
- }
- else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
- && (SEG_NORMAL (add_symbol_segment)
- || (add_symbol_segment == absolute_section)))
- {
- /* Difference of 2 symbols from same segment.
- Can't make difference of 2 undefineds: 'value' means
- something different for N_UNDF. */
+ else if (pcrel
+ && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
+ {
+ /* Should try converting to a constant. */
+ goto bad_sub_reloc;
+ }
+ else
+ bad_sub_reloc:
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "Negative of non-absolute symbol %s",
+ S_GET_NAME (sub_symbolP));
+ }
+ else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
+ && (SEG_NORMAL (add_symbol_segment)
+ || (add_symbol_segment == absolute_section)))
+ {
+ /* Difference of 2 symbols from same segment.
+ Can't make difference of 2 undefineds: 'value' means
+ something different for N_UNDF. */
#ifdef TC_I960
- /* Makes no sense to use the difference of 2 arbitrary symbols
- as the target of a call instruction. */
- if (fixP->fx_callj)
- {
- as_bad ("callj to difference of 2 symbols");
- }
+ /* Makes no sense to use the difference of 2 arbitrary symbols
+ as the target of a call instruction. */
+ if (fixP->fx_tcbit)
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "callj to difference of 2 symbols");
#endif /* TC_I960 */
- add_number += S_GET_VALUE (add_symbolP) -
- S_GET_VALUE (sub_symbolP);
+ add_number += S_GET_VALUE (add_symbolP) -
+ S_GET_VALUE (sub_symbolP);
- add_symbolP = NULL;
- fixP->fx_addsy = NULL;
- }
- else
- {
- /* Different segments in subtraction. */
- know (!(S_IS_EXTERNAL (sub_symbolP)
- && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
+ add_symbolP = NULL;
- if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
- {
- add_number -= S_GET_VALUE (sub_symbolP);
- }
- else
- {
- char buf[50];
- sprint_value (buf, fragP->fr_address + where);
- as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
- segment_name (S_GET_SEGMENT (sub_symbolP)),
- S_GET_NAME (sub_symbolP), buf);
- }
- }
- }
+ /* Let the target machine make the final determination
+ as to whether or not a relocation will be needed to
+ handle this fixup. */
+ if (!TC_FORCE_RELOCATION (fixP))
+ {
+ fixP->fx_addsy = NULL;
+ }
+ }
+ else
+ {
+ /* Different segments in subtraction. */
+ know (!(S_IS_EXTERNAL (sub_symbolP)
+ && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
- if (add_symbolP)
- {
- if (add_symbol_segment == this_segment_type && pcrel)
- {
- /*
- * This fixup was made when the symbol's segment was
- * SEG_UNKNOWN, but it is now in the local segment.
- * So we know how to do the address without relocation.
- */
+ if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
+ add_number -= S_GET_VALUE (sub_symbolP);
+
+#ifdef DIFF_EXPR_OK
+ else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
+#if 0 /* Do this even if it's already described as pc-relative. For example,
+ on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
+ pc-relative mode. */
+ && pcrel
+#endif
+ )
+ {
+ /* Make it pc-relative. */
+ add_number += (md_pcrel_from (fixP)
+ - S_GET_VALUE (sub_symbolP));
+ pcrel = 1;
+ fixP->fx_pcrel = 1;
+ sub_symbolP = 0;
+ fixP->fx_subsy = 0;
+ }
+#endif
+#ifdef BFD_ASSEMBLER
+ else if (fixP->fx_r_type == BFD_RELOC_GPREL32
+ || fixP->fx_r_type == BFD_RELOC_GPREL16)
+ {
+ /* Leave it alone. */
+ }
+#endif
+ else
+ {
+ char buf[50];
+ sprint_value (buf, fragP->fr_address + where);
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
+ segment_name (S_GET_SEGMENT (sub_symbolP)),
+ S_GET_NAME (sub_symbolP), buf);
+ }
+ }
+ }
+
+ if (add_symbolP)
+ {
+ if (add_symbol_segment == this_segment_type && pcrel)
+ {
+ /*
+ * This fixup was made when the symbol's segment was
+ * SEG_UNKNOWN, but it is now in the local segment.
+ * So we know how to do the address without relocation.
+ */
#ifdef TC_I960
- /* reloc_callj() may replace a 'call' with a 'calls' or a
- 'bal', in which cases it modifies *fixP as appropriate.
- In the case of a 'calls', no further work is required,
- and *fixP has been set up to make the rest of the code
- below a no-op. */
- reloc_callj (fixP);
+ /* reloc_callj() may replace a 'call' with a 'calls' or a
+ 'bal', in which cases it modifies *fixP as appropriate.
+ In the case of a 'calls', no further work is required,
+ and *fixP has been set up to make the rest of the code
+ below a no-op. */
+ reloc_callj (fixP);
#endif /* TC_I960 */
- add_number += S_GET_VALUE (add_symbolP);
- add_number -= md_pcrel_from (fixP);
- pcrel = 0; /* Lie. Don't want further pcrel processing. */
- fixP->fx_addsy = NULL; /* No relocations please. */
- }
- else
- {
- if (add_symbol_segment == absolute_section)
- {
+ add_number += S_GET_VALUE (add_symbolP);
+ add_number -= md_pcrel_from (fixP);
+ pcrel = 0; /* Lie. Don't want further pcrel processing. */
+
+ /* Let the target machine make the final determination
+ as to whether or not a relocation will be needed to
+ handle this fixup. */
+ if (!TC_FORCE_RELOCATION (fixP))
+ {
+ fixP->fx_pcrel = 0;
+ fixP->fx_addsy = NULL;
+ }
+ }
+ else
+ {
+ if (add_symbol_segment == absolute_section)
+ {
#ifdef TC_I960
- /* See comment about reloc_callj() above. */
- reloc_callj (fixP);
+ /* See comment about reloc_callj() above. */
+ reloc_callj (fixP);
#endif /* TC_I960 */
- add_number += S_GET_VALUE (add_symbolP);
- fixP->fx_addsy = NULL;
- add_symbolP = NULL;
- }
- else if (add_symbol_segment == undefined_section
+ add_number += S_GET_VALUE (add_symbolP);
+
+ /* Let the target machine make the final determination
+ as to whether or not a relocation will be needed to
+ handle this fixup. */
+ if (!TC_FORCE_RELOCATION (fixP))
+ {
+ fixP->fx_addsy = NULL;
+ add_symbolP = NULL;
+ }
+ }
+ else if (add_symbol_segment == undefined_section
#ifdef BFD_ASSEMBLER
- || add_symbol_segment == &bfd_com_section
+ || bfd_is_com_section (add_symbol_segment)
#endif
- )
- {
+ )
+ {
#ifdef TC_I960
- if ((int) fixP->fx_bit_fixP == 13)
- {
- /* This is a COBR instruction. They have only a
- * 13-bit displacement and are only to be used
- * for local branches: flag as error, don't generate
- * relocation.
- */
- as_bad ("can't use COBR format with external label");
- fixP->fx_addsy = NULL; /* No relocations please. */
- continue;
- } /* COBR */
+ if ((int) fixP->fx_bit_fixP == 13)
+ {
+ /* This is a COBR instruction. They have only a
+ * 13-bit displacement and are only to be used
+ * for local branches: flag as error, don't generate
+ * relocation.
+ */
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "can't use COBR format with external label");
+ fixP->fx_addsy = NULL;
+ fixP->fx_done = 1;
+ continue;
+ } /* COBR */
#endif /* TC_I960 */
-
+
#ifdef OBJ_COFF
#ifdef TE_I386AIX
- if (S_IS_COMMON (add_symbolP))
- add_number += S_GET_VALUE (add_symbolP);
+ if (S_IS_COMMON (add_symbolP))
+ add_number += S_GET_VALUE (add_symbolP);
#endif /* TE_I386AIX */
#endif /* OBJ_COFF */
- ++seg_reloc_count;
- }
- else
- {
- seg_reloc_count++;
- add_number += S_GET_VALUE (add_symbolP);
- }
- } /* if not in local seg */
- } /* if there was a + symbol */
+ ++seg_reloc_count;
+ }
+ else
+ {
+ seg_reloc_count++;
+ add_number += S_GET_VALUE (add_symbolP);
+ }
+ }
+ }
- if (pcrel)
- {
- add_number -= md_pcrel_from (fixP);
- if (add_symbolP == 0)
- {
- fixP->fx_addsy = &abs_symbol;
- ++seg_reloc_count;
- } /* if there's an add_symbol */
- } /* if pcrel */
+ if (pcrel)
+ {
+ add_number -= md_pcrel_from (fixP);
+ if (add_symbolP == 0)
+ {
+#ifndef BFD_ASSEMBLER
+ fixP->fx_addsy = &abs_symbol;
+#else
+ fixP->fx_addsy = section_symbol (absolute_section);
+#endif
+ fixP->fx_addsy->sy_used_in_reloc = 1;
+ ++seg_reloc_count;
+ }
+ }
- if (!fixP->fx_bit_fixP)
- {
- if ((size == 1
- && (add_number & ~0xFF)
- && ((add_number & ~0xFF) != (-1 & ~0xFF)))
- || (size == 2
- && (add_number & ~0xFFFF)
- && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)))
- || (size == 4
- && (add_number & ~(valueT)0xFFFFFFFF)
- && ((add_number & ~(valueT)0xFFFFFFFF) != (-1 & ~(valueT)0xFFFFFFFF)))
- )
- {
- char buf[50];
- sprint_value (buf, fragP->fr_address + where);
- as_bad ("Value of %d too large for field of %d bytes at %s",
- add_number, size, buf);
- } /* generic error checking */
+ if (!fixP->fx_bit_fixP && size > 0)
+ {
+ valueT mask = 0;
+ if (size < sizeof (mask))
+ {
+ /* set all bits to one */
+ mask--;
+ /* Technically, combining these produces an undefined result
+ if size is sizeof (valueT), though I think these two
+ half-way operations should both be defined. And the
+ compiler should be able to combine them if it's valid on
+ the host architecture. */
+ mask <<= size * 4;
+ mask <<= size * 4;
+ if ((add_number & mask) != 0
+ && (add_number & mask) != mask)
+ {
+ char buf[50], buf2[50];
+ sprint_value (buf, fragP->fr_address + where);
+ if (add_number > 1000)
+ sprint_value (buf2, add_number);
+ else
+ sprintf (buf2, "%ld", (long) add_number);
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "Value of %s too large for field of %d bytes at %s",
+ buf2, size, buf);
+ } /* generic error checking */
+ }
#ifdef WARN_SIGNED_OVERFLOW_WORD
- /* Warn if a .word value is too large when treated as a signed
- number. We already know it is not too negative. This is to
- catch over-large switches generated by gcc on the 68k. */
- if (!flagseen['J']
- && size == 2
- && add_number > 0x7fff)
- as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
- add_number, fragP->fr_address + where);
+ /* Warn if a .word value is too large when treated as a signed
+ number. We already know it is not too negative. This is to
+ catch over-large switches generated by gcc on the 68k. */
+ if (!flag_signed_overflow_ok
+ && size == 2
+ && add_number > 0x7fff)
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ "Signed .word overflow; switch may be too large; %ld at 0x%lx",
+ (long) add_number,
+ (unsigned long) (fragP->fr_address + where));
#endif
- } /* not a bit fix */
+ } /* not a bit fix */
+ if (!fixP->fx_done)
+ {
#ifdef BFD_ASSEMBLER
- md_apply_fix (fixP, &add_number);
+ md_apply_fix (fixP, &add_number);
#else
- md_apply_fix (fixP, add_number);
+ md_apply_fix (fixP, add_number);
#endif
- } /* For each fixS in this segment. */
-#ifdef OBJ_COFF
-#ifdef TC_I960
- {
- fixS *topP = fixP;
+#ifndef TC_HANDLES_FX_DONE
+ /* If the tc-* files haven't been converted, assume it's handling
+ it the old way, where a null fx_addsy means that the fix has
+ been applied completely, and no further work is needed. */
+ if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
+ fixP->fx_done = 1;
+#endif
+ }
+#ifdef TC_VALIDATE_FIX
+ skip:
+#endif
+ ;
+ } /* For each fixS in this segment. */
- /* two relocs per callj under coff. */
- for (fixP = topP; fixP; fixP = fixP->fx_next)
- {
- if (fixP->fx_callj && fixP->fx_addsy != 0)
- {
- ++seg_reloc_count;
- } /* if callj and not already fixed. */
- } /* for each fix */
- }
-#endif /* TC_I960 */
+ TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
+ return seg_reloc_count;
+}
-#endif /* OBJ_COFF */
- return (seg_reloc_count);
+#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
+
+void
+number_to_chars_bigendian (buf, val, n)
+ char *buf;
+ valueT val;
+ int n;
+{
+ if (n > sizeof (val)|| n <= 0)
+ abort ();
+ while (n--)
+ {
+ buf[n] = val & 0xff;
+ val >>= 8;
+ }
+}
+
+void
+number_to_chars_littleendian (buf, val, n)
+ char *buf;
+ valueT val;
+ int n;
+{
+ if (n > sizeof (val) || n <= 0)
+ abort ();
+ while (n--)
+ {
+ *buf++ = val & 0xff;
+ val >>= 8;
+ }
}
/* end of write.c */
projects / binutils.git / blobdiff