/* write.c - emit .o file
- Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+ Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
-/* This thing should be set up to do byteordering correctly. But... */
+/* This thing should be set up to do byteordering correctly. But... */
#include "as.h"
#include "subsegs.h"
struct frag *data_frag_root;
struct frag *bss_frag_root;
-struct frag *text_last_frag; /* Last frag in segment. */
-struct frag *data_last_frag; /* Last frag in segment. */
-static struct frag *bss_last_frag; /* Last frag in segment. */
+struct frag *text_last_frag; /* Last frag in segment. */
+struct frag *data_last_frag; /* Last frag in segment. */
+static struct frag *bss_last_frag; /* Last frag in segment. */
#endif
#ifndef BFD
#endif
long string_byte_count;
-char *next_object_file_charP; /* Tracks object file bytes. */
+char *next_object_file_charP; /* Tracks object file bytes. */
#ifndef OBJ_VMS
int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
#endif
-#endif /* BFD_ASSEMBLER */
+#endif /* BFD_ASSEMBLER */
static int n_fixups;
static void set_segment_vma PARAMS ((bfd *, asection *, PTR));
#endif
-/*
- * fix_new()
- *
- * Create a fixS in obstack 'notes'.
- */
+/* Create a fixS in obstack 'notes'. */
+
static fixS *
fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
r_type)
- fragS *frag; /* Which frag? */
- int where; /* Where in that frag? */
- int size; /* 1, 2, or 4 usually. */
- symbolS *add_symbol; /* X_add_symbol. */
- symbolS *sub_symbol; /* X_op_symbol. */
- offsetT offset; /* X_add_number. */
- int pcrel; /* TRUE if PC-relative relocation. */
+ fragS *frag; /* Which frag? */
+ int where; /* Where in that frag? */
+ int size; /* 1, 2, or 4 usually. */
+ symbolS *add_symbol; /* X_add_symbol. */
+ symbolS *sub_symbol; /* X_op_symbol. */
+ offsetT offset; /* X_add_number. */
+ int pcrel; /* TRUE if PC-relative relocation. */
#ifdef BFD_ASSEMBLER
- bfd_reloc_code_real_type r_type; /* Relocation type */
+ bfd_reloc_code_real_type r_type; /* Relocation type. */
#else
- int r_type; /* Relocation type */
+ int r_type; /* Relocation type. */
#endif
{
fixS *fixP;
#endif
#ifdef TC_FIX_TYPE
- TC_INIT_FIX_DATA(fixP);
+ TC_INIT_FIX_DATA (fixP);
#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
reverse sorted, it is convenient to have this compile
- time option. xoxorich. */
-
+ time option. xoxorich. */
{
#ifdef BFD_ASSEMBLER
fixP->fx_next = *seg_fix_rootP;
*seg_fix_rootP = fixP;
-#else /* REVERSE_SORT_RELOCS */
+#else /* REVERSE_SORT_RELOCS */
fixP->fx_next = NULL;
*seg_fix_rootP = fixP;
*seg_fix_tailP = fixP;
-#endif /* REVERSE_SORT_RELOCS */
-
+#endif /* REVERSE_SORT_RELOCS */
}
return fixP;
fixS *
fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
- fragS *frag; /* Which frag? */
- int where; /* Where in that frag? */
- int size; /* 1, 2, or 4 usually. */
- symbolS *add_symbol; /* X_add_symbol. */
- offsetT offset; /* X_add_number. */
- int pcrel; /* TRUE if PC-relative relocation. */
+ fragS *frag; /* Which frag? */
+ int where; /* Where in that frag? */
+ int size; /* 1, 2, or 4 usually. */
+ symbolS *add_symbol; /* X_add_symbol. */
+ offsetT offset; /* X_add_number. */
+ int pcrel; /* TRUE if PC-relative relocation. */
#ifdef BFD_ASSEMBLER
- bfd_reloc_code_real_type r_type; /* Relocation type */
+ bfd_reloc_code_real_type r_type; /* Relocation type. */
#else
- int r_type; /* Relocation type */
+ int r_type; /* Relocation type. */
#endif
{
return fix_new_internal (frag, where, size, add_symbol,
fixS *
fix_new_exp (frag, where, size, exp, pcrel, r_type)
- fragS *frag; /* Which frag? */
- int where; /* Where in that frag? */
- int size; /* 1, 2, or 4 usually. */
+ fragS *frag; /* Which frag? */
+ int where; /* Where in that frag? */
+ int size; /* 1, 2, or 4 usually. */
expressionS *exp; /* Expression. */
- int pcrel; /* TRUE if PC-relative relocation. */
+ int pcrel; /* TRUE if PC-relative relocation. */
#ifdef BFD_ASSEMBLER
- bfd_reloc_code_real_type r_type; /* Relocation type */
+ bfd_reloc_code_real_type r_type; /* Relocation type. */
#else
- int r_type; /* Relocation type */
+ int r_type; /* Relocation type. */
#endif
{
symbolS *add = NULL;
the difference expression cannot immediately be reduced. */
{
symbolS *stmp = make_expr_symbol (exp);
+
exp->X_op = O_symbol;
exp->X_op_symbol = 0;
exp->X_add_symbol = stmp;
exp->X_add_number = 0;
+
return fix_new_exp (frag, where, size, exp, pcrel, r_type);
}
#if defined(TC_RVA_RELOC)
r_type = TC_RVA_RELOC;
#else
- as_fatal(_("rva not supported"));
+ as_fatal (_("rva not supported"));
#endif
#endif
break;
/* Fall through. */
case O_symbol:
add = exp->X_add_symbol;
- /* Fall through. */
+ /* Fall through. */
case O_constant:
off = exp->X_add_number;
break;
break;
}
- return fix_new_internal (frag, where, size, add, sub, off,
- pcrel, r_type);
+ return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
}
/* Append a string onto another string, bumping the pointer along. */
char *fromP;
unsigned long length;
{
- /* Don't trust memcpy() of 0 chars. */
+ /* Don't trust memcpy() of 0 chars. */
if (length == 0)
return;
int section_alignment[SEG_MAXIMUM_ORDINAL];
#endif
-/*
- * This routine records the largest alignment seen for each segment.
- * If the beginning of the segment is aligned on the worst-case
- * boundary, all of the other alignments within it will work. At
- * least one object format really uses this info.
- */
+/* This routine records the largest alignment seen for each segment.
+ If the beginning of the segment is aligned on the worst-case
+ boundary, all of the other alignments within it will work. At
+ least one object format really uses this info. */
+
void
record_alignment (seg, align)
- /* Segment to which alignment pertains */
+ /* Segment to which alignment pertains. */
segT seg;
/* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
boundary, etc.) */
++*countp;
}
-#endif /* defined (BFD_ASSEMBLER) */
+#endif /* defined (BFD_ASSEMBLER) */
#if defined (BFD_ASSEMBLER) || ! defined (BFD)
subseg_new, so it is possible that seg_info is NULL. */
info = seg_info (section);
if (info != (segment_info_type *) NULL)
- info->frchainP->frch_last
- = 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. */
*last = chain_frchains_together_1 (seg, head);
}
-#endif /* BFD */
+#endif /* BFD */
#if defined (BFD_ASSEMBLER) || !defined (BFD)
#ifdef BFD_ASSEMBLER
static void
cvt_frag_to_fill (sec, fragP)
- segT sec;
+ segT sec ATTRIBUTE_UNUSED;
fragS *fragP;
#else
static void
|| ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
== fragP->fr_fix));
- /*
- * After md_convert_frag, we make the frag into a ".space 0".
- * Md_convert_frag() should set up any fixSs and constants
- * required.
- */
+ /* After md_convert_frag, we make the frag into a ".space 0".
+ md_convert_frag() should set up any fixSs and constants
+ required. */
frag_wane (fragP);
break;
}
}
-#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
+#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
#ifdef BFD_ASSEMBLER
static void
for (fragp = seginfo->frchainP->frch_root;
fragp->fr_next;
fragp = fragp->fr_next)
- /* walk to last elt */;
+ /* Walk to last elt. */
+ ;
size = fragp->fr_address + fragp->fr_fix;
}
else
for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
if (fixp->fx_done)
- /* ignore it */;
+ /* Ignore it. */
+ ;
else if (fixp->fx_addsy)
{
symbolS *sym;
table. */
if (sym != NULL)
resolve_symbol_value (sym, 1);
-
+
if (fixp->fx_subsy != NULL)
resolve_symbol_value (fixp->fx_subsy, 1);
if (symsec == NULL)
abort ();
-
+
if (bfd_is_abs_section (symsec))
{
/* The fixup_segment routine will not use this symbol in a
We refetch the segment when calling section_symbol, rather
than using symsec, because S_GET_VALUE may wind up changing
- the section when it calls resolve_symbol_value. */
+ the section when it calls resolve_symbol_value. */
fixp->fx_offset += S_GET_VALUE (sym);
fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
symbol_mark_used_in_reloc (fixp->fx_addsy);
done:
;
}
-#if 1/*def RELOC_REQUIRES_SYMBOL*/
+#if 1 /* def RELOC_REQUIRES_SYMBOL */
else
{
/* There was no symbol required by this relocation. However,
a local symbol in the absolute section. */
fixp->fx_addsy = section_symbol (absolute_section);
-/* fixp->fx_addsy->sy_used_in_reloc = 1; */
+#if 0
+ fixp->fx_addsy->sy_used_in_reloc = 1;
+#endif
}
#endif
#ifndef RELOC_EXPANSION_POSSIBLE
/* Set up reloc information as well. */
relocs = (arelent **) xmalloc (n * sizeof (arelent *));
- memset ((char*)relocs, 0, n * sizeof (arelent*));
+ memset ((char *) relocs, 0, n * sizeof (arelent *));
i = 0;
for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
for (j = 0; reloc[j]; j++)
{
- relocs[i++] = reloc[j];
- assert(i <= n);
+ relocs[i++] = reloc[j];
+ assert (i <= n);
}
data = fixp->fx_frag->fr_literal + fixp->fx_where;
if (fixp->fx_where + fixp->fx_size
as_bad_where (fixp->fx_file, fixp->fx_line,
_("internal error: fixup not contained within frag"));
for (j = 0; reloc[j]; j++)
- {
+ {
s = bfd_install_relocation (stdoutput, reloc[j],
fixp->fx_frag->fr_literal,
fixp->fx_frag->fr_address,
sec, &err);
- switch (s)
+ switch (s)
{
case bfd_reloc_ok:
break;
as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
fixp->fx_file, fixp->fx_line);
}
- }
+ }
}
n = i;
#endif
/* Write out the frags. */
if (seginfo == NULL
- || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
+ || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
return;
for (f = seginfo->frchainP->frch_root;
if (fill_size && count)
{
char buf[256];
- if (fill_size > sizeof(buf))
+ if (fill_size > sizeof (buf))
{
- /* Do it the old way. Can this ever happen? */
+ /* Do it the old way. Can this ever happen? */
while (count--)
{
x = bfd_set_section_contents (stdoutput, sec,
if (x == false)
{
bfd_perror (stdoutput->filename);
- as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
+ as_perror (_("FATAL: Can't write %s"),
+ stdoutput->filename);
exit (EXIT_FAILURE);
}
offset += fill_size;
else
{
char *bufp;
- n_per_buf = sizeof(buf)/fill_size;
+ n_per_buf = sizeof (buf) / fill_size;
for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
- memcpy(bufp, fill_literal, fill_size);
+ memcpy (bufp, fill_literal, fill_size);
}
for (; count > 0; count -= n_per_buf)
{
n_per_buf = n_per_buf > count ? count : n_per_buf;
- x = bfd_set_section_contents (stdoutput, sec,
- buf, (file_ptr) offset,
- (bfd_size_type) n_per_buf * fill_size);
+ x = bfd_set_section_contents
+ (stdoutput, sec, buf, (file_ptr) offset,
+ (bfd_size_type) n_per_buf * fill_size);
if (x != true)
as_fatal (_("Cannot write to output file."));
offset += n_per_buf * fill_size;
data_fix_root = NULL;
#endif
}
-#endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
+#endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
#if !defined (BFD_ASSEMBLER) && !defined (BFD)
static void
relax_segment (text_frag_root, SEG_TEXT);
relax_segment (data_frag_root, SEG_DATA);
relax_segment (bss_frag_root, SEG_BSS);
- /*
- * Now the addresses of frags are correct within the segment.
- */
+ /* Now the addresses of frags are correct within the segment. */
know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
- /*
- * Join the 2 segments into 1 huge segment.
- * To do this, re-compute every rn_address in the SEG_DATA frags.
- * Then join the data frags after the text frags.
- *
- * Determine a_data [length of data segment].
- */
+ /* Join the 2 segments into 1 huge segment.
+ To do this, re-compute every rn_address in the SEG_DATA frags.
+ Then join the data frags after the text frags.
+
+ Determine a_data [length of data segment]. */
if (data_frag_root)
{
register relax_addressT slide;
- know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
+ know ((text_last_frag->fr_type == rs_fill)
+ && (text_last_frag->fr_offset == 0));
H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
- slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
+ slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
#ifdef OBJ_BOUT
#define RoundUp(N,S) (((N)+(S)-1)&-(S))
/* For b.out: If the data section has a strict alignment
#endif
for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
- {
- fragP->fr_address += slide;
- } /* for each data frag */
+ fragP->fr_address += slide;
know (text_last_frag != 0);
text_last_frag->fr_next = data_frag_root;
bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
bss_address_frag.fr_address = bss_vma;
}
-#else /* ! OBJ_BOUT */
+#else /* ! OBJ_BOUT */
bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
H_GET_DATA_SIZE (&headers));
-#endif /* ! OBJ_BOUT */
+#endif /* ! OBJ_BOUT */
- /* Slide all the frags */
+ /* Slide all the frags. */
if (bss_frag_root)
{
relax_addressT slide = bss_address_frag.fr_address;
for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
- {
- fragP->fr_address += slide;
- } /* for each bss frag */
+ fragP->fr_address += slide;
}
if (bss_last_frag)
else
H_SET_BSS_SIZE (&headers, 0);
}
-#endif /* ! BFD_ASSEMBLER && ! BFD */
+#endif /* ! BFD_ASSEMBLER && ! BFD */
#if defined (BFD_ASSEMBLER) || !defined (BFD)
PTR xxx ATTRIBUTE_UNUSED;
{
static bfd_vma addr = 0;
-
+
bfd_set_section_vma (abfd, sec, addr);
addr += bfd_section_size (abfd, sec);
}
-#endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
+#endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
/* Finish the subsegments. After every sub-segment, we fake an
".align ...". This conforms to BSD4.2 brane-damage. We then fake
For this segment ...
Create a last frag. Do not leave a "being filled in frag". */
-
frag_wane (frag_now);
frag_now->fr_fix = 0;
know (frag_now->fr_next == NULL);
write_object_file ()
{
#if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
- fragS *fragP; /* Track along all frags. */
+ fragS *fragP; /* Track along all frags. */
#endif
/* Do we really want to write it? */
#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. */
+ and if so -- fix it up so that it can be program entry point. */
vms_check_for_main ();
-#endif /* OBJ_VMS */
+#endif /* OBJ_VMS */
/* From now on, we don't care about sub-segments. Build one frag chain
for each segment. Linked thru fr_next. */
bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
#else
relax_and_size_all_segments ();
-#endif /* BFD_ASSEMBLER */
+#endif /* BFD_ASSEMBLER */
#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
/* Now that the segments have their final sizes, run through the
#endif
#ifndef BFD_ASSEMBLER
- /*
- *
- * Crawl the symbol chain.
- *
- * For each symbol whose value depends on a frag, take the address of
- * that frag and subsume it into the value of the symbol.
- * After this, there is just one way to lookup a symbol value.
- * Values are left in their final state for object file emission.
- * We adjust the values of 'L' local symbols, even if we do
- * not intend to emit them to the object file, because their values
- * are needed for fix-ups.
- *
- * Unless we saw a -L flag, remove all symbols that begin with 'L'
- * from the symbol chain. (They are still pointed to by the fixes.)
- *
- * Count the remaining symbols.
- * Assign a symbol number to each symbol.
- * Count the number of string-table chars we will emit.
- * Put this info into the headers as appropriate.
- *
- */
+ /* Crawl the symbol chain.
+
+ For each symbol whose value depends on a frag, take the address of
+ that frag and subsume it into the value of the symbol.
+ After this, there is just one way to lookup a symbol value.
+ Values are left in their final state for object file emission.
+ We adjust the values of 'L' local symbols, even if we do
+ not intend to emit them to the object file, because their values
+ are needed for fix-ups.
+
+ Unless we saw a -L flag, remove all symbols that begin with 'L'
+ from the symbol chain. (They are still pointed to by the fixes.)
+
+ Count the remaining symbols.
+ Assign a symbol number to each symbol.
+ Count the number of string-table chars we will emit.
+ Put this info into the headers as appropriate. */
know (zero_address_frag.fr_address == 0);
string_byte_count = sizeof (string_byte_count);
H_SET_STRING_SIZE (&headers, string_byte_count);
- /*
- * Addresses of frags now reflect addresses we use in the object file.
- * Symbol values are correct.
- * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
- * Also converting any machine-dependent frags using md_convert_frag();
- */
+ /* Addresses of frags now reflect addresses we use in the object file.
+ Symbol values are correct.
+ Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
+ Also converting any machine-dependent frags using md_convert_frag(); */
subseg_change (SEG_TEXT, 0);
for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
abort ();
#endif
}
-#endif /* ! BFD_ASSEMBLER */
+#endif /* ! BFD_ASSEMBLER */
#ifndef WORKING_DOT_WORD
{
#ifdef BFD_ASSEMBLER
#ifdef TC_CONS_FIX_NEW
TC_CONS_FIX_NEW (lie->frag,
- lie->word_goes_here - lie->frag->fr_literal,
- 2, &exp);
+ lie->word_goes_here - lie->frag->fr_literal,
+ 2, &exp);
#else
fix_new_exp (lie->frag,
lie->word_goes_here - lie->frag->fr_literal,
fix_new_exp (lie->frag,
lie->word_goes_here - lie->frag->fr_literal,
2, &exp, 0, 0);
-#endif /* TC_NS32K */
-#endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
-#endif /* BFD_ASSEMBLER */
+#endif /* TC_NS32K */
+#endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
+#endif /* BFD_ASSEMBLER */
*prevP = lie->next_broken_word;
}
else
/* Find out how many broken_words go here. */
n = 0;
- for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
+ for (untruth = lie;
+ untruth && untruth->dispfrag == fragP;
+ untruth = untruth->next_broken_word)
if (untruth->added == 1)
n++;
table_ptr = lie->dispfrag->fr_opcode;
- table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
+ table_addr = (lie->dispfrag->fr_address
+ + (table_ptr - lie->dispfrag->fr_literal));
/* Create the jump around the long jumps. This is a short
jump from table_ptr+0 to table_ptr+n*long_jump_size. */
from_addr = table_addr;
to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
- md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
+ md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
+ lie->add);
table_ptr += md_short_jump_size;
table_addr += md_short_jump_size;
- for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
+ for (m = 0;
+ lie && lie->dispfrag == fragP;
+ m++, lie = lie->next_broken_word)
{
if (lie->added == 2)
continue;
- /* Patch the jump table */
- /* This is the offset from ??? to table_ptr+0 */
+ /* Patch the jump table. */
+ /* This is the offset from ??? to table_ptr+0. */
to_addr = table_addr - S_GET_VALUE (lie->sub);
#ifdef BFD_ASSEMBLER
to_addr -= symbol_get_frag (lie->sub)->fr_address;
TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
#endif
md_number_to_chars (lie->word_goes_here, to_addr, 2);
- for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
+ for (untruth = lie->next_broken_word;
+ untruth && untruth->dispfrag == fragP;
+ untruth = untruth->next_broken_word)
{
if (untruth->use_jump == lie)
md_number_to_chars (untruth->word_goes_here, to_addr, 2);
}
- /* Install the long jump */
- /* this is a long jump from table_ptr+0 to the final target */
+ /* Install the long jump. */
+ /* This is a long jump from table_ptr+0 to the final target. */
from_addr = table_addr;
to_addr = S_GET_VALUE (lie->add) + lie->addnum;
#ifdef BFD_ASSEMBLER
to_addr += symbol_get_frag (lie->add)->fr_address;
#endif
- md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
+ md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
+ lie->add);
table_ptr += md_long_jump_size;
table_addr += md_long_jump_size;
}
}
}
-#endif /* not WORKING_DOT_WORD */
+#endif /* not WORKING_DOT_WORD */
#ifndef BFD_ASSEMBLER
#ifndef OBJ_VMS
- { /* not vms */
+ { /* not vms */
char *the_object_file;
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.
- */
+ /* Scan every FixS performing fixups. We had to wait until now to
+ do this because md_convert_frag() may have made some fixSs. */
int trsize, drsize;
subseg_change (SEG_TEXT, 0);
drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
- /* FIXME move this stuff into the pre-write-hook */
+ /* FIXME: Move this stuff into the pre-write-hook. */
H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
H_SET_ENTRY_POINT (&headers, 0);
- obj_pre_write_hook (&headers); /* extra coff stuff */
+ obj_pre_write_hook (&headers); /* Extra coff stuff. */
object_file_size = H_GET_FILE_SIZE (&headers);
next_object_file_charP = the_object_file = xmalloc (object_file_size);
obj_header_append (&next_object_file_charP, &headers);
- know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
+ know ((next_object_file_charP - the_object_file)
+ == H_GET_HEADER_SIZE (&headers));
- /*
- * Emit code.
- */
+ /* Emit code. */
for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
{
register long count;
PROGRESS (1);
know (fragP->fr_type == rs_fill);
- append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
+ append (&next_object_file_charP, fragP->fr_literal,
+ (unsigned long) fragP->fr_fix);
fill_literal = fragP->fr_literal + fragP->fr_fix;
fill_size = fragP->fr_var;
know (fragP->fr_offset >= 0);
for (count = fragP->fr_offset; count; count--)
- {
- append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
- } /* for each */
-
- } /* for each code frag. */
-
- know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
+ append (&next_object_file_charP, fill_literal,
+ (unsigned long) fill_size);
+ }
- /*
- * Emit relocations.
- */
- obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
- know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers)));
+ know ((next_object_file_charP - the_object_file)
+ == (H_GET_HEADER_SIZE (&headers)
+ + H_GET_TEXT_SIZE (&headers)
+ + H_GET_DATA_SIZE (&headers)));
+
+ /* Emit relocations. */
+ obj_emit_relocations (&next_object_file_charP, text_fix_root,
+ (relax_addressT) 0);
+ know ((next_object_file_charP - the_object_file)
+ == (H_GET_HEADER_SIZE (&headers)
+ + H_GET_TEXT_SIZE (&headers)
+ + H_GET_DATA_SIZE (&headers)
+ + H_GET_TEXT_RELOCATION_SIZE (&headers)));
#ifdef TC_I960
/* Make addresses in data relocation directives relative to beginning of
- * first data fragment, not end of last text fragment: alignment of the
- * start of the data segment may place a gap between the segments.
- */
- obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
-#else /* TC_I960 */
- obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
-#endif /* TC_I960 */
-
- know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers)));
-
- /*
- * Emit line number entries.
- */
+ first data fragment, not end of last text fragment: alignment of the
+ start of the data segment may place a gap between the segments. */
+ obj_emit_relocations (&next_object_file_charP, data_fix_root,
+ data0_frchainP->frch_root->fr_address);
+#else /* TC_I960 */
+ obj_emit_relocations (&next_object_file_charP, data_fix_root,
+ text_last_frag->fr_address);
+#endif /* TC_I960 */
+
+ know ((next_object_file_charP - the_object_file)
+ == (H_GET_HEADER_SIZE (&headers)
+ + H_GET_TEXT_SIZE (&headers)
+ + H_GET_DATA_SIZE (&headers)
+ + H_GET_TEXT_RELOCATION_SIZE (&headers)
+ + H_GET_DATA_RELOCATION_SIZE (&headers)));
+
+ /* Emit line number entries. */
OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
- know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers) + H_GET_LINENO_SIZE (&headers)));
-
- /*
- * Emit symbols.
- */
+ know ((next_object_file_charP - the_object_file)
+ == (H_GET_HEADER_SIZE (&headers)
+ + H_GET_TEXT_SIZE (&headers)
+ + H_GET_DATA_SIZE (&headers)
+ + H_GET_TEXT_RELOCATION_SIZE (&headers)
+ + H_GET_DATA_RELOCATION_SIZE (&headers)
+ + H_GET_LINENO_SIZE (&headers)));
+
+ /* Emit symbols. */
obj_emit_symbols (&next_object_file_charP, symbol_rootP);
- know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers) + H_GET_LINENO_SIZE (&headers) + H_GET_SYMBOL_TABLE_SIZE (&headers)));
-
- /*
- * Emit strings.
- */
-
+ know ((next_object_file_charP - the_object_file)
+ == (H_GET_HEADER_SIZE (&headers)
+ + H_GET_TEXT_SIZE (&headers)
+ + H_GET_DATA_SIZE (&headers)
+ + H_GET_TEXT_RELOCATION_SIZE (&headers)
+ + H_GET_DATA_RELOCATION_SIZE (&headers)
+ + H_GET_LINENO_SIZE (&headers)
+ + H_GET_SYMBOL_TABLE_SIZE (&headers)));
+
+ /* Emit strings. */
if (string_byte_count > 0)
- {
- obj_emit_strings (&next_object_file_charP);
- } /* only if we have a string table */
+ obj_emit_strings (&next_object_file_charP);
#ifdef BFD_HEADERS
bfd_seek (stdoutput, 0, 0);
bfd_write (the_object_file, 1, object_file_size, stdoutput);
#else
- /* Write the data to the file */
+ /* Write the data to the file. */
output_file_append (the_object_file, object_file_size, out_file_name);
free (the_object_file);
#endif
- } /* non vms output */
-#else /* OBJ_VMS */
- /*
- * Now do the VMS-dependent part of writing the object file
- */
+ }
+#else /* OBJ_VMS */
+ /* Now do the VMS-dependent part of writing the object file. */
vms_write_object_file (H_GET_TEXT_SIZE (&headers),
H_GET_DATA_SIZE (&headers),
H_GET_BSS_SIZE (&headers),
text_frag_root, data_frag_root);
-#endif /* OBJ_VMS */
-#else /* BFD_ASSEMBLER */
+#endif /* OBJ_VMS */
+#else /* BFD_ASSEMBLER */
/* Resolve symbol values. This needs to be done before processing
the relocations. */
obj_frob_file_before_adjust ();
#endif
- bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
+ bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
/* Set up symbol table, and write it out. */
if (symbol_rootP)
name = S_GET_NAME (symp);
if (name)
{
- const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
+ const char *name2 =
+ decode_local_label_name ((char *) S_GET_NAME (symp));
/* They only differ if `name' is a fb or dollar local
label name. */
if (name2 != name && ! S_IS_DEFINED (symp))
&& ! symbol_used_in_reloc_p (symp)))
{
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;
}
#endif
bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
-#endif /* BFD_ASSEMBLER */
+#endif /* BFD_ASSEMBLER */
}
-#endif /* ! BFD */
-
-/*
- * relax_segment()
- *
- * Now we have a segment, not a crowd of sub-segments, we can make fr_address
- * values.
- *
- * Relax the frags.
- *
- * After this, all frags in this segment have addresses that are correct
- * within the segment. Since segments live in different file addresses,
- * these frag addresses may not be the same as final object-file addresses.
- */
+#endif /* ! BFD */
#ifdef TC_GENERIC_RELAX_TABLE
#endif
know (!(S_GET_SEGMENT (symbolP) == absolute_section)
|| symbolP->sy_frag == &zero_address_frag);
- target += S_GET_VALUE (symbolP) + symbol_get_frag (symbolP)->fr_address;
+ target += S_GET_VALUE (symbolP) + symbol_get_frag (symbolP)->fr_address;
/* If frag has yet to be reached on this pass,
assume it will move by STRETCH just as we did.
aim = target - address - fragP->fr_fix;
#ifdef TC_PCREL_ADJUST
- /* Currently only the ns32k family needs this */
- aim += TC_PCREL_ADJUST(fragP);
-/*#else*/
+ /* Currently only the ns32k family needs this. */
+ aim += TC_PCREL_ADJUST (fragP);
+/* #else */
/* This machine doesn't want to use pcrel_adjust.
In that case, pcrel_adjust should be zero. */
-/* assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);*/
+#if 0
+ assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
#endif
-#ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
+#endif
+#ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
#endif
if (aim < 0)
{
- /* Look backwards. */
+ /* Look backwards. */
for (next_state = this_type->rlx_more; next_state;)
if (aim >= this_type->rlx_backward)
next_state = 0;
else
{
- /* Grow to next state. */
+ /* Grow to next state. */
this_state = next_state;
this_type = table + this_state;
next_state = this_type->rlx_more;
}
else
{
- /* Look forwards. */
+ /* Look forwards. */
for (next_state = this_type->rlx_more; next_state;)
if (aim <= this_type->rlx_forward)
next_state = 0;
else
{
- /* Grow to next state. */
+ /* Grow to next state. */
this_state = next_state;
this_type = table + this_state;
next_state = this_type->rlx_more;
return growth;
}
-#endif /* defined (TC_GENERIC_RELAX_TABLE) */
+#endif /* defined (TC_GENERIC_RELAX_TABLE) */
/* Relax_align. Advance location counter to next address that has 'alignment'
lowest order bits all 0s, return size of adjustment made. */
static relax_addressT
relax_align (address, alignment)
- register relax_addressT address; /* Address now. */
- register int alignment; /* Alignment (binary). */
+ register relax_addressT address; /* Address now. */
+ register int alignment; /* Alignment (binary). */
{
relax_addressT mask;
relax_addressT new_address;
return (new_address - address);
}
+/* Now we have a segment, not a crowd of sub-segments, we can make
+ fr_address values.
+
+ Relax the frags.
+
+ After this, all frags in this segment have addresses that are correct
+ within the segment. Since segments live in different file addresses,
+ these frag addresses may not be the same as final object-file
+ addresses. */
+
void
relax_segment (segment_frag_root, segment)
struct frag *segment_frag_root;
#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
#endif
- /* In case md_estimate_size_before_relax() wants to make fixSs. */
+ /* In case md_estimate_size_before_relax() wants to make fixSs. */
subseg_change (segment, 0);
/* For each frag in segment: count and store (a 1st guess of)
break;
#ifndef WORKING_DOT_WORD
- /* Broken words don't concern us yet */
+ /* Broken words don't concern us yet. */
case rs_broken_word:
break;
#endif
case rs_leb128:
- /* Initial guess is always 1; doing otherwise can result in
+ /* Initial guess is always 1; doing otherwise can result in
stable solutions that are larger than the minimum. */
address += fragP->fr_offset = 1;
break;
default:
BAD_CASE (fragP->fr_type);
break;
- } /* switch(fr_type) */
- } /* for each frag in the segment */
+ }
+ }
/* Do relax(). */
{
- long stretch; /* May be any size, 0 or negative. */
- /* Cumulative number of addresses we have */
- /* relaxed this pass. */
- /* We may have relaxed more than one address. */
- long stretched; /* Have we stretched on this pass? */
+ long stretch; /* May be any size, 0 or negative. */
+ /* Cumulative number of addresses we have relaxed this pass.
+ We may have relaxed more than one address. */
+ long stretched; /* Have we stretched on this pass? */
/* This is 'cuz stretch may be zero, when, in fact some piece of code
grew, and another shrank. If a branch instruction doesn't fit anymore,
we could be scrod. */
do
{
stretch = stretched = 0;
+
for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
{
long growth = 0;
switch (fragP->fr_type)
{
- case rs_fill: /* .fill never relaxes. */
+ case rs_fill: /* .fill never relaxes. */
growth = 0;
break;
}
break;
- } /* case rs_broken_word */
+ } /* case rs_broken_word */
#endif
case rs_align:
case rs_align_code:
#endif
target += (S_GET_VALUE (symbolP)
+ symbol_get_frag (symbolP)->fr_address);
- } /* if we have a symbol */
+ } /* if we have a symbol */
know (fragP->fr_next);
after = fragP->fr_next->fr_address;
{
/* Growth may be negative, but variable part of frag
cannot have fewer than 0 chars. That is, we can't
- .org backwards. */
+ .org backwards. */
as_bad_where (fragP->fr_file, fragP->fr_line,
_("attempt to .org backwards ignored"));
growth = stretch;
}
- growth -= stretch; /* This is an absolute growth factor */
+ /* This is an absolute growth factor */
+ growth -= stretch;
break;
}
/* The default way to relax a frag is to look through
TC_GENERIC_RELAX_TABLE. */
growth = relax_frag (fragP, stretch);
-#endif /* TC_GENERIC_RELAX_TABLE */
+#endif /* TC_GENERIC_RELAX_TABLE */
#endif
break;
stretch += growth;
stretched++;
}
- } /* For each frag in the segment. */
+ } /* For each frag in the segment. */
}
- while (stretched); /* Until nothing further to relax. */
- } /* do_relax */
+ while (stretched); /* Until nothing further to relax. */
+ } /* do_relax */
- /*
- * We now have valid fr_address'es for each frag.
- */
+ /* We now have valid fr_address'es for each frag. */
- /*
- * All fr_address's are correct, relative to their own segment.
- * We have made all the fixS we will ever make.
- */
-} /* relax_segment() */
+ /* All fr_address's are correct, relative to their own segment.
+ We have made all the fixS we will ever make. */
+}
#if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
static long
fixup_segment (fixP, this_segment_type)
register fixS *fixP;
- segT this_segment_type; /* N_TYPE bits for segment. */
+ segT this_segment_type; /* N_TYPE bits for segment. */
{
long seg_reloc_count = 0;
symbolS *add_symbolP;
for (; fixP; fixP = fixP->fx_next)
{
-
#ifdef DEBUG5
fprintf (stderr, "\nprocessing fixup:\n");
print_fixup (fixP);
#endif
-
fragP = fixP->fx_frag;
know (fragP);
where = fixP->fx_where;
fixP->fx_addsy = NULL;
}
- /* It's just -sym */
+ /* It's just -sym. */
if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
{
add_number -= S_GET_VALUE (sub_symbolP);
{
/* Difference of 2 symbols from same segment.
Can't make difference of 2 undefineds: 'value' means
- something different for N_UNDF. */
+ 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_tcbit)
as_bad_where (fixP->fx_file, fixP->fx_line,
_("callj to difference of 2 symbols"));
-#endif /* TC_I960 */
+#endif /* TC_I960 */
add_number += S_GET_VALUE (add_symbolP) -
S_GET_VALUE (sub_symbolP);
add_symbolP = NULL;
- pcrel = 0; /* No further pcrel processing. */
+ pcrel = 0; /* No further pcrel processing. */
/* Let the target machine make the final determination
as to whether or not a relocation will be needed to
}
else
{
- /* Different segments in subtraction. */
+ /* Different segments in subtraction. */
know (!(S_IS_EXTERNAL (sub_symbolP)
&& (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
#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. */
+#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
)
if (add_symbol_segment == this_segment_type && pcrel && !plt
&& TC_RELOC_RTSYM_LOC_FIXUP (fixP))
{
- /*
- * 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.
- */
+ /* 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. */
+ below a no-op. */
reloc_callj (fixP);
-#endif /* TC_I960 */
+#endif /* TC_I960 */
add_number += S_GET_VALUE (add_symbolP);
add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
- pcrel = 0; /* Lie. Don't want further pcrel processing. */
+ /* Lie. Don't want further pcrel processing. */
+ pcrel = 0;
/* Let the target machine make the final determination
as to whether or not a relocation will be needed to
#ifdef TC_I960
/* See comment about reloc_callj() above. */
reloc_callj (fixP);
-#endif /* TC_I960 */
+#endif /* TC_I960 */
add_number += S_GET_VALUE (add_symbolP);
/* Let the target machine make the final determination
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.
- */
+ 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 */
+ } /* COBR. */
+#endif /* TC_I960 */
#ifdef OBJ_COFF
#ifdef TE_I386AIX
if (S_IS_COMMON (add_symbolP))
add_number += S_GET_VALUE (add_symbolP);
-#endif /* TE_I386AIX */
-#endif /* OBJ_COFF */
+#endif /* TE_I386AIX */
+#endif /* OBJ_COFF */
++seg_reloc_count;
}
else
valueT mask;
mask = 0;
- mask--; /* set all bits to one */
+ mask--; /* Set all bits to one. */
mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
if ((add_number & mask) != 0 && (add_number & mask) != mask)
{
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 */
+ } /* Generic error checking. */
}
#ifdef WARN_SIGNED_OVERFLOW_WORD
/* Warn if a .word value is too large when treated as a signed
(long) add_number,
(unsigned long) (fragP->fr_address + where));
#endif
- } /* not a bit fix */
+ } /* Not a bit fix. */
#ifdef TC_VALIDATE_FIX
skip: ATTRIBUTE_UNUSED_LABEL
fprintf (stderr, "result:\n");
print_fixup (fixP);
#endif
- } /* For each fixS in this segment. */
+ } /* For each fixS in this segment. */
TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
return seg_reloc_count;
fprintf (file, "fixups: %d\n", n_fixups);
}
-/* for debugging */
+/* For debugging. */
extern int indent_level;
void
TC_FIX_DATA_PRINT (stderr, fixp);
#endif
}
-
-/* end of write.c */
projects / binutils-gdb.git / commitdiff