From abb1d861ef2c471b2936b69b8e296a7b7fef75cf Mon Sep 17 00:00:00 2001 From: Nick Clifton Date: Mon, 3 Jul 2000 17:49:37 +0000 Subject: Fix formatting of reloc16.c Regernate generated files. --- bfd/reloc16.c | 121 +++++++++++++++++++++++++++------------------------------- 1 file changed, 57 insertions(+), 64 deletions(-) (limited to 'bfd/reloc16.c') diff --git a/bfd/reloc16.c b/bfd/reloc16.c index 0e7c18abfd9..cb9636f8f10 100644 --- a/bfd/reloc16.c +++ b/bfd/reloc16.c @@ -1,5 +1,5 @@ /* 8 and 16 bit COFF relocation functions, for BFD. - Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998 + Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 2000 Free Software Foundation, Inc. Written by Cygnus Support. @@ -19,10 +19,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/* -Most of this hacked by Steve Chamberlain, - sac@cygnus.com -*/ +/* Most of this hacked by Steve Chamberlain . */ /* These routines are used by coff-h8300 and coff-z8k to do relocation. @@ -53,7 +50,7 @@ bfd_coff_reloc16_get_value (reloc, link_info, input_section) asymbol *symbol = *(reloc->sym_ptr_ptr); /* A symbol holds a pointer to a section, and an offset from the base of the section. To relocate, we find where the section will - live in the output and add that in */ + live in the output and add that in. */ if (bfd_is_und_section (symbol->section) || bfd_is_com_section (symbol->section)) @@ -79,29 +76,29 @@ bfd_coff_reloc16_get_value (reloc, link_info, input_section) value = h->u.c.size; else { - if (! ((*link_info->callbacks->undefined_symbol) - (link_info, bfd_asymbol_name (symbol), - input_section->owner, input_section, reloc->address, - true))) + if (!((*link_info->callbacks->undefined_symbol) + (link_info, bfd_asymbol_name (symbol), + input_section->owner, input_section, reloc->address, + true))) abort (); value = 0; } } - else + else { - value = symbol->value + - symbol->section->output_offset + - symbol->section->output_section->vma; + value = symbol->value + + symbol->section->output_offset + + symbol->section->output_section->vma; } - - /* Add the value contained in the relocation */ + + /* Add the value contained in the relocation. */ value += reloc->addend; - + return value; } void -bfd_perform_slip(abfd, slip, input_section, value) +bfd_perform_slip (abfd, slip, input_section, value) bfd *abfd; unsigned int slip; asection *input_section; @@ -113,13 +110,13 @@ bfd_perform_slip(abfd, slip, input_section, value) BFD_ASSERT (s != (asymbol **) NULL); /* Find all symbols past this point, and make them know - what's happened */ - while (*s) + what's happened. */ + while (*s) { asymbol *p = *s; - if (p->section == input_section) + if (p->section == input_section) { - /* This was pointing into this section, so mangle it */ + /* This was pointing into this section, so mangle it. */ if (p->value > value) { p->value -= slip; @@ -136,17 +133,17 @@ bfd_perform_slip(abfd, slip, input_section, value) } } s++; - } + } } -boolean +boolean bfd_coff_reloc16_relax_section (abfd, i, link_info, again) bfd *abfd; asection *i; struct bfd_link_info *link_info; boolean *again; { - /* Get enough memory to hold the stuff */ + /* Get enough memory to hold the stuff. */ bfd *input_bfd = i->owner; asection *input_section = i; int *shrinks; @@ -166,7 +163,7 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again) if (!reloc_vector && reloc_size > 0) return false; - /* Get the relocs and think about them */ + /* Get the relocs and think about them. */ reloc_count = bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector, _bfd_generic_link_get_symbols (input_bfd)); @@ -190,7 +187,7 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again) entire link, we could use the generic relaxing code in the linker and get better results, particularly for jsr->bsr and 24->16 bit memory reference relaxations. */ - + if (reloc_count > 0) { int another_pass = 0; @@ -208,7 +205,7 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again) another_pass = 0; - for (i = 0, parent = reloc_vector; *parent; parent++, i++) + for (i = 0, parent = reloc_vector; *parent; parent++, i++) { /* Let the target/machine dependent code examine each reloc in this section and attempt to shrink it. */ @@ -224,15 +221,15 @@ bfd_coff_reloc16_relax_section (abfd, i, link_info, again) shrinks[j] += shrink - shrinks[i]; } } - - } while (another_pass); + } + while (another_pass); shrink = shrinks[reloc_count]; - free((char *)shrinks); + free ((char *) shrinks); } - input_section->_cooked_size -= shrink; - free((char *)reloc_vector); + input_section->_cooked_size -= shrink; + free ((char *) reloc_vector); return true; } @@ -250,7 +247,7 @@ bfd_coff_reloc16_get_relocated_section_contents(in_abfd, boolean relocateable; asymbol **symbols; { - /* Get enough memory to hold the stuff */ + /* Get enough memory to hold the stuff. */ bfd *input_bfd = link_order->u.indirect.section->owner; asection *input_section = link_order->u.indirect.section; long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); @@ -267,20 +264,19 @@ bfd_coff_reloc16_get_relocated_section_contents(in_abfd, data, relocateable, symbols); - /* read in the section */ - if (! bfd_get_section_contents(input_bfd, - input_section, - data, - 0, - input_section->_raw_size)) + /* Read in the section. */ + if (!bfd_get_section_contents(input_bfd, + input_section, + data, + 0, + input_section->_raw_size)) return NULL; - - - reloc_vector = (arelent **) bfd_malloc((size_t) reloc_size); + + reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size); if (!reloc_vector && reloc_size != 0) return NULL; - - reloc_count = bfd_canonicalize_reloc (input_bfd, + + reloc_count = bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector, symbols); @@ -289,49 +285,46 @@ bfd_coff_reloc16_get_relocated_section_contents(in_abfd, free (reloc_vector); return NULL; } - + if (reloc_count > 0) { arelent **parent = reloc_vector; - arelent *reloc ; + arelent *reloc; unsigned int dst_address = 0; unsigned int src_address = 0; unsigned int run; unsigned int idx; - - /* Find how long a run we can do */ - while (dst_address < link_order->size) + + /* Find how long a run we can do. */ + while (dst_address < link_order->size) { reloc = *parent; - if (reloc) + if (reloc) { /* Note that the relaxing didn't tie up the addresses in the relocation, so we use the original address to work out the - run of non-relocated data */ + run of non-relocated data. */ run = reloc->address - src_address; parent++; } - else + else { run = link_order->size - dst_address; } - /* Copy the bytes */ + + /* Copy the bytes. */ for (idx = 0; idx < run; idx++) - { - data[dst_address++] = data[src_address++]; - } - - /* Now do the relocation */ - - if (reloc) + data[dst_address++] = data[src_address++]; + + /* Now do the relocation. */ + if (reloc) { bfd_coff_reloc16_extra_cases (input_bfd, link_info, link_order, reloc, data, &src_address, &dst_address); - } + } } } - free((char *)reloc_vector); + free ((char *) reloc_vector); return data; } - -- cgit v1.2.1