ld/ldwrite.c

   1 /* Copyright (C) 1991 Free Software Foundation, Inc.
   2
   3 This file is part of GLD, the Gnu Linker.
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 /*
  20  * $Id$
  21 */
  22
  23 /*
  24    This module writes out the final image by reading sections from the
  25    input files, relocating them and writing them out
  26
  27    There are two main paths through this module, one for normal
  28    operation and one for partial linking.
  29
  30    During  normal operation, raw section data is read along with the
  31    associated relocation information, the relocation info applied and
  32    the section data written out on a section by section basis.
  33
  34    When partially linking, all the relocation records are read to work
  35    out how big the output relocation vector will be. Then raw data is
  36    read, relocated and written section by section.
  37
  38    Written by Steve Chamberlain steve@cygnus.com
  39
  40 */
  41
  42
  43 #include "bfd.h"
  44 #include "sysdep.h"
  45
  46 #include "ldlang.h"
  47 #include "ld.h"
  48 #include "ldwrite.h"
  49 #include "ldmisc.h"
  50 #include "ldsym.h"
  51 #include "ldgram.h"
  52
  53
  54
  55
  56 /* Static vars for do_warnings and subroutines of it */
  57 int list_unresolved_refs;       /* List unresolved refs */
  58 int list_warning_symbols;       /* List warning syms */
  59 int list_multiple_defs;         /* List multiple definitions */
  60 extern int errno;
  61 extern char *sys_errlist[];
  62
  63 extern unsigned int undefined_global_sym_count;
  64
  65 extern bfd *output_bfd;
  66
  67 extern struct lang_output_section_statement_struct * create_object_symbols;
  68
  69 extern char lprefix;
  70
  71 #ifdef __STDC__
  72 void lang_for_each_statement(void (*func)());
  73 #else /* __STDC__ */
  74 void lang_for_each_statement();
  75 #endif /* __STDC__ */
  76
  77 extern bfd_size_type largest_section;
  78 ld_config_type config;
  79
  80 extern unsigned int global_symbol_count;
  81
  82 boolean trace_files;
  83
  84 static void
  85 DEFUN(perform_relocation,(input_bfd,
  86                           input_section,
  87                           data,
  88                           symbols),
  89       bfd *input_bfd AND
  90       asection *input_section AND
  91       PTR data AND
  92       asymbol **symbols)
  93 {
  94   static asymbol *error_symbol = (asymbol *)NULL;
  95   static unsigned int error_count = 0;
  96 #define MAX_ERRORS_IN_A_ROW 5
  97   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd, input_section);
  98
  99   arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
 100   arelent **parent;
 101   bfd *ob = output_bfd;
 102   asection *os = input_section->output_section;
 103   if (config.relocateable_output == false) ob = (bfd *)NULL;
 104
 105   input_section->_cooked_size = input_section->_raw_size;
 106   input_section->reloc_done = 1;
 107
 108   if (bfd_canonicalize_reloc(input_bfd,
 109                              input_section,
 110                              reloc_vector,
 111                              symbols) )
 112     {
 113       for (parent = reloc_vector; *parent; parent++)
 114         {
 115
 116           bfd_reloc_status_type r=
 117             bfd_perform_relocation(input_bfd,
 118                                    *parent,
 119                                    data,
 120                                    input_section,
 121                                    ob);
 122
 123           if (r == bfd_reloc_ok) {
 124             if (ob != (bfd *)NULL) {
 125               /* A parital link, so keep the relocs */
 126
 127               /* Add to each relocation the offset of where it lives
 128                  in the output section */
 129 /*            (*parent)->address += input_section->output_offset;*/
 130
 131               os->orelocation[os->reloc_count] = *parent;
 132               os->reloc_count++;
 133             }
 134           }
 135           else
 136             {
 137               asymbol *s;
 138               arelent *p = *parent;
 139
 140               if (ob != (bfd *)NULL) {
 141                 /* A parital link, so keep the relocs */
 142                 os->orelocation[os->reloc_count] = *parent;
 143                 os->reloc_count++;
 144               }
 145
 146               if (p->sym_ptr_ptr != (asymbol **)NULL) {
 147                 s = *(p->sym_ptr_ptr);
 148               }
 149               else {
 150                 s = (asymbol *)NULL;
 151               }
 152               switch (r)
 153                 {
 154                 case bfd_reloc_undefined:
 155                   /* We remember the symbol, and never print more than
 156                      a reasonable number of them in a row */
 157                   if (s == error_symbol) {
 158                     error_count++;
 159                   }
 160                   else {
 161                     error_count = 0;
 162                     error_symbol = s;
 163                   }
 164                   if (error_count < MAX_ERRORS_IN_A_ROW) {
 165                     einfo("%C: undefined reference to `%T'\n",
 166                           input_bfd, input_section, symbols,
 167                           (*parent)->address, s);
 168                     config.make_executable = false;
 169                   }
 170                   else if (error_count == MAX_ERRORS_IN_A_ROW) {
 171                     einfo("%C: more undefined references to `%T' follow\n",
 172                           input_bfd, input_section,
 173                           symbols, (*parent)->address, s);
 174                   }
 175                   else {
 176                     /* Don't print any more */
 177                   }
 178                   break;
 179                 case bfd_reloc_dangerous:
 180                   einfo("%B: relocation may be wrong `%T'\n",
 181                         input_bfd, s);
 182                   break;
 183                 case bfd_reloc_outofrange:
 184                   einfo("%B:%s relocation address out of range %T (%V)\n",
 185                         input_bfd, input_section->name, s, p->address);
 186                   break;
 187                 case bfd_reloc_overflow:
 188                   einfo("%B:%s relocation overflow in %T reloc type %d\n",
 189                         input_bfd, input_section->name, s, p->howto->type);
 190                   break;
 191                 default:
 192                   einfo("%F%B: relocation error, symbol `%T'\n",
 193                         input_bfd, s);
 194                   break;
 195                 }
 196             }
 197         }
 198     }
 199   free((char *)reloc_vector);
 200 }
 201
 202
 203
 204
 205
 206
 207 PTR data_area;
 208
 209 static void
 210 DEFUN(copy_and_relocate,(statement),
 211       lang_statement_union_type *statement)
 212 {
 213   switch (statement->header.type) {
 214   case lang_fill_statement_enum:
 215       {
 216 #if 0
 217       bfd_byte play_area[SHORT_SIZE];
 218       unsigned int i;
 219       bfd_putshort(output_bfd, statement->fill_statement.fill, play_area);
 220       /* Write out all entire shorts */
 221       for (i = 0;
 222            i < statement->fill_statement.size - SHORT_SIZE + 1;
 223            i+= SHORT_SIZE)
 224         {
 225           bfd_set_section_contents(output_bfd,
 226                                    statement->fill_statement.output_section,
 227                                    play_area,
 228                                    statement->data_statement.output_offset +i,
 229                                    SHORT_SIZE);
 230
 231         }
 232
 233       /* Now write any remaining byte */
 234       if (i < statement->fill_statement.size)
 235         {
 236           bfd_set_section_contents(output_bfd,
 237                                    statement->fill_statement.output_section,
 238                                    play_area,
 239                                    statement->data_statement.output_offset +i,
 240                                    1);
 241
 242         }
 243 #endif
 244     }
 245     break;
 246   case lang_data_statement_enum:
 247     {
 248       bfd_vma value = statement->data_statement.value;
 249       bfd_byte play_area[LONG_SIZE];
 250       unsigned int size = 0;
 251       switch (statement->data_statement.type) {
 252       case LONG:
 253         bfd_put_32(output_bfd, value,  play_area);
 254         size = LONG_SIZE;
 255         break;
 256       case SHORT:
 257         bfd_put_16(output_bfd, value,  play_area);
 258         size = SHORT_SIZE;
 259         break;
 260       case BYTE:
 261         bfd_put_8(output_bfd, value,  play_area);
 262         size = BYTE_SIZE;
 263         break;
 264       }
 265
 266       bfd_set_section_contents(output_bfd,
 267                                statement->data_statement.output_section,
 268                                play_area,
 269                                statement->data_statement.output_vma,
 270                                size);
 271
 272
 273
 274
 275     }
 276     break;
 277   case lang_input_section_enum:
 278       {
 279
 280         asection *i  = statement->input_section.section;
 281         asection *output_section = i->output_section;
 282         lang_input_statement_type *ifile =
 283           statement->input_section.ifile;
 284         if (ifile->just_syms_flag == false) {
 285           bfd *inbfd = ifile->the_bfd;
 286
 287           if (output_section->flags & SEC_LOAD &&
 288               output_section->flags & SEC_ALLOC
 289               && bfd_get_section_size_before_reloc(i) != 0)
 290               {
 291                 if(bfd_get_section_contents(inbfd,
 292                                             i,
 293                                             data_area,
 294                                             (file_ptr)0,
 295                                             bfd_get_section_size_before_reloc(i)) == false)
 296                     {
 297                       einfo("%F%B error reading section contents %E\n", inbfd);
 298                     }
 299                 /* Set the reloc bit */
 300                 perform_relocation (inbfd,  i,  data_area, ifile->asymbols);
 301
 302
 303                 if(bfd_set_section_contents(output_bfd,
 304                                             output_section,
 305                                             data_area,
 306                                             (file_ptr)i->output_offset,
 307                                             bfd_get_section_size_after_reloc(i)) == false)
 308                     {
 309                       einfo("%F%B error writing section contents of %E\n",
 310                             output_bfd);
 311                     }
 312
 313               }
 314         }
 315
 316       }
 317     break;
 318
 319   default:
 320     /* All the other ones fall through */
 321     ;
 322
 323   }
 324 }
 325
 326 void
 327 DEFUN_VOID(write_norel)
 328 {
 329   /* Output the text and data segments, relocating as we go.  */
 330   lang_for_each_statement(copy_and_relocate);
 331 }
 332
 333
 334 static void
 335 DEFUN(read_relocs,(abfd, section, symbols),
 336       bfd *abfd AND
 337       asection *section AND
 338       asymbol **symbols)
 339 {
 340   /* Work out the output section ascociated with this input section */
 341   asection *output_section = section->output_section;
 342
 343   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(abfd, section);
 344   arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
 345
 346   if (bfd_canonicalize_reloc(abfd,
 347                              section,
 348                              reloc_vector,
 349                              symbols)) {
 350     output_section->reloc_count   += section->reloc_count;
 351   }
 352 }
 353
 354
 355 static  void
 356 DEFUN_VOID(write_rel)
 357 {
 358   /*
 359      Run through each section of each file and work work out the total
 360      number of relocation records which will finally be in each output
 361      section
 362      */
 363
 364   LANG_FOR_EACH_INPUT_SECTION
 365     (statement, abfd, section,
 366      (read_relocs(abfd, section, statement->asymbols)));
 367
 368
 369
 370   /*
 371      Now run though all the output sections and allocate the space for
 372      all the relocations
 373      */
 374   LANG_FOR_EACH_OUTPUT_SECTION
 375     (section,
 376      (section->orelocation =
 377       (arelent **)ldmalloc((bfd_size_type)(sizeof(arelent **)*
 378                                     section->reloc_count)),
 379       section->reloc_count = 0,
 380      section->flags |= SEC_HAS_CONTENTS));
 381
 382
 383   /*
 384      Copy the data, relocating as we go
 385      */
 386   lang_for_each_statement(copy_and_relocate);
 387 }
 388
 389 void
 390 DEFUN_VOID(ldwrite)
 391 {
 392   data_area = (PTR) ldmalloc(largest_section);
 393   if (config.relocateable_output == true)
 394       {
 395         write_rel();
 396       }
 397   else
 398       {
 399         write_relaxnorel(output_bfd);
 400       }
 401   free(data_area);
 402   /* Output the symbol table (both globals and locals).  */
 403
 404   /* Print a map, if requested.  */
 405
 406   if (config.map_file) {
 407     ldsym_print_symbol_table ();
 408     lang_map();
 409   }
 410
 411   ldsym_write ();
 412
 413 }
 414