bfd/som.c

   1 /* bfd back-end for HP PA-RISC SOM objects.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997
   3    Free Software Foundation, Inc.
   4
   5    Contributed by the Center for Software Science at the
   6    University of Utah (pa-gdb-bugs@cs.utah.edu).
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 #include "bfd.h"
  25 #include "sysdep.h"
  26
  27 #if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD) || defined (HOST_HPPAOSF)
  28
  29 #include "libbfd.h"
  30 #include "som.h"
  31
  32 #include <stdio.h>
  33 #include <sys/types.h>
  34 #include <sys/param.h>
  35 #include <signal.h>
  36 #include <machine/reg.h>
  37 #include <sys/file.h>
  38 #include <errno.h>
  39 #include <ctype.h>
  40
  41 /* Magic not defined in standard HP-UX header files until 8.0 */
  42
  43 #ifndef CPU_PA_RISC1_0
  44 #define CPU_PA_RISC1_0 0x20B
  45 #endif /* CPU_PA_RISC1_0 */
  46
  47 #ifndef CPU_PA_RISC1_1
  48 #define CPU_PA_RISC1_1 0x210
  49 #endif /* CPU_PA_RISC1_1 */
  50
  51 #ifndef _PA_RISC1_0_ID
  52 #define _PA_RISC1_0_ID CPU_PA_RISC1_0
  53 #endif /* _PA_RISC1_0_ID */
  54
  55 #ifndef _PA_RISC1_1_ID
  56 #define _PA_RISC1_1_ID CPU_PA_RISC1_1
  57 #endif /* _PA_RISC1_1_ID */
  58
  59 #ifndef _PA_RISC_MAXID
  60 #define _PA_RISC_MAXID  0x2FF
  61 #endif /* _PA_RISC_MAXID */
  62
  63 #ifndef _PA_RISC_ID
  64 #define _PA_RISC_ID(__m_num)            \
  65     (((__m_num) == _PA_RISC1_0_ID) ||   \
  66      ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID))
  67 #endif /* _PA_RISC_ID */
  68
  69
  70 /* HIUX in it's infinite stupidity changed the names for several "well
  71    known" constants.  Work around such braindamage.  Try the HPUX version
  72    first, then the HIUX version, and finally provide a default.  */
  73 #ifdef HPUX_AUX_ID
  74 #define EXEC_AUX_ID HPUX_AUX_ID
  75 #endif
  76
  77 #if !defined (EXEC_AUX_ID) && defined (HIUX_AUX_ID)
  78 #define EXEC_AUX_ID HIUX_AUX_ID
  79 #endif
  80
  81 #ifndef EXEC_AUX_ID
  82 #define EXEC_AUX_ID 0
  83 #endif
  84
  85 /* Size (in chars) of the temporary buffers used during fixup and string
  86    table writes.   */
  87
  88 #define SOM_TMP_BUFSIZE 8192
  89
  90 /* Size of the hash table in archives.  */
  91 #define SOM_LST_HASH_SIZE 31
  92
  93 /* Max number of SOMs to be found in an archive.  */
  94 #define SOM_LST_MODULE_LIMIT 1024
  95
  96 /* Generic alignment macro.  */
  97 #define SOM_ALIGN(val, alignment) \
  98   (((val) + (alignment) - 1) & ~((alignment) - 1))
  99
 100 /* SOM allows any one of the four previous relocations to be reused
 101    with a "R_PREV_FIXUP" relocation entry.  Since R_PREV_FIXUP
 102    relocations are always a single byte, using a R_PREV_FIXUP instead
 103    of some multi-byte relocation makes object files smaller.
 104
 105    Note one side effect of using a R_PREV_FIXUP is the relocation that
 106    is being repeated moves to the front of the queue.  */
 107 struct reloc_queue
 108   {
 109     unsigned char *reloc;
 110     unsigned int size;
 111   } reloc_queue[4];
 112
 113 /* This fully describes the symbol types which may be attached to
 114    an EXPORT or IMPORT directive.  Only SOM uses this formation
 115    (ELF has no need for it).  */
 116 typedef enum
 117 {
 118   SYMBOL_TYPE_UNKNOWN,
 119   SYMBOL_TYPE_ABSOLUTE,
 120   SYMBOL_TYPE_CODE,
 121   SYMBOL_TYPE_DATA,
 122   SYMBOL_TYPE_ENTRY,
 123   SYMBOL_TYPE_MILLICODE,
 124   SYMBOL_TYPE_PLABEL,
 125   SYMBOL_TYPE_PRI_PROG,
 126   SYMBOL_TYPE_SEC_PROG,
 127 } pa_symbol_type;
 128
 129 struct section_to_type
 130 {
 131   char *section;
 132   char type;
 133 };
 134
 135 /* Assorted symbol information that needs to be derived from the BFD symbol
 136    and/or the BFD backend private symbol data.  */
 137 struct som_misc_symbol_info
 138 {
 139   unsigned int symbol_type;
 140   unsigned int symbol_scope;
 141   unsigned int arg_reloc;
 142   unsigned int symbol_info;
 143   unsigned int symbol_value;
 144 };
 145
 146 /* Forward declarations */
 147
 148 static boolean som_mkobject PARAMS ((bfd *));
 149 static const bfd_target * som_object_setup PARAMS ((bfd *,
 150                                                     struct header *,
 151                                                     struct som_exec_auxhdr *));
 152 static boolean setup_sections PARAMS ((bfd *, struct header *));
 153 static const bfd_target * som_object_p PARAMS ((bfd *));
 154 static boolean som_write_object_contents PARAMS ((bfd *));
 155 static boolean som_slurp_string_table PARAMS ((bfd *));
 156 static unsigned int som_slurp_symbol_table PARAMS ((bfd *));
 157 static long som_get_symtab_upper_bound PARAMS ((bfd *));
 158 static long som_canonicalize_reloc PARAMS ((bfd *, sec_ptr,
 159                                             arelent **, asymbol **));
 160 static long som_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
 161 static unsigned int som_set_reloc_info PARAMS ((unsigned char *, unsigned int,
 162                                                 arelent *, asection *,
 163                                                 asymbol **, boolean));
 164 static boolean som_slurp_reloc_table PARAMS ((bfd *, asection *,
 165                                               asymbol **, boolean));
 166 static long som_get_symtab PARAMS ((bfd *, asymbol **));
 167 static asymbol * som_make_empty_symbol PARAMS ((bfd *));
 168 static void som_print_symbol PARAMS ((bfd *, PTR,
 169                                       asymbol *, bfd_print_symbol_type));
 170 static boolean som_new_section_hook PARAMS ((bfd *, asection *));
 171 static boolean som_bfd_copy_private_symbol_data PARAMS ((bfd *, asymbol *,
 172                                                           bfd *, asymbol *));
 173 static boolean som_bfd_copy_private_section_data PARAMS ((bfd *, asection *,
 174                                                           bfd *, asection *));
 175 static boolean som_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 176 #define som_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
 177 #define som_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
 178 static boolean som_bfd_is_local_label_name PARAMS ((bfd *, const char *));
 179 static boolean som_set_section_contents PARAMS ((bfd *, sec_ptr, PTR,
 180                                                  file_ptr, bfd_size_type));
 181 static boolean som_get_section_contents PARAMS ((bfd *, sec_ptr, PTR,
 182                                                  file_ptr, bfd_size_type));
 183 static boolean som_set_arch_mach PARAMS ((bfd *, enum bfd_architecture,
 184                                           unsigned long));
 185 static boolean som_find_nearest_line PARAMS ((bfd *, asection *,
 186                                               asymbol **, bfd_vma,
 187                                               CONST char **,
 188                                               CONST char **,
 189                                               unsigned int *));
 190 static void som_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
 191 static asection * bfd_section_from_som_symbol PARAMS ((bfd *,
 192                                         struct symbol_dictionary_record *));
 193 static int log2 PARAMS ((unsigned int));
 194 static bfd_reloc_status_type hppa_som_reloc PARAMS ((bfd *, arelent *,
 195                                                      asymbol *, PTR,
 196                                                      asection *, bfd *,
 197                                                      char **));
 198 static void som_initialize_reloc_queue PARAMS ((struct reloc_queue *));
 199 static void som_reloc_queue_insert PARAMS ((unsigned char *, unsigned int,
 200                                             struct reloc_queue *));
 201 static void som_reloc_queue_fix PARAMS ((struct reloc_queue *, unsigned int));
 202 static int som_reloc_queue_find PARAMS ((unsigned char *, unsigned int,
 203                                          struct reloc_queue *));
 204 static unsigned char * try_prev_fixup PARAMS ((bfd *, int *, unsigned char *,
 205                                                unsigned int,
 206                                                struct reloc_queue *));
 207
 208 static unsigned char * som_reloc_skip PARAMS ((bfd *, unsigned int,
 209                                                unsigned char *, unsigned int *,
 210                                                struct reloc_queue *));
 211 static unsigned char * som_reloc_addend PARAMS ((bfd *, int, unsigned char *,
 212                                                  unsigned int *,
 213                                                  struct reloc_queue *));
 214 static unsigned char * som_reloc_call PARAMS ((bfd *, unsigned char *,
 215                                                unsigned int *,
 216                                                arelent *, int,
 217                                                struct reloc_queue *));
 218 static unsigned long som_count_spaces PARAMS ((bfd *));
 219 static unsigned long som_count_subspaces PARAMS ((bfd *));
 220 static int compare_syms PARAMS ((const void *, const void *));
 221 static int compare_subspaces PARAMS ((const void *, const void *));
 222 static unsigned long som_compute_checksum PARAMS ((bfd *));
 223 static boolean som_prep_headers PARAMS ((bfd *));
 224 static int som_sizeof_headers PARAMS ((bfd *, boolean));
 225 static boolean som_finish_writing PARAMS ((bfd *));
 226 static boolean som_build_and_write_symbol_table PARAMS ((bfd *));
 227 static void som_prep_for_fixups PARAMS ((bfd *, asymbol **, unsigned long));
 228 static boolean som_write_fixups PARAMS ((bfd *, unsigned long, unsigned int *));
 229 static boolean som_write_space_strings PARAMS ((bfd *, unsigned long,
 230                                                 unsigned int *));
 231 static boolean som_write_symbol_strings PARAMS ((bfd *, unsigned long,
 232                                                  asymbol **, unsigned int,
 233                                                  unsigned *));
 234 static boolean som_begin_writing PARAMS ((bfd *));
 235 static reloc_howto_type * som_bfd_reloc_type_lookup
 236         PARAMS ((bfd *, bfd_reloc_code_real_type));
 237 static char som_section_type PARAMS ((const char *));
 238 static int som_decode_symclass PARAMS ((asymbol *));
 239 static boolean som_bfd_count_ar_symbols PARAMS ((bfd *, struct lst_header *,
 240                                                  symindex *));
 241
 242 static boolean som_bfd_fill_in_ar_symbols PARAMS ((bfd *, struct lst_header *,
 243                                                    carsym **syms));
 244 static boolean som_slurp_armap PARAMS ((bfd *));
 245 static boolean som_write_armap PARAMS ((bfd *, unsigned int, struct orl *,
 246                                         unsigned int, int));
 247 static void som_bfd_derive_misc_symbol_info PARAMS ((bfd *, asymbol *,
 248                                              struct som_misc_symbol_info *));
 249 static boolean som_bfd_prep_for_ar_write PARAMS ((bfd *, unsigned int *,
 250                                                   unsigned int *));
 251 static unsigned int som_bfd_ar_symbol_hash PARAMS ((asymbol *));
 252 static boolean som_bfd_ar_write_symbol_stuff PARAMS ((bfd *, unsigned int,
 253                                                       unsigned int,
 254                                                       struct lst_header,
 255                                                       unsigned int));
 256 static boolean som_is_space PARAMS ((asection *));
 257 static boolean som_is_subspace PARAMS ((asection *));
 258 static boolean som_is_container PARAMS ((asection *, asection *));
 259 static boolean som_bfd_free_cached_info PARAMS ((bfd *));
 260 static boolean som_bfd_link_split_section PARAMS ((bfd *, asection *));
 261
 262 /* Map SOM section names to POSIX/BSD single-character symbol types.
 263
 264    This table includes all the standard subspaces as defined in the
 265    current "PRO ABI for PA-RISC Systems", $UNWIND$ which for
 266    some reason was left out, and sections specific to embedded stabs.  */
 267
 268 static const struct section_to_type stt[] = {
 269   {"$TEXT$", 't'},
 270   {"$SHLIB_INFO$", 't'},
 271   {"$MILLICODE$", 't'},
 272   {"$LIT$", 't'},
 273   {"$CODE$", 't'},
 274   {"$UNWIND_START$", 't'},
 275   {"$UNWIND$", 't'},
 276   {"$PRIVATE$", 'd'},
 277   {"$PLT$", 'd'},
 278   {"$SHLIB_DATA$", 'd'},
 279   {"$DATA$", 'd'},
 280   {"$SHORTDATA$", 'g'},
 281   {"$DLT$", 'd'},
 282   {"$GLOBAL$", 'g'},
 283   {"$SHORTBSS$", 's'},
 284   {"$BSS$", 'b'},
 285   {"$GDB_STRINGS$", 'N'},
 286   {"$GDB_SYMBOLS$", 'N'},
 287   {0, 0}
 288 };
 289
 290 /* About the relocation formatting table...
 291
 292    There are 256 entries in the table, one for each possible
 293    relocation opcode available in SOM.  We index the table by
 294    the relocation opcode.  The names and operations are those
 295    defined by a.out_800 (4).
 296
 297    Right now this table is only used to count and perform minimal
 298    processing on relocation streams so that they can be internalized
 299    into BFD and symbolically printed by utilities.  To make actual use
 300    of them would be much more difficult, BFD's concept of relocations
 301    is far too simple to handle SOM relocations.  The basic assumption
 302    that a relocation can be completely processed independent of other
 303    relocations before an object file is written is invalid for SOM.
 304
 305    The SOM relocations are meant to be processed as a stream, they
 306    specify copying of data from the input section to the output section
 307    while possibly modifying the data in some manner.  They also can
 308    specify that a variable number of zeros or uninitialized data be
 309    inserted on in the output segment at the current offset.  Some
 310    relocations specify that some previous relocation be re-applied at
 311    the current location in the input/output sections.  And finally a number
 312    of relocations have effects on other sections (R_ENTRY, R_EXIT,
 313    R_UNWIND_AUX and a variety of others).  There isn't even enough room
 314    in the BFD relocation data structure to store enough information to
 315    perform all the relocations.
 316
 317    Each entry in the table has three fields.
 318
 319    The first entry is an index into this "class" of relocations.  This
 320    index can then be used as a variable within the relocation itself.
 321
 322    The second field is a format string which actually controls processing
 323    of the relocation.  It uses a simple postfix machine to do calculations
 324    based on variables/constants found in the string and the relocation
 325    stream.
 326
 327    The third field specifys whether or not this relocation may use
 328    a constant (V) from the previous R_DATA_OVERRIDE rather than a constant
 329    stored in the instruction.
 330
 331    Variables:
 332
 333    L = input space byte count
 334    D = index into class of relocations
 335    M = output space byte count
 336    N = statement number (unused?)
 337    O = stack operation
 338    R = parameter relocation bits
 339    S = symbol index
 340    T = first 32 bits of stack unwind information
 341    U = second 32 bits of stack unwind information
 342    V = a literal constant (usually used in the next relocation)
 343    P = a previous relocation
 344
 345    Lower case letters (starting with 'b') refer to following
 346    bytes in the relocation stream.  'b' is the next 1 byte,
 347    c is the next 2 bytes, d is the next 3 bytes, etc...
 348    This is the variable part of the relocation entries that
 349    makes our life a living hell.
 350
 351    numerical constants are also used in the format string.  Note
 352    the constants are represented in decimal.
 353
 354    '+', "*" and "=" represents the obvious postfix operators.
 355    '<' represents a left shift.
 356
 357    Stack Operations:
 358
 359    Parameter Relocation Bits:
 360
 361    Unwind Entries:
 362
 363    Previous Relocations:  The index field represents which in the queue
 364    of 4 previous fixups should be re-applied.
 365
 366    Literal Constants:  These are generally used to represent addend
 367    parts of relocations when these constants are not stored in the
 368    fields of the instructions themselves.  For example the instruction
 369    addil foo-$global$-0x1234 would use an override for "0x1234" rather
 370    than storing it into the addil itself.  */
 371
 372 struct fixup_format
 373 {
 374   int D;
 375   char *format;
 376 };
 377
 378 static const struct fixup_format som_fixup_formats[256] =
 379 {
 380   /* R_NO_RELOCATION */
 381   0,   "LD1+4*=",       /* 0x00 */
 382   1,   "LD1+4*=",       /* 0x01 */
 383   2,   "LD1+4*=",       /* 0x02 */
 384   3,   "LD1+4*=",       /* 0x03 */
 385   4,   "LD1+4*=",       /* 0x04 */
 386   5,   "LD1+4*=",       /* 0x05 */
 387   6,   "LD1+4*=",       /* 0x06 */
 388   7,   "LD1+4*=",       /* 0x07 */
 389   8,   "LD1+4*=",       /* 0x08 */
 390   9,   "LD1+4*=",       /* 0x09 */
 391   10,  "LD1+4*=",       /* 0x0a */
 392   11,  "LD1+4*=",       /* 0x0b */
 393   12,  "LD1+4*=",       /* 0x0c */
 394   13,  "LD1+4*=",       /* 0x0d */
 395   14,  "LD1+4*=",       /* 0x0e */
 396   15,  "LD1+4*=",       /* 0x0f */
 397   16,  "LD1+4*=",       /* 0x10 */
 398   17,  "LD1+4*=",       /* 0x11 */
 399   18,  "LD1+4*=",       /* 0x12 */
 400   19,  "LD1+4*=",       /* 0x13 */
 401   20,  "LD1+4*=",       /* 0x14 */
 402   21,  "LD1+4*=",       /* 0x15 */
 403   22,  "LD1+4*=",       /* 0x16 */
 404   23,  "LD1+4*=",       /* 0x17 */
 405   0,   "LD8<b+1+4*=",   /* 0x18 */
 406   1,   "LD8<b+1+4*=",   /* 0x19 */
 407   2,   "LD8<b+1+4*=",   /* 0x1a */
 408   3,   "LD8<b+1+4*=",   /* 0x1b */
 409   0,   "LD16<c+1+4*=",  /* 0x1c */
 410   1,   "LD16<c+1+4*=",  /* 0x1d */
 411   2,   "LD16<c+1+4*=",  /* 0x1e */
 412   0,   "Ld1+=",         /* 0x1f */
 413   /* R_ZEROES */
 414   0,    "Lb1+4*=",      /* 0x20 */
 415   1,    "Ld1+=",        /* 0x21 */
 416   /* R_UNINIT */
 417   0,    "Lb1+4*=",      /* 0x22 */
 418   1,    "Ld1+=",        /* 0x23 */
 419   /* R_RELOCATION */
 420   0,    "L4=",          /* 0x24 */
 421   /* R_DATA_ONE_SYMBOL */
 422   0,    "L4=Sb=",       /* 0x25 */
 423   1,    "L4=Sd=",       /* 0x26 */
 424   /* R_DATA_PLEBEL */
 425   0,    "L4=Sb=",       /* 0x27 */
 426   1,    "L4=Sd=",       /* 0x28 */
 427   /* R_SPACE_REF */
 428   0,    "L4=",          /* 0x29 */
 429   /* R_REPEATED_INIT */
 430   0,    "L4=Mb1+4*=",   /* 0x2a */
 431   1,    "Lb4*=Mb1+L*=", /* 0x2b */
 432   2,    "Lb4*=Md1+4*=", /* 0x2c */
 433   3,    "Ld1+=Me1+=",   /* 0x2d */
 434   /* R_SHORT_PCREL_MODE */
 435   0,    "",             /* 0x2e */
 436   /* R_LONG_PCREL_MODE */
 437   0,    "",             /* 0x2f */
 438   /* R_PCREL_CALL */
 439   0,    "L4=RD=Sb=",    /* 0x30 */
 440   1,    "L4=RD=Sb=",    /* 0x31 */
 441   2,    "L4=RD=Sb=",    /* 0x32 */
 442   3,    "L4=RD=Sb=",    /* 0x33 */
 443   4,    "L4=RD=Sb=",    /* 0x34 */
 444   5,    "L4=RD=Sb=",    /* 0x35 */
 445   6,    "L4=RD=Sb=",    /* 0x36 */
 446   7,    "L4=RD=Sb=",    /* 0x37 */
 447   8,    "L4=RD=Sb=",    /* 0x38 */
 448   9,    "L4=RD=Sb=",    /* 0x39 */
 449   0,    "L4=RD8<b+=Sb=",/* 0x3a */
 450   1,    "L4=RD8<b+=Sb=",/* 0x3b */
 451   0,    "L4=RD8<b+=Sd=",/* 0x3c */
 452   1,    "L4=RD8<b+=Sd=",/* 0x3d */
 453   /* R_RESERVED */
 454   0,    "",             /* 0x3e */
 455   0,    "",             /* 0x3f */
 456   /* R_ABS_CALL */
 457   0,    "L4=RD=Sb=",    /* 0x40 */
 458   1,    "L4=RD=Sb=",    /* 0x41 */
 459   2,    "L4=RD=Sb=",    /* 0x42 */
 460   3,    "L4=RD=Sb=",    /* 0x43 */
 461   4,    "L4=RD=Sb=",    /* 0x44 */
 462   5,    "L4=RD=Sb=",    /* 0x45 */
 463   6,    "L4=RD=Sb=",    /* 0x46 */
 464   7,    "L4=RD=Sb=",    /* 0x47 */
 465   8,    "L4=RD=Sb=",    /* 0x48 */
 466   9,    "L4=RD=Sb=",    /* 0x49 */
 467   0,    "L4=RD8<b+=Sb=",/* 0x4a */
 468   1,    "L4=RD8<b+=Sb=",/* 0x4b */
 469   0,    "L4=RD8<b+=Sd=",/* 0x4c */
 470   1,    "L4=RD8<b+=Sd=",/* 0x4d */
 471   /* R_RESERVED */
 472   0,     "",            /* 0x4e */
 473   0,     "",            /* 0x4f */
 474   /* R_DP_RELATIVE */
 475   0,    "L4=SD=",       /* 0x50 */
 476   1,    "L4=SD=",       /* 0x51 */
 477   2,    "L4=SD=",       /* 0x52 */
 478   3,    "L4=SD=",       /* 0x53 */
 479   4,    "L4=SD=",       /* 0x54 */
 480   5,    "L4=SD=",       /* 0x55 */
 481   6,    "L4=SD=",       /* 0x56 */
 482   7,    "L4=SD=",       /* 0x57 */
 483   8,    "L4=SD=",       /* 0x58 */
 484   9,    "L4=SD=",       /* 0x59 */
 485   10,   "L4=SD=",       /* 0x5a */
 486   11,   "L4=SD=",       /* 0x5b */
 487   12,   "L4=SD=",       /* 0x5c */
 488   13,   "L4=SD=",       /* 0x5d */
 489   14,   "L4=SD=",       /* 0x5e */
 490   15,   "L4=SD=",       /* 0x5f */
 491   16,   "L4=SD=",       /* 0x60 */
 492   17,   "L4=SD=",       /* 0x61 */
 493   18,   "L4=SD=",       /* 0x62 */
 494   19,   "L4=SD=",       /* 0x63 */
 495   20,   "L4=SD=",       /* 0x64 */
 496   21,   "L4=SD=",       /* 0x65 */
 497   22,   "L4=SD=",       /* 0x66 */
 498   23,   "L4=SD=",       /* 0x67 */
 499   24,   "L4=SD=",       /* 0x68 */
 500   25,   "L4=SD=",       /* 0x69 */
 501   26,   "L4=SD=",       /* 0x6a */
 502   27,   "L4=SD=",       /* 0x6b */
 503   28,   "L4=SD=",       /* 0x6c */
 504   29,   "L4=SD=",       /* 0x6d */
 505   30,   "L4=SD=",       /* 0x6e */
 506   31,   "L4=SD=",       /* 0x6f */
 507   32,   "L4=Sb=",       /* 0x70 */
 508   33,   "L4=Sd=",       /* 0x71 */
 509   /* R_RESERVED */
 510   0,    "",             /* 0x72 */
 511   0,    "",             /* 0x73 */
 512   0,    "",             /* 0x74 */
 513   0,    "",             /* 0x75 */
 514   0,    "",             /* 0x76 */
 515   0,    "",             /* 0x77 */
 516   /* R_DLT_REL */
 517   0,    "L4=Sb=",       /* 0x78 */
 518   1,    "L4=Sd=",       /* 0x79 */
 519   /* R_RESERVED */
 520   0,    "",             /* 0x7a */
 521   0,    "",             /* 0x7b */
 522   0,    "",             /* 0x7c */
 523   0,    "",             /* 0x7d */
 524   0,    "",             /* 0x7e */
 525   0,    "",             /* 0x7f */
 526   /* R_CODE_ONE_SYMBOL */
 527   0,    "L4=SD=",       /* 0x80 */
 528   1,    "L4=SD=",       /* 0x81 */
 529   2,    "L4=SD=",       /* 0x82 */
 530   3,    "L4=SD=",       /* 0x83 */
 531   4,    "L4=SD=",       /* 0x84 */
 532   5,    "L4=SD=",       /* 0x85 */
 533   6,    "L4=SD=",       /* 0x86 */
 534   7,    "L4=SD=",       /* 0x87 */
 535   8,    "L4=SD=",       /* 0x88 */
 536   9,    "L4=SD=",       /* 0x89 */
 537   10,   "L4=SD=",       /* 0x8q */
 538   11,   "L4=SD=",       /* 0x8b */
 539   12,   "L4=SD=",       /* 0x8c */
 540   13,   "L4=SD=",       /* 0x8d */
 541   14,   "L4=SD=",       /* 0x8e */
 542   15,   "L4=SD=",       /* 0x8f */
 543   16,   "L4=SD=",       /* 0x90 */
 544   17,   "L4=SD=",       /* 0x91 */
 545   18,   "L4=SD=",       /* 0x92 */
 546   19,   "L4=SD=",       /* 0x93 */
 547   20,   "L4=SD=",       /* 0x94 */
 548   21,   "L4=SD=",       /* 0x95 */
 549   22,   "L4=SD=",       /* 0x96 */
 550   23,   "L4=SD=",       /* 0x97 */
 551   24,   "L4=SD=",       /* 0x98 */
 552   25,   "L4=SD=",       /* 0x99 */
 553   26,   "L4=SD=",       /* 0x9a */
 554   27,   "L4=SD=",       /* 0x9b */
 555   28,   "L4=SD=",       /* 0x9c */
 556   29,   "L4=SD=",       /* 0x9d */
 557   30,   "L4=SD=",       /* 0x9e */
 558   31,   "L4=SD=",       /* 0x9f */
 559   32,   "L4=Sb=",       /* 0xa0 */
 560   33,   "L4=Sd=",       /* 0xa1 */
 561   /* R_RESERVED */
 562   0,    "",             /* 0xa2 */
 563   0,    "",             /* 0xa3 */
 564   0,    "",             /* 0xa4 */
 565   0,    "",             /* 0xa5 */
 566   0,    "",             /* 0xa6 */
 567   0,    "",             /* 0xa7 */
 568   0,    "",             /* 0xa8 */
 569   0,    "",             /* 0xa9 */
 570   0,    "",             /* 0xaa */
 571   0,    "",             /* 0xab */
 572   0,    "",             /* 0xac */
 573   0,    "",             /* 0xad */
 574   /* R_MILLI_REL */
 575   0,    "L4=Sb=",       /* 0xae */
 576   1,    "L4=Sd=",       /* 0xaf */
 577   /* R_CODE_PLABEL */
 578   0,    "L4=Sb=",       /* 0xb0 */
 579   1,    "L4=Sd=",       /* 0xb1 */
 580   /* R_BREAKPOINT */
 581   0,    "L4=",          /* 0xb2 */
 582   /* R_ENTRY */
 583   0,    "Te=Ue=",       /* 0xb3 */
 584   1,    "Uf=",          /* 0xb4 */
 585   /* R_ALT_ENTRY */
 586   0,    "",             /* 0xb5 */
 587   /* R_EXIT */
 588   0,    "",             /* 0xb6 */
 589   /* R_BEGIN_TRY */
 590   0,    "",             /* 0xb7 */
 591   /* R_END_TRY */
 592   0,    "R0=",          /* 0xb8 */
 593   1,    "Rb4*=",        /* 0xb9 */
 594   2,    "Rd4*=",        /* 0xba */
 595   /* R_BEGIN_BRTAB */
 596   0,    "",             /* 0xbb */
 597   /* R_END_BRTAB */
 598   0,    "",             /* 0xbc */
 599   /* R_STATEMENT */
 600   0,    "Nb=",          /* 0xbd */
 601   1,    "Nc=",          /* 0xbe */
 602   2,    "Nd=",          /* 0xbf */
 603   /* R_DATA_EXPR */
 604   0,    "L4=",          /* 0xc0 */
 605   /* R_CODE_EXPR */
 606   0,    "L4=",          /* 0xc1 */
 607   /* R_FSEL */
 608   0,    "",             /* 0xc2 */
 609   /* R_LSEL */
 610   0,    "",             /* 0xc3 */
 611   /* R_RSEL */
 612   0,    "",             /* 0xc4 */
 613   /* R_N_MODE */
 614   0,    "",             /* 0xc5 */
 615   /* R_S_MODE */
 616   0,    "",             /* 0xc6 */
 617   /* R_D_MODE */
 618   0,    "",             /* 0xc7 */
 619   /* R_R_MODE */
 620   0,    "",             /* 0xc8 */
 621   /* R_DATA_OVERRIDE */
 622   0,    "V0=",          /* 0xc9 */
 623   1,    "Vb=",          /* 0xca */
 624   2,    "Vc=",          /* 0xcb */
 625   3,    "Vd=",          /* 0xcc */
 626   4,    "Ve=",          /* 0xcd */
 627   /* R_TRANSLATED */
 628   0,    "",             /* 0xce */
 629   /* R_RESERVED */
 630   0,    "",             /* 0xcf */
 631   /* R_COMP1 */
 632   0,    "Ob=",          /* 0xd0 */
 633   /* R_COMP2 */
 634   0,    "Ob=Sd=",       /* 0xd1 */
 635   /* R_COMP3 */
 636   0,    "Ob=Ve=",       /* 0xd2 */
 637   /* R_PREV_FIXUP */
 638   0,    "P",            /* 0xd3 */
 639   1,    "P",            /* 0xd4 */
 640   2,    "P",            /* 0xd5 */
 641   3,    "P",            /* 0xd6 */
 642   /* R_SEC_STMT */
 643   0,    "",             /* 0xd7 */
 644   /* R_N0SEL */
 645   0,    "",             /* 0xd8 */
 646   /* R_N1SEL */
 647   0,    "",             /* 0xd9 */
 648   /* R_LINETAB */
 649   0,    "",             /* 0xda */
 650   /* R_LINETAB_ESC */
 651   0,    "",             /* 0xdb */
 652   /* R_LTP_OVERRIDE */
 653   0,    "",             /* 0xdc */
 654   /* R_COMMENT */
 655   0,    "",             /* 0xdd */
 656   /* R_RESERVED */
 657   0,    "",             /* 0xde */
 658   0,    "",             /* 0xdf */
 659   0,    "",             /* 0xe0 */
 660   0,    "",             /* 0xe1 */
 661   0,    "",             /* 0xe2 */
 662   0,    "",             /* 0xe3 */
 663   0,    "",             /* 0xe4 */
 664   0,    "",             /* 0xe5 */
 665   0,    "",             /* 0xe6 */
 666   0,    "",             /* 0xe7 */
 667   0,    "",             /* 0xe8 */
 668   0,    "",             /* 0xe9 */
 669   0,    "",             /* 0xea */
 670   0,    "",             /* 0xeb */
 671   0,    "",             /* 0xec */
 672   0,    "",             /* 0xed */
 673   0,    "",             /* 0xee */
 674   0,    "",             /* 0xef */
 675   0,    "",             /* 0xf0 */
 676   0,    "",             /* 0xf1 */
 677   0,    "",             /* 0xf2 */
 678   0,    "",             /* 0xf3 */
 679   0,    "",             /* 0xf4 */
 680   0,    "",             /* 0xf5 */
 681   0,    "",             /* 0xf6 */
 682   0,    "",             /* 0xf7 */
 683   0,    "",             /* 0xf8 */
 684   0,    "",             /* 0xf9 */
 685   0,    "",             /* 0xfa */
 686   0,    "",             /* 0xfb */
 687   0,    "",             /* 0xfc */
 688   0,    "",             /* 0xfd */
 689   0,    "",             /* 0xfe */
 690   0,    "",             /* 0xff */
 691 };
 692
 693 static const int comp1_opcodes[] =
 694 {
 695   0x00,
 696   0x40,
 697   0x41,
 698   0x42,
 699   0x43,
 700   0x44,
 701   0x45,
 702   0x46,
 703   0x47,
 704   0x48,
 705   0x49,
 706   0x4a,
 707   0x4b,
 708   0x60,
 709   0x80,
 710   0xa0,
 711   0xc0,
 712   -1
 713 };
 714
 715 static const int comp2_opcodes[] =
 716 {
 717   0x00,
 718   0x80,
 719   0x82,
 720   0xc0,
 721   -1
 722 };
 723
 724 static const int comp3_opcodes[] =
 725 {
 726   0x00,
 727   0x02,
 728   -1
 729 };
 730
 731 /* These apparently are not in older versions of hpux reloc.h (hpux7).  */
 732 #ifndef R_DLT_REL
 733 #define R_DLT_REL 0x78
 734 #endif
 735
 736 #ifndef R_AUX_UNWIND
 737 #define R_AUX_UNWIND 0xcf
 738 #endif
 739
 740 #ifndef R_SEC_STMT
 741 #define R_SEC_STMT 0xd7
 742 #endif
 743
 744 /* And these first appeared in hpux10.  */
 745 #ifndef R_SHORT_PCREL_MODE
 746 #define R_SHORT_PCREL_MODE 0x3e
 747 #endif
 748
 749 #ifndef R_LONG_PCREL_MODE
 750 #define R_LONG_PCREL_MODE 0x3f
 751 #endif
 752
 753 #ifndef R_N0SEL
 754 #define R_N0SEL 0xd8
 755 #endif
 756
 757 #ifndef R_N1SEL
 758 #define R_N1SEL 0xd9
 759 #endif
 760
 761 #ifndef R_LINETAB
 762 #define R_LINETAB 0xda
 763 #endif
 764
 765 #ifndef R_LINETAB_ESC
 766 #define R_LINETAB_ESC 0xdb
 767 #endif
 768
 769 #ifndef R_LTP_OVERRIDE
 770 #define R_LTP_OVERRIDE 0xdc
 771 #endif
 772
 773 #ifndef R_COMMENT
 774 #define R_COMMENT 0xdd
 775 #endif
 776
 777 static reloc_howto_type som_hppa_howto_table[] =
 778 {
 779   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 780   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 781   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 782   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 783   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 784   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 785   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 786   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 787   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 788   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 789   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 790   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 791   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 792   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 793   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 794   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 795   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 796   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 797   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 798   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 799   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 800   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 801   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 802   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 803   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 804   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 805   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 806   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 807   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 808   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 809   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 810   {R_NO_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_NO_RELOCATION"},
 811   {R_ZEROES, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ZEROES"},
 812   {R_ZEROES, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ZEROES"},
 813   {R_UNINIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_UNINIT"},
 814   {R_UNINIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_UNINIT"},
 815   {R_RELOCATION, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RELOCATION"},
 816   {R_DATA_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_ONE_SYMBOL"},
 817   {R_DATA_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_ONE_SYMBOL"},
 818   {R_DATA_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_PLABEL"},
 819   {R_DATA_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_PLABEL"},
 820   {R_SPACE_REF, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SPACE_REF"},
 821   {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
 822   {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
 823   {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
 824   {R_REPEATED_INIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "REPEATED_INIT"},
 825   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 826   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 827   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 828   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 829   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 830   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 831   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 832   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 833   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 834   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 835   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 836   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 837   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 838   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 839   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 840   {R_PCREL_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PCREL_CALL"},
 841   {R_SHORT_PCREL_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SHORT_PCREL_MODE"},
 842   {R_LONG_PCREL_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LONG_PCREL_MODE"},
 843   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 844   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 845   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 846   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 847   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 848   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 849   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 850   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 851   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 852   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 853   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 854   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 855   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 856   {R_ABS_CALL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ABS_CALL"},
 857   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 858   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 859   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 860   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 861   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 862   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 863   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 864   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 865   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 866   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 867   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 868   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 869   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 870   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 871   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 872   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 873   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 874   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 875   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 876   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 877   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 878   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 879   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 880   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 881   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 882   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 883   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 884   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 885   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 886   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 887   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 888   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 889   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 890   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 891   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 892   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 893   {R_DP_RELATIVE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DP_RELATIVE"},
 894   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 895   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 896   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 897   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 898   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 899   {R_DLT_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DLT_REL"},
 900   {R_DLT_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DLT_REL"},
 901   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 902   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 903   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 904   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 905   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 906   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 907   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 908   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 909   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 910   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 911   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 912   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 913   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 914   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 915   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 916   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 917   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 918   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 919   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 920   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 921   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 922   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 923   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 924   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 925   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 926   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 927   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 928   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 929   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 930   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 931   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 932   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 933   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 934   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 935   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 936   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 937   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 938   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 939   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 940   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 941   {R_CODE_ONE_SYMBOL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_ONE_SYMBOL"},
 942   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 943   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 944   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 945   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 946   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 947   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 948   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 949   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 950   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 951   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 952   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
 953   {R_MILLI_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_MILLI_REL"},
 954   {R_MILLI_REL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_MILLI_REL"},
 955   {R_CODE_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_PLABEL"},
 956   {R_CODE_PLABEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_PLABEL"},
 957   {R_BREAKPOINT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BREAKPOINT"},
 958   {R_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ENTRY"},
 959   {R_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ENTRY"},
 960   {R_ALT_ENTRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_ALT_ENTRY"},
 961   {R_EXIT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_EXIT"},
 962   {R_BEGIN_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BEGIN_TRY"},
 963   {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
 964   {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
 965   {R_END_TRY, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_TRY"},
 966   {R_BEGIN_BRTAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_BEGIN_BRTAB"},
 967   {R_END_BRTAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_END_BRTAB"},
 968   {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
 969   {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
 970   {R_STATEMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_STATEMENT"},
 971   {R_DATA_EXPR, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_EXPR"},
 972   {R_CODE_EXPR, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_CODE_EXPR"},
 973   {R_FSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_FSEL"},
 974   {R_LSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LSEL"},
 975   {R_RSEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RSEL"},
 976   {R_N_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N_MODE"},
 977   {R_S_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_S_MODE"},
 978   {R_D_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_D_MODE"},
 979   {R_R_MODE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_R_MODE"},
 980   {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
 981   {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
 982   {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
 983   {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
 984   {R_DATA_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_DATA_OVERRIDE"},
 985   {R_TRANSLATED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_TRANSLATED"},
 986   {R_AUX_UNWIND, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_AUX_UNWIND"},
 987   {R_COMP1, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP1"},
 988   {R_COMP2, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP2"},
 989   {R_COMP3, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMP3"},
 990   {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
 991   {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
 992   {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
 993   {R_PREV_FIXUP, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_PREV_FIXUP"},
 994   {R_SEC_STMT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_SEC_STMT"},
 995   {R_N0SEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N0SEL"},
 996   {R_N1SEL, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_N1SEL"},
 997   {R_LINETAB, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LINETAB"},
 998   {R_LINETAB_ESC, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LINETAB_ESC"},
 999   {R_LTP_OVERRIDE, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_LTP_OVERRIDE"},
1000   {R_COMMENT, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_COMMENT"},
1001   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1002   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1003   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1004   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1005   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1006   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1007   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1008   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1009   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1010   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1011   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1012   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1013   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1014   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1015   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1016   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1017   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1018   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1019   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1020   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1021   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1022   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1023   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1024   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1025   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1026   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1027   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1028   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1029   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1030   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1031   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1032   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1033   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
1034   {R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"}};
1035
1036 /* Initialize the SOM relocation queue.  By definition the queue holds
1037    the last four multibyte fixups.  */
1038
1039 static void
1040 som_initialize_reloc_queue (queue)
1041      struct reloc_queue *queue;
1042 {
1043   queue[0].reloc = NULL;
1044   queue[0].size = 0;
1045   queue[1].reloc = NULL;
1046   queue[1].size = 0;
1047   queue[2].reloc = NULL;
1048   queue[2].size = 0;
1049   queue[3].reloc = NULL;
1050   queue[3].size = 0;
1051 }
1052
1053 /* Insert a new relocation into the relocation queue.  */
1054
1055 static void
1056 som_reloc_queue_insert (p, size, queue)
1057      unsigned char *p;
1058      unsigned int size;
1059      struct reloc_queue *queue;
1060 {
1061   queue[3].reloc = queue[2].reloc;
1062   queue[3].size = queue[2].size;
1063   queue[2].reloc = queue[1].reloc;
1064   queue[2].size = queue[1].size;
1065   queue[1].reloc = queue[0].reloc;
1066   queue[1].size = queue[0].size;
1067   queue[0].reloc = p;
1068   queue[0].size = size;
1069 }
1070
1071 /* When an entry in the relocation queue is reused, the entry moves
1072    to the front of the queue.  */
1073
1074 static void
1075 som_reloc_queue_fix (queue, index)
1076      struct reloc_queue *queue;
1077      unsigned int index;
1078 {
1079   if (index == 0)
1080     return;
1081
1082   if (index == 1)
1083     {
1084       unsigned char *tmp1 = queue[0].reloc;
1085       unsigned int tmp2 = queue[0].size;
1086       queue[0].reloc = queue[1].reloc;
1087       queue[0].size = queue[1].size;
1088       queue[1].reloc = tmp1;
1089       queue[1].size = tmp2;
1090       return;
1091     }
1092
1093   if (index == 2)
1094     {
1095       unsigned char *tmp1 = queue[0].reloc;
1096       unsigned int tmp2 = queue[0].size;
1097       queue[0].reloc = queue[2].reloc;
1098       queue[0].size = queue[2].size;
1099       queue[2].reloc = queue[1].reloc;
1100       queue[2].size = queue[1].size;
1101       queue[1].reloc = tmp1;
1102       queue[1].size = tmp2;
1103       return;
1104     }
1105
1106   if (index == 3)
1107     {
1108       unsigned char *tmp1 = queue[0].reloc;
1109       unsigned int tmp2 = queue[0].size;
1110       queue[0].reloc = queue[3].reloc;
1111       queue[0].size = queue[3].size;
1112       queue[3].reloc = queue[2].reloc;
1113       queue[3].size = queue[2].size;
1114       queue[2].reloc = queue[1].reloc;
1115       queue[2].size = queue[1].size;
1116       queue[1].reloc = tmp1;
1117       queue[1].size = tmp2;
1118       return;
1119     }
1120   abort();
1121 }
1122
1123 /* Search for a particular relocation in the relocation queue.  */
1124
1125 static int
1126 som_reloc_queue_find (p, size, queue)
1127      unsigned char *p;
1128      unsigned int size;
1129      struct reloc_queue *queue;
1130 {
1131   if (queue[0].reloc && !memcmp (p, queue[0].reloc, size)
1132       && size == queue[0].size)
1133     return 0;
1134   if (queue[1].reloc && !memcmp (p, queue[1].reloc, size)
1135       && size == queue[1].size)
1136     return 1;
1137   if (queue[2].reloc && !memcmp (p, queue[2].reloc, size)
1138       && size == queue[2].size)
1139     return 2;
1140   if (queue[3].reloc && !memcmp (p, queue[3].reloc, size)
1141       && size == queue[3].size)
1142     return 3;
1143   return -1;
1144 }
1145
1146 static unsigned char *
1147 try_prev_fixup (abfd, subspace_reloc_sizep, p, size, queue)
1148      bfd *abfd;
1149      int *subspace_reloc_sizep;
1150      unsigned char *p;
1151      unsigned int size;
1152      struct reloc_queue *queue;
1153 {
1154   int queue_index = som_reloc_queue_find (p, size, queue);
1155
1156   if (queue_index != -1)
1157     {
1158       /* Found this in a previous fixup.  Undo the fixup we
1159          just built and use R_PREV_FIXUP instead.  We saved
1160          a total of size - 1 bytes in the fixup stream.  */
1161       bfd_put_8 (abfd, R_PREV_FIXUP + queue_index, p);
1162       p += 1;
1163       *subspace_reloc_sizep += 1;
1164       som_reloc_queue_fix (queue, queue_index);
1165     }
1166   else
1167     {
1168       som_reloc_queue_insert (p, size, queue);
1169       *subspace_reloc_sizep += size;
1170       p += size;
1171     }
1172   return p;
1173 }
1174
1175 /* Emit the proper R_NO_RELOCATION fixups to map the next SKIP
1176    bytes without any relocation.  Update the size of the subspace
1177    relocation stream via SUBSPACE_RELOC_SIZE_P; also return the
1178    current pointer into the relocation stream.  */
1179
1180 static unsigned char *
1181 som_reloc_skip (abfd, skip, p, subspace_reloc_sizep, queue)
1182      bfd *abfd;
1183      unsigned int skip;
1184      unsigned char *p;
1185      unsigned int *subspace_reloc_sizep;
1186      struct reloc_queue *queue;
1187 {
1188   /* Use a 4 byte R_NO_RELOCATION entry with a maximal value
1189      then R_PREV_FIXUPs to get the difference down to a
1190      reasonable size.  */
1191   if (skip >= 0x1000000)
1192     {
1193       skip -= 0x1000000;
1194       bfd_put_8 (abfd, R_NO_RELOCATION + 31, p);
1195       bfd_put_8 (abfd, 0xff, p + 1);
1196       bfd_put_16 (abfd, 0xffff, p + 2);
1197       p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1198       while (skip >= 0x1000000)
1199         {
1200           skip -= 0x1000000;
1201           bfd_put_8 (abfd, R_PREV_FIXUP, p);
1202           p++;
1203           *subspace_reloc_sizep += 1;
1204           /* No need to adjust queue here since we are repeating the
1205              most recent fixup.  */
1206         }
1207     }
1208
1209   /* The difference must be less than 0x1000000.  Use one
1210      more R_NO_RELOCATION entry to get to the right difference.  */
1211   if ((skip & 3) == 0 && skip <= 0xc0000 && skip > 0)
1212     {
1213       /* Difference can be handled in a simple single-byte
1214          R_NO_RELOCATION entry.  */
1215       if (skip <= 0x60)
1216         {
1217           bfd_put_8 (abfd, R_NO_RELOCATION + (skip >> 2) - 1, p);
1218           *subspace_reloc_sizep += 1;
1219           p++;
1220         }
1221       /* Handle it with a two byte R_NO_RELOCATION entry.  */
1222       else if (skip <= 0x1000)
1223         {
1224           bfd_put_8 (abfd, R_NO_RELOCATION + 24 + (((skip >> 2) - 1) >> 8), p);
1225           bfd_put_8 (abfd, (skip >> 2) - 1, p + 1);
1226           p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1227         }
1228       /* Handle it with a three byte R_NO_RELOCATION entry.  */
1229       else
1230         {
1231           bfd_put_8 (abfd, R_NO_RELOCATION + 28 + (((skip >> 2) - 1) >> 16), p);
1232           bfd_put_16 (abfd, (skip >> 2) - 1, p + 1);
1233           p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1234         }
1235     }
1236   /* Ugh.  Punt and use a 4 byte entry.  */
1237   else if (skip > 0)
1238     {
1239       bfd_put_8 (abfd, R_NO_RELOCATION + 31, p);
1240       bfd_put_8 (abfd, (skip - 1) >> 16, p + 1);
1241       bfd_put_16 (abfd, skip - 1, p + 2);
1242       p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1243     }
1244   return p;
1245 }
1246
1247 /* Emit the proper R_DATA_OVERRIDE fixups to handle a nonzero addend
1248    from a BFD relocation.  Update the size of the subspace relocation
1249    stream via SUBSPACE_RELOC_SIZE_P; also return the current pointer
1250    into the relocation stream.  */
1251
1252 static unsigned char *
1253 som_reloc_addend (abfd, addend, p, subspace_reloc_sizep, queue)
1254      bfd *abfd;
1255      int addend;
1256      unsigned char *p;
1257      unsigned int *subspace_reloc_sizep;
1258      struct reloc_queue *queue;
1259 {
1260   if ((unsigned)(addend) + 0x80 < 0x100)
1261     {
1262       bfd_put_8 (abfd, R_DATA_OVERRIDE + 1, p);
1263       bfd_put_8 (abfd, addend, p + 1);
1264       p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1265     }
1266   else if ((unsigned) (addend) + 0x8000 < 0x10000)
1267     {
1268       bfd_put_8 (abfd, R_DATA_OVERRIDE + 2, p);
1269       bfd_put_16 (abfd, addend, p + 1);
1270       p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1271     }
1272   else if ((unsigned) (addend) + 0x800000 < 0x1000000)
1273     {
1274       bfd_put_8 (abfd, R_DATA_OVERRIDE + 3, p);
1275       bfd_put_8 (abfd, addend >> 16, p + 1);
1276       bfd_put_16 (abfd, addend, p + 2);
1277       p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 4, queue);
1278     }
1279   else
1280     {
1281       bfd_put_8 (abfd, R_DATA_OVERRIDE + 4, p);
1282       bfd_put_32 (abfd, addend, p + 1);
1283       p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue);
1284     }
1285   return p;
1286 }
1287
1288 /* Handle a single function call relocation.  */
1289
1290 static unsigned char *
1291 som_reloc_call (abfd, p, subspace_reloc_sizep, bfd_reloc, sym_num, queue)
1292      bfd *abfd;
1293      unsigned char *p;
1294      unsigned int *subspace_reloc_sizep;
1295      arelent *bfd_reloc;
1296      int sym_num;
1297      struct reloc_queue *queue;
1298 {
1299   int arg_bits = HPPA_R_ARG_RELOC (bfd_reloc->addend);
1300   int rtn_bits = arg_bits & 0x3;
1301   int type, done = 0;
1302
1303   /* You'll never believe all this is necessary to handle relocations
1304      for function calls.  Having to compute and pack the argument
1305      relocation bits is the real nightmare.
1306
1307      If you're interested in how this works, just forget it.  You really
1308      do not want to know about this braindamage.  */
1309
1310   /* First see if this can be done with a "simple" relocation.  Simple
1311      relocations have a symbol number < 0x100 and have simple encodings
1312      of argument relocations.  */
1313
1314   if (sym_num < 0x100)
1315     {
1316       switch (arg_bits)
1317         {
1318         case 0:
1319         case 1:
1320           type = 0;
1321           break;
1322         case 1 << 8:
1323         case 1 << 8 | 1:
1324           type = 1;
1325           break;
1326         case 1 << 8 | 1 << 6:
1327         case 1 << 8 | 1 << 6 | 1:
1328           type = 2;
1329           break;
1330         case 1 << 8 | 1 << 6 | 1 << 4:
1331         case 1 << 8 | 1 << 6 | 1 << 4 | 1:
1332           type = 3;
1333           break;
1334         case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2:
1335         case 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2 | 1:
1336           type = 4;
1337           break;
1338         default:
1339           /* Not one of the easy encodings.  This will have to be
1340              handled by the more complex code below.  */
1341           type = -1;
1342           break;
1343         }
1344       if (type != -1)
1345         {
1346           /* Account for the return value too.  */
1347           if (rtn_bits)
1348             type += 5;
1349
1350           /* Emit a 2 byte relocation.  Then see if it can be handled
1351              with a relocation which is already in the relocation queue.  */
1352           bfd_put_8 (abfd, bfd_reloc->howto->type + type, p);
1353           bfd_put_8 (abfd, sym_num, p + 1);
1354           p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 2, queue);
1355           done = 1;
1356         }
1357     }
1358
1359   /* If this could not be handled with a simple relocation, then do a hard
1360      one.  Hard relocations occur if the symbol number was too high or if
1361      the encoding of argument relocation bits is too complex.  */
1362   if (! done)
1363     {
1364       /* Don't ask about these magic sequences.  I took them straight
1365          from gas-1.36 which took them from the a.out man page.  */
1366       type = rtn_bits;
1367       if ((arg_bits >> 6 & 0xf) == 0xe)
1368         type += 9 * 40;
1369       else
1370         type += (3 * (arg_bits >> 8 & 3) + (arg_bits >> 6 & 3)) * 40;
1371       if ((arg_bits >> 2 & 0xf) == 0xe)
1372         type += 9 * 4;
1373       else
1374         type += (3 * (arg_bits >> 4 & 3) + (arg_bits >> 2 & 3)) * 4;
1375
1376       /* Output the first two bytes of the relocation.  These describe
1377          the length of the relocation and encoding style.  */
1378       bfd_put_8 (abfd, bfd_reloc->howto->type + 10
1379                  + 2 * (sym_num >= 0x100) + (type >= 0x100),
1380                  p);
1381       bfd_put_8 (abfd, type, p + 1);
1382
1383       /* Now output the symbol index and see if this bizarre relocation
1384          just happened to be in the relocation queue.  */
1385       if (sym_num < 0x100)
1386         {
1387           bfd_put_8 (abfd, sym_num, p + 2);
1388           p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 3, queue);
1389         }
1390       else
1391         {
1392           bfd_put_8 (abfd, sym_num >> 16, p + 2);
1393           bfd_put_16 (abfd, sym_num, p + 3);
1394           p = try_prev_fixup (abfd, subspace_reloc_sizep, p, 5, queue);
1395         }
1396     }
1397   return p;
1398 }
1399
1400
1401 /* Return the logarithm of X, base 2, considering X unsigned.
1402    Abort -1 if X is not a power or two or is zero.  */
1403
1404 static int
1405 log2 (x)
1406      unsigned int x;
1407 {
1408   int log = 0;
1409
1410   /* Test for 0 or a power of 2.  */
1411   if (x == 0 || x != (x & -x))
1412     return -1;
1413
1414   while ((x >>= 1) != 0)
1415     log++;
1416   return log;
1417 }
1418
1419 static bfd_reloc_status_type
1420 hppa_som_reloc (abfd, reloc_entry, symbol_in, data,
1421                 input_section, output_bfd, error_message)
1422      bfd *abfd;
1423      arelent *reloc_entry;
1424      asymbol *symbol_in;
1425      PTR data;
1426      asection *input_section;
1427      bfd *output_bfd;
1428      char **error_message;
1429 {
1430   if (output_bfd)
1431     {
1432       reloc_entry->address += input_section->output_offset;
1433       return bfd_reloc_ok;
1434     }
1435   return bfd_reloc_ok;
1436 }
1437
1438 /* Given a generic HPPA relocation type, the instruction format,
1439    and a field selector, return one or more appropriate SOM relocations.  */
1440
1441 int **
1442 hppa_som_gen_reloc_type (abfd, base_type, format, field, sym_diff, sym)
1443      bfd *abfd;
1444      int base_type;
1445      int format;
1446      enum hppa_reloc_field_selector_type_alt field;
1447      int sym_diff;
1448      asymbol *sym;
1449 {
1450   int *final_type, **final_types;
1451
1452   final_types = (int **) bfd_alloc (abfd, sizeof (int *) * 6);
1453   final_type = (int *) bfd_alloc (abfd, sizeof (int));
1454   if (!final_types || !final_type)
1455     return NULL;
1456
1457   /* The field selector may require additional relocations to be
1458      generated.  It's impossible to know at this moment if additional
1459      relocations will be needed, so we make them.  The code to actually
1460      write the relocation/fixup stream is responsible for removing
1461      any redundant relocations.  */
1462   switch (field)
1463     {
1464       case e_fsel:
1465       case e_psel:
1466       case e_lpsel:
1467       case e_rpsel:
1468         final_types[0] = final_type;
1469         final_types[1] = NULL;
1470         final_types[2] = NULL;
1471         *final_type = base_type;
1472         break;
1473
1474       case e_tsel:
1475       case e_ltsel:
1476       case e_rtsel:
1477         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1478         if (!final_types[0])
1479           return NULL;
1480         if (field == e_tsel)
1481           *final_types[0] = R_FSEL;
1482         else if (field == e_ltsel)
1483           *final_types[0] = R_LSEL;
1484         else
1485           *final_types[0] = R_RSEL;
1486         final_types[1] = final_type;
1487         final_types[2] = NULL;
1488         *final_type = base_type;
1489         break;
1490
1491       case e_lssel:
1492       case e_rssel:
1493         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1494         if (!final_types[0])
1495           return NULL;
1496         *final_types[0] = R_S_MODE;
1497         final_types[1] = final_type;
1498         final_types[2] = NULL;
1499         *final_type = base_type;
1500         break;
1501
1502       case e_lsel:
1503       case e_rsel:
1504         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1505         if (!final_types[0])
1506           return NULL;
1507         *final_types[0] = R_N_MODE;
1508         final_types[1] = final_type;
1509         final_types[2] = NULL;
1510         *final_type = base_type;
1511         break;
1512
1513       case e_ldsel:
1514       case e_rdsel:
1515         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1516         if (!final_types[0])
1517           return NULL;
1518         *final_types[0] = R_D_MODE;
1519         final_types[1] = final_type;
1520         final_types[2] = NULL;
1521         *final_type = base_type;
1522         break;
1523
1524       case e_lrsel:
1525       case e_rrsel:
1526         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1527         if (!final_types[0])
1528           return NULL;
1529         *final_types[0] = R_R_MODE;
1530         final_types[1] = final_type;
1531         final_types[2] = NULL;
1532         *final_type = base_type;
1533         break;
1534
1535       case e_nsel:
1536         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1537         if (!final_types[0])
1538           return NULL;
1539         *final_types[0] = R_N1SEL;
1540         final_types[1] = final_type;
1541         final_types[2] = NULL;
1542         *final_type = base_type;
1543         break;
1544
1545       case e_nlsel:
1546       case e_nlrsel:
1547         final_types[0] = (int *) bfd_alloc (abfd, sizeof (int));
1548         if (!final_types[0])
1549           return NULL;
1550         *final_types[0] = R_N0SEL;
1551         final_types[1] = (int *) bfd_alloc (abfd, sizeof (int));
1552         if (!final_types[1])
1553           return NULL;
1554         if (field == e_nlsel)
1555           *final_types[1] = R_N_MODE;
1556         else
1557           *final_types[1] = R_R_MODE;
1558         final_types[2] = final_type;
1559         final_types[3] = NULL;
1560         *final_type = base_type;
1561         break;
1562     }
1563
1564   switch (base_type)
1565     {
1566     case R_HPPA:
1567       /* The difference of two symbols needs *very* special handling.  */
1568       if (sym_diff)
1569         {
1570           final_types[0] = (int *)bfd_alloc (abfd, sizeof (int));
1571           final_types[1] = (int *)bfd_alloc (abfd, sizeof (int));
1572           final_types[2] = (int *)bfd_alloc (abfd, sizeof (int));
1573           final_types[3] = (int *)bfd_alloc (abfd, sizeof (int));
1574           if (!final_types[0] || !final_types[1] || !final_types[2])
1575             return NULL;
1576           if (field == e_fsel)
1577             *final_types[0] = R_FSEL;
1578           else if (field == e_rsel)
1579             *final_types[0] = R_RSEL;
1580           else if (field == e_lsel)
1581             *final_types[0] = R_LSEL;
1582           *final_types[1] = R_COMP2;
1583           *final_types[2] = R_COMP2;
1584           *final_types[3] = R_COMP1;
1585           final_types[4] = final_type;
1586           if (format == 32)
1587             *final_types[4] = R_DATA_EXPR;
1588           else
1589             *final_types[4] = R_CODE_EXPR;
1590           final_types[5] = NULL;
1591           break;
1592         }
1593       /* PLABELs get their own relocation type.  */
1594       else if (field == e_psel
1595           || field == e_lpsel
1596           || field == e_rpsel)
1597         {
1598           /* A PLABEL relocation that has a size of 32 bits must
1599              be a R_DATA_PLABEL.  All others are R_CODE_PLABELs.  */
1600           if (format == 32)
1601             *final_type = R_DATA_PLABEL;
1602           else
1603             *final_type = R_CODE_PLABEL;
1604         }
1605       /* PIC stuff.  */
1606       else if (field == e_tsel
1607           || field == e_ltsel
1608           || field == e_rtsel)
1609         *final_type = R_DLT_REL;
1610       /* A relocation in the data space is always a full 32bits.  */
1611       else if (format == 32)
1612         {
1613           *final_type = R_DATA_ONE_SYMBOL;
1614
1615           /* If there's no SOM symbol type associated with this BFD
1616              symbol, then set the symbol type to ST_DATA.
1617
1618              Only do this if the type is going to default later when
1619              we write the object file.
1620
1621              This is done so that the linker never encounters an
1622              R_DATA_ONE_SYMBOL reloc involving an ST_CODE symbol.
1623
1624              This allows the compiler to generate exception handling
1625              tables.
1626
1627              Note that one day we may need to also emit BEGIN_BRTAB and
1628              END_BRTAB to prevent the linker from optimizing away insns
1629              in exception handling regions.  */
1630           if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN
1631               && (sym->flags & BSF_SECTION_SYM) == 0
1632               && (sym->flags & BSF_FUNCTION) == 0
1633               && ! bfd_is_com_section (sym->section))
1634             som_symbol_data (sym)->som_type = SYMBOL_TYPE_DATA;
1635         }
1636       break;
1637
1638
1639     case R_HPPA_GOTOFF:
1640       /* More PLABEL special cases.  */
1641       if (field == e_psel
1642           || field == e_lpsel
1643           || field == e_rpsel)
1644         *final_type = R_DATA_PLABEL;
1645       break;
1646
1647     case R_HPPA_COMPLEX:
1648       /* The difference of two symbols needs *very* special handling.  */
1649       if (sym_diff)
1650         {
1651           final_types[0] = (int *)bfd_alloc (abfd, sizeof (int));
1652           final_types[1] = (int *)bfd_alloc (abfd, sizeof (int));
1653           final_types[2] = (int *)bfd_alloc (abfd, sizeof (int));
1654           final_types[3] = (int *)bfd_alloc (abfd, sizeof (int));
1655           if (!final_types[0] || !final_types[1] || !final_types[2])
1656             return NULL;
1657           if (field == e_fsel)
1658             *final_types[0] = R_FSEL;
1659           else if (field == e_rsel)
1660             *final_types[0] = R_RSEL;
1661           else if (field == e_lsel)
1662             *final_types[0] = R_LSEL;
1663           *final_types[1] = R_COMP2;
1664           *final_types[2] = R_COMP2;
1665           *final_types[3] = R_COMP1;
1666           final_types[4] = final_type;
1667           if (format == 32)
1668             *final_types[4] = R_DATA_EXPR;
1669           else
1670             *final_types[4] = R_CODE_EXPR;
1671           final_types[5] = NULL;
1672           break;
1673         }
1674       else
1675         break;
1676
1677     case R_HPPA_NONE:
1678     case R_HPPA_ABS_CALL:
1679     case R_HPPA_PCREL_CALL:
1680       /* Right now we can default all these.  */
1681       break;
1682     }
1683   return final_types;
1684 }
1685
1686 /* Return the address of the correct entry in the PA SOM relocation
1687    howto table.  */
1688
1689 /*ARGSUSED*/
1690 static reloc_howto_type *
1691 som_bfd_reloc_type_lookup (abfd, code)
1692      bfd *abfd;
1693      bfd_reloc_code_real_type code;
1694 {
1695   if ((int) code < (int) R_NO_RELOCATION + 255)
1696     {
1697       BFD_ASSERT ((int) som_hppa_howto_table[(int) code].type == (int) code);
1698       return &som_hppa_howto_table[(int) code];
1699     }
1700
1701   return (reloc_howto_type *) 0;
1702 }
1703
1704 /* Perform some initialization for an object.  Save results of this
1705    initialization in the BFD.  */
1706
1707 static const bfd_target *
1708 som_object_setup (abfd, file_hdrp, aux_hdrp)
1709      bfd *abfd;
1710      struct header *file_hdrp;
1711      struct som_exec_auxhdr *aux_hdrp;
1712 {
1713   asection *section;
1714   int found;
1715
1716   /* som_mkobject will set bfd_error if som_mkobject fails.  */
1717   if (som_mkobject (abfd) != true)
1718     return 0;
1719
1720   /* Set BFD flags based on what information is available in the SOM.  */
1721   abfd->flags = BFD_NO_FLAGS;
1722   if (file_hdrp->symbol_total)
1723     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
1724
1725   switch (file_hdrp->a_magic)
1726     {
1727     case DEMAND_MAGIC:
1728       abfd->flags |= (D_PAGED | WP_TEXT | EXEC_P);
1729       break;
1730     case SHARE_MAGIC:
1731       abfd->flags |= (WP_TEXT | EXEC_P);
1732       break;
1733     case EXEC_MAGIC:
1734       abfd->flags |= (EXEC_P);
1735       break;
1736     case RELOC_MAGIC:
1737       abfd->flags |= HAS_RELOC;
1738       break;
1739 #ifdef SHL_MAGIC
1740     case SHL_MAGIC:
1741 #endif
1742 #ifdef DL_MAGIC
1743     case DL_MAGIC:
1744 #endif
1745       abfd->flags |= DYNAMIC;
1746       break;
1747
1748     default:
1749       break;
1750     }
1751
1752   /* Allocate space to hold the saved exec header information.  */
1753   obj_som_exec_data (abfd) = (struct som_exec_data *)
1754     bfd_zalloc (abfd, sizeof (struct som_exec_data ));
1755   if (obj_som_exec_data (abfd) == NULL)
1756     return NULL;
1757
1758   /* The braindamaged OSF1 linker switched exec_flags and exec_entry!
1759
1760      We used to identify OSF1 binaries based on NEW_VERSION_ID, but
1761      apparently the latest HPUX linker is using NEW_VERSION_ID now.
1762
1763      It's about time, OSF has used the new id since at least 1992;
1764      HPUX didn't start till nearly 1995!.
1765
1766      The new approach examines the entry field.  If it's zero or not 4
1767      byte aligned then it's not a proper code address and we guess it's
1768      really the executable flags.  */
1769   found = 0;
1770   for (section = abfd->sections; section; section = section->next)
1771     {
1772       if ((section->flags & SEC_CODE) == 0)
1773         continue;
1774       if (aux_hdrp->exec_entry >= section->vma
1775           && aux_hdrp->exec_entry < section->vma + section->_cooked_size)
1776         found = 1;
1777     }
1778   if (aux_hdrp->exec_entry == 0
1779       || (aux_hdrp->exec_entry & 0x3) != 0
1780       || ! found)
1781     {
1782       bfd_get_start_address (abfd) = aux_hdrp->exec_flags;
1783       obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_entry;
1784     }
1785   else
1786     {
1787       bfd_get_start_address (abfd) = aux_hdrp->exec_entry;
1788       obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_flags;
1789     }
1790
1791   bfd_default_set_arch_mach (abfd, bfd_arch_hppa, pa10);
1792   bfd_get_symcount (abfd) = file_hdrp->symbol_total;
1793
1794   /* Initialize the saved symbol table and string table to NULL.
1795      Save important offsets and sizes from the SOM header into
1796      the BFD.  */
1797   obj_som_stringtab (abfd) = (char  *) NULL;
1798   obj_som_symtab (abfd) = (som_symbol_type *) NULL;
1799   obj_som_sorted_syms (abfd) = NULL;
1800   obj_som_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
1801   obj_som_sym_filepos (abfd) = file_hdrp->symbol_location;
1802   obj_som_str_filepos (abfd) = file_hdrp->symbol_strings_location;
1803   obj_som_reloc_filepos (abfd) = file_hdrp->fixup_request_location;
1804   obj_som_exec_data (abfd)->system_id = file_hdrp->system_id;
1805
1806   return abfd->xvec;
1807 }
1808
1809 /* Convert all of the space and subspace info into BFD sections.  Each space
1810    contains a number of subspaces, which in turn describe the mapping between
1811    regions of the exec file, and the address space that the program runs in.
1812    BFD sections which correspond to spaces will overlap the sections for the
1813    associated subspaces.  */
1814
1815 static boolean
1816 setup_sections (abfd, file_hdr)
1817      bfd *abfd;
1818      struct header *file_hdr;
1819 {
1820   char *space_strings;
1821   unsigned int space_index, i;
1822   unsigned int total_subspaces = 0;
1823   asection **subspace_sections, *section;
1824
1825   /* First, read in space names */
1826
1827   space_strings = bfd_malloc (file_hdr->space_strings_size);
1828   if (!space_strings && file_hdr->space_strings_size != 0)
1829     goto error_return;
1830
1831   if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
1832     goto error_return;
1833   if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
1834       != file_hdr->space_strings_size)
1835     goto error_return;
1836
1837   /* Loop over all of the space dictionaries, building up sections */
1838   for (space_index = 0; space_index < file_hdr->space_total; space_index++)
1839     {
1840       struct space_dictionary_record space;
1841       struct subspace_dictionary_record subspace, save_subspace;
1842       int subspace_index;
1843       asection *space_asect;
1844       char *newname;
1845
1846       /* Read the space dictionary element */
1847       if (bfd_seek (abfd, file_hdr->space_location
1848                     + space_index * sizeof space, SEEK_SET) < 0)
1849         goto error_return;
1850       if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
1851         goto error_return;
1852
1853       /* Setup the space name string */
1854       space.name.n_name = space.name.n_strx + space_strings;
1855
1856       /* Make a section out of it */
1857       newname = bfd_alloc (abfd, strlen (space.name.n_name) + 1);
1858       if (!newname)
1859         goto error_return;
1860       strcpy (newname, space.name.n_name);
1861
1862       space_asect = bfd_make_section_anyway (abfd, newname);
1863       if (!space_asect)
1864         goto error_return;
1865
1866        if (space.is_loadable == 0)
1867         space_asect->flags |= SEC_DEBUGGING;
1868
1869       /* Set up all the attributes for the space.  */
1870       if (bfd_som_set_section_attributes (space_asect, space.is_defined,
1871                                           space.is_private, space.sort_key,
1872                                           space.space_number) == false)
1873         goto error_return;
1874
1875       /* If the space has no subspaces, then we're done.  */
1876       if (space.subspace_quantity == 0)
1877         continue;
1878
1879       /* Now, read in the first subspace for this space */
1880       if (bfd_seek (abfd, file_hdr->subspace_location
1881                     + space.subspace_index * sizeof subspace,
1882                     SEEK_SET) < 0)
1883         goto error_return;
1884       if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
1885         goto error_return;
1886       /* Seek back to the start of the subspaces for loop below */
1887       if (bfd_seek (abfd, file_hdr->subspace_location
1888                     + space.subspace_index * sizeof subspace,
1889                     SEEK_SET) < 0)
1890         goto error_return;
1891
1892       /* Setup the start address and file loc from the first subspace record */
1893       space_asect->vma = subspace.subspace_start;
1894       space_asect->filepos = subspace.file_loc_init_value;
1895       space_asect->alignment_power = log2 (subspace.alignment);
1896       if (space_asect->alignment_power == -1)
1897         goto error_return;
1898
1899       /* Initialize save_subspace so we can reliably determine if this
1900          loop placed any useful values into it.  */
1901       memset (&save_subspace, 0, sizeof (struct subspace_dictionary_record));
1902
1903       /* Loop over the rest of the subspaces, building up more sections */
1904       for (subspace_index = 0; subspace_index < space.subspace_quantity;
1905            subspace_index++)
1906         {
1907           asection *subspace_asect;
1908
1909           /* Read in the next subspace */
1910           if (bfd_read (&subspace, 1, sizeof subspace, abfd)
1911               != sizeof subspace)
1912             goto error_return;
1913
1914           /* Setup the subspace name string */
1915           subspace.name.n_name = subspace.name.n_strx + space_strings;
1916
1917           newname = bfd_alloc (abfd, strlen (subspace.name.n_name) + 1);
1918           if (!newname)
1919             goto error_return;
1920           strcpy (newname, subspace.name.n_name);
1921
1922           /* Make a section out of this subspace */
1923           subspace_asect = bfd_make_section_anyway (abfd, newname);
1924           if (!subspace_asect)
1925             goto error_return;
1926
1927           /* Store private information about the section.  */
1928           if (bfd_som_set_subsection_attributes (subspace_asect, space_asect,
1929                                                  subspace.access_control_bits,
1930                                                  subspace.sort_key,
1931                                                  subspace.quadrant) == false)
1932             goto error_return;
1933
1934           /* Keep an easy mapping between subspaces and sections.
1935              Note we do not necessarily read the subspaces in the
1936              same order in which they appear in the object file.
1937
1938              So to make the target index come out correctly, we
1939              store the location of the subspace header in target
1940              index, then sort using the location of the subspace
1941              header as the key.  Then we can assign correct
1942              subspace indices.  */
1943           total_subspaces++;
1944           subspace_asect->target_index = bfd_tell (abfd) - sizeof (subspace);
1945
1946           /* Set SEC_READONLY and SEC_CODE/SEC_DATA as specified
1947              by the access_control_bits in the subspace header.  */
1948           switch (subspace.access_control_bits >> 4)
1949             {
1950             /* Readonly data.  */
1951             case 0x0:
1952               subspace_asect->flags |= SEC_DATA | SEC_READONLY;
1953               break;
1954
1955             /* Normal data.  */
1956             case 0x1:
1957               subspace_asect->flags |= SEC_DATA;
1958               break;
1959
1960             /* Readonly code and the gateways.
1961                Gateways have other attributes which do not map
1962                into anything BFD knows about.  */
1963             case 0x2:
1964             case 0x4:
1965             case 0x5:
1966             case 0x6:
1967             case 0x7:
1968               subspace_asect->flags |= SEC_CODE | SEC_READONLY;
1969               break;
1970
1971             /* dynamic (writable) code.  */
1972             case 0x3:
1973               subspace_asect->flags |= SEC_CODE;
1974               break;
1975             }
1976
1977           if (subspace.dup_common || subspace.is_common)
1978             subspace_asect->flags |= SEC_IS_COMMON;
1979           else if (subspace.subspace_length > 0)
1980             subspace_asect->flags |= SEC_HAS_CONTENTS;
1981
1982           if (subspace.is_loadable)
1983             subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
1984           else
1985             subspace_asect->flags |= SEC_DEBUGGING;
1986
1987           if (subspace.code_only)
1988             subspace_asect->flags |= SEC_CODE;
1989
1990           /* Both file_loc_init_value and initialization_length will
1991              be zero for a BSS like subspace.  */
1992           if (subspace.file_loc_init_value == 0
1993               && subspace.initialization_length == 0)
1994             subspace_asect->flags &= ~(SEC_DATA | SEC_LOAD | SEC_HAS_CONTENTS);
1995
1996           /* This subspace has relocations.
1997              The fixup_request_quantity is a byte count for the number of
1998              entries in the relocation stream; it is not the actual number
1999              of relocations in the subspace.  */
2000           if (subspace.fixup_request_quantity != 0)
2001             {
2002               subspace_asect->flags |= SEC_RELOC;
2003               subspace_asect->rel_filepos = subspace.fixup_request_index;
2004               som_section_data (subspace_asect)->reloc_size
2005                 = subspace.fixup_request_quantity;
2006               /* We can not determine this yet.  When we read in the
2007                  relocation table the correct value will be filled in.  */
2008               subspace_asect->reloc_count = -1;
2009             }
2010
2011           /* Update save_subspace if appropriate.  */
2012           if (subspace.file_loc_init_value > save_subspace.file_loc_init_value)
2013             save_subspace = subspace;
2014
2015           subspace_asect->vma = subspace.subspace_start;
2016           subspace_asect->_cooked_size = subspace.subspace_length;
2017           subspace_asect->_raw_size = subspace.subspace_length;
2018           subspace_asect->filepos = subspace.file_loc_init_value;
2019           subspace_asect->alignment_power = log2 (subspace.alignment);
2020           if (subspace_asect->alignment_power == -1)
2021             goto error_return;
2022         }
2023
2024       /* This can happen for a .o which defines symbols in otherwise
2025          empty subspaces.  */
2026       if (!save_subspace.file_loc_init_value)
2027         {
2028           space_asect->_cooked_size = 0;
2029           space_asect->_raw_size = 0;
2030         }
2031       else
2032         {
2033           /* Setup the sizes for the space section based upon the info in the
2034              last subspace of the space.  */
2035           space_asect->_cooked_size = (save_subspace.subspace_start
2036                                        - space_asect->vma
2037                                        + save_subspace.subspace_length);
2038           space_asect->_raw_size = (save_subspace.file_loc_init_value
2039                                     - space_asect->filepos
2040                                     + save_subspace.initialization_length);
2041         }
2042     }
2043   /* Now that we've read in all the subspace records, we need to assign
2044      a target index to each subspace.  */
2045   subspace_sections = (asection **) bfd_malloc (total_subspaces
2046                                                 * sizeof (asection *));
2047   if (subspace_sections == NULL)
2048     goto error_return;
2049
2050   for (i = 0, section = abfd->sections; section; section = section->next)
2051     {
2052       if (!som_is_subspace (section))
2053         continue;
2054
2055       subspace_sections[i] = section;
2056       i++;
2057     }
2058   qsort (subspace_sections, total_subspaces,
2059          sizeof (asection *), compare_subspaces);
2060
2061   /* subspace_sections is now sorted in the order in which the subspaces
2062      appear in the object file.  Assign an index to each one now.  */
2063   for (i = 0; i < total_subspaces; i++)
2064     subspace_sections[i]->target_index = i;
2065
2066   if (space_strings != NULL)
2067     free (space_strings);
2068
2069   if (subspace_sections != NULL)
2070     free (subspace_sections);
2071
2072   return true;
2073
2074  error_return:
2075   if (space_strings != NULL)
2076     free (space_strings);
2077
2078   if (subspace_sections != NULL)
2079     free (subspace_sections);
2080   return false;
2081 }
2082
2083 /* Read in a SOM object and make it into a BFD.  */
2084
2085 static const bfd_target *
2086 som_object_p (abfd)
2087      bfd *abfd;
2088 {
2089   struct header file_hdr;
2090   struct som_exec_auxhdr aux_hdr;
2091
2092   if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
2093     {
2094       if (bfd_get_error () != bfd_error_system_call)
2095         bfd_set_error (bfd_error_wrong_format);
2096       return 0;
2097     }
2098
2099   if (!_PA_RISC_ID (file_hdr.system_id))
2100     {
2101       bfd_set_error (bfd_error_wrong_format);
2102       return 0;
2103     }
2104
2105   switch (file_hdr.a_magic)
2106     {
2107     case RELOC_MAGIC:
2108     case EXEC_MAGIC:
2109     case SHARE_MAGIC:
2110     case DEMAND_MAGIC:
2111 #ifdef DL_MAGIC
2112     case DL_MAGIC:
2113 #endif
2114 #ifdef SHL_MAGIC
2115     case SHL_MAGIC:
2116 #endif
2117 #ifdef EXECLIBMAGIC
2118     case EXECLIBMAGIC:
2119 #endif
2120 #ifdef SHARED_MAGIC_CNX
2121     case SHARED_MAGIC_CNX:
2122 #endif
2123       break;
2124     default:
2125       bfd_set_error (bfd_error_wrong_format);
2126       return 0;
2127     }
2128
2129   if (file_hdr.version_id != VERSION_ID
2130       && file_hdr.version_id != NEW_VERSION_ID)
2131     {
2132       bfd_set_error (bfd_error_wrong_format);
2133       return 0;
2134     }
2135
2136   /* If the aux_header_size field in the file header is zero, then this
2137      object is an incomplete executable (a .o file).  Do not try to read
2138      a non-existant auxiliary header.  */
2139   memset (&aux_hdr, 0, sizeof (struct som_exec_auxhdr));
2140   if (file_hdr.aux_header_size != 0)
2141     {
2142       if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
2143         {
2144           if (bfd_get_error () != bfd_error_system_call)
2145             bfd_set_error (bfd_error_wrong_format);
2146           return 0;
2147         }
2148     }
2149
2150   if (!setup_sections (abfd, &file_hdr))
2151     {
2152       /* setup_sections does not bubble up a bfd error code.  */
2153       bfd_set_error (bfd_error_bad_value);
2154       return 0;
2155     }
2156
2157   /* This appears to be a valid SOM object.  Do some initialization.  */
2158   return som_object_setup (abfd, &file_hdr, &aux_hdr);
2159 }
2160
2161 /* Create a SOM object.  */
2162
2163 static boolean
2164 som_mkobject (abfd)
2165      bfd *abfd;
2166 {
2167   /* Allocate memory to hold backend information.  */
2168   abfd->tdata.som_data = (struct som_data_struct *)
2169     bfd_zalloc (abfd, sizeof (struct som_data_struct));
2170   if (abfd->tdata.som_data == NULL)
2171     return false;
2172   return true;
2173 }
2174
2175 /* Initialize some information in the file header.  This routine makes
2176    not attempt at doing the right thing for a full executable; it
2177    is only meant to handle relocatable objects.  */
2178
2179 static boolean
2180 som_prep_headers (abfd)
2181      bfd *abfd;
2182 {
2183   struct header *file_hdr;
2184   asection *section;
2185
2186   /* Make and attach a file header to the BFD.  */
2187   file_hdr = (struct header *) bfd_zalloc (abfd, sizeof (struct header));
2188   if (file_hdr == NULL)
2189     return false;
2190   obj_som_file_hdr (abfd) = file_hdr;
2191
2192   if (abfd->flags & (EXEC_P | DYNAMIC))
2193     {
2194
2195       /* Make and attach an exec header to the BFD.  */
2196       obj_som_exec_hdr (abfd) = (struct som_exec_auxhdr *)
2197         bfd_zalloc (abfd, sizeof (struct som_exec_auxhdr));
2198       if (obj_som_exec_hdr (abfd) == NULL)
2199         return false;
2200
2201       if (abfd->flags & D_PAGED)
2202         file_hdr->a_magic = DEMAND_MAGIC;
2203       else if (abfd->flags & WP_TEXT)
2204         file_hdr->a_magic = SHARE_MAGIC;
2205 #ifdef SHL_MAGIC
2206       else if (abfd->flags & DYNAMIC)
2207         file_hdr->a_magic = SHL_MAGIC;
2208 #endif
2209       else
2210         file_hdr->a_magic = EXEC_MAGIC;
2211     }
2212   else
2213     file_hdr->a_magic = RELOC_MAGIC;
2214
2215   /* Only new format SOM is supported.  */
2216   file_hdr->version_id = NEW_VERSION_ID;
2217
2218   /* These fields are optional, and embedding timestamps is not always
2219      a wise thing to do, it makes comparing objects during a multi-stage
2220      bootstrap difficult.  */
2221   file_hdr->file_time.secs = 0;
2222   file_hdr->file_time.nanosecs = 0;
2223
2224   file_hdr->entry_space = 0;
2225   file_hdr->entry_subspace = 0;
2226   file_hdr->entry_offset = 0;
2227   file_hdr->presumed_dp = 0;
2228
2229   /* Now iterate over the sections translating information from
2230      BFD sections to SOM spaces/subspaces.  */
2231
2232   for (section = abfd->sections; section != NULL; section = section->next)
2233     {
2234       /* Ignore anything which has not been marked as a space or
2235          subspace.  */
2236       if (!som_is_space (section) && !som_is_subspace (section))
2237         continue;
2238
2239       if (som_is_space (section))
2240         {
2241           /* Allocate space for the space dictionary.  */
2242           som_section_data (section)->space_dict
2243             = (struct space_dictionary_record *)
2244               bfd_zalloc (abfd, sizeof (struct space_dictionary_record));
2245           if (som_section_data (section)->space_dict == NULL)
2246             return false;
2247           /* Set space attributes.  Note most attributes of SOM spaces
2248              are set based on the subspaces it contains.  */
2249           som_section_data (section)->space_dict->loader_fix_index = -1;
2250           som_section_data (section)->space_dict->init_pointer_index = -1;
2251
2252           /* Set more attributes that were stuffed away in private data.  */
2253           som_section_data (section)->space_dict->sort_key =
2254             som_section_data (section)->copy_data->sort_key;
2255           som_section_data (section)->space_dict->is_defined =
2256             som_section_data (section)->copy_data->is_defined;
2257           som_section_data (section)->space_dict->is_private =
2258             som_section_data (section)->copy_data->is_private;
2259           som_section_data (section)->space_dict->space_number =
2260             som_section_data (section)->copy_data->space_number;
2261         }
2262       else
2263         {
2264           /* Allocate space for the subspace dictionary.  */
2265           som_section_data (section)->subspace_dict
2266             = (struct subspace_dictionary_record *)
2267               bfd_zalloc (abfd, sizeof (struct subspace_dictionary_record));
2268           if (som_section_data (section)->subspace_dict == NULL)
2269             return false;
2270
2271           /* Set subspace attributes.  Basic stuff is done here, additional
2272              attributes are filled in later as more information becomes
2273              available.  */
2274           if (section->flags & SEC_IS_COMMON)
2275             {
2276               som_section_data (section)->subspace_dict->dup_common = 1;
2277               som_section_data (section)->subspace_dict->is_common = 1;
2278             }
2279
2280           if (section->flags & SEC_ALLOC)
2281             som_section_data (section)->subspace_dict->is_loadable = 1;
2282
2283           if (section->flags & SEC_CODE)
2284             som_section_data (section)->subspace_dict->code_only = 1;
2285
2286           som_section_data (section)->subspace_dict->subspace_start =
2287             section->vma;
2288           som_section_data (section)->subspace_dict->subspace_length =
2289             bfd_section_size (abfd, section);
2290           som_section_data (section)->subspace_dict->initialization_length =
2291             bfd_section_size (abfd, section);
2292           som_section_data (section)->subspace_dict->alignment =
2293             1 << section->alignment_power;
2294
2295           /* Set more attributes that were stuffed away in private data.  */
2296           som_section_data (section)->subspace_dict->sort_key =
2297             som_section_data (section)->copy_data->sort_key;
2298           som_section_data (section)->subspace_dict->access_control_bits =
2299             som_section_data (section)->copy_data->access_control_bits;
2300           som_section_data (section)->subspace_dict->quadrant =
2301             som_section_data (section)->copy_data->quadrant;
2302         }
2303     }
2304   return true;
2305 }
2306
2307 /* Return true if the given section is a SOM space, false otherwise.  */
2308
2309 static boolean
2310 som_is_space (section)
2311      asection *section;
2312 {
2313   /* If no copy data is available, then it's neither a space nor a
2314      subspace.  */
2315   if (som_section_data (section)->copy_data == NULL)
2316     return false;
2317
2318   /* If the containing space isn't the same as the given section,
2319      then this isn't a space.  */
2320   if (som_section_data (section)->copy_data->container != section
2321       && (som_section_data (section)->copy_data->container->output_section
2322           != section))
2323     return false;
2324
2325   /* OK.  Must be a space.  */
2326   return true;
2327 }
2328
2329 /* Return true if the given section is a SOM subspace, false otherwise.  */
2330
2331 static boolean
2332 som_is_subspace (section)
2333      asection *section;
2334 {
2335   /* If no copy data is available, then it's neither a space nor a
2336      subspace.  */
2337   if (som_section_data (section)->copy_data == NULL)
2338     return false;
2339
2340   /* If the containing space is the same as the given section,
2341      then this isn't a subspace.  */
2342   if (som_section_data (section)->copy_data->container == section
2343       || (som_section_data (section)->copy_data->container->output_section
2344           == section))
2345     return false;
2346
2347   /* OK.  Must be a subspace.  */
2348   return true;
2349 }
2350
2351 /* Return true if the given space containins the given subspace.  It
2352    is safe to assume space really is a space, and subspace really
2353    is a subspace.  */
2354
2355 static boolean
2356 som_is_container (space, subspace)
2357      asection *space, *subspace;
2358 {
2359   return (som_section_data (subspace)->copy_data->container == space
2360           || (som_section_data (subspace)->copy_data->container->output_section
2361               == space));
2362 }
2363
2364 /* Count and return the number of spaces attached to the given BFD.  */
2365
2366 static unsigned long
2367 som_count_spaces (abfd)
2368      bfd *abfd;
2369 {
2370   int count = 0;
2371   asection *section;
2372
2373   for (section = abfd->sections; section != NULL; section = section->next)
2374       count += som_is_space (section);
2375
2376   return count;
2377 }
2378
2379 /* Count the number of subspaces attached to the given BFD.  */
2380
2381 static unsigned long
2382 som_count_subspaces (abfd)
2383      bfd *abfd;
2384 {
2385   int count = 0;
2386   asection *section;
2387
2388   for (section = abfd->sections; section != NULL; section = section->next)
2389     count += som_is_subspace (section);
2390
2391   return count;
2392 }
2393
2394 /* Return -1, 0, 1 indicating the relative ordering of sym1 and sym2.
2395
2396    We desire symbols to be ordered starting with the symbol with the
2397    highest relocation count down to the symbol with the lowest relocation
2398    count.  Doing so compacts the relocation stream.  */
2399
2400 static int
2401 compare_syms (arg1, arg2)
2402      const PTR arg1;
2403      const PTR arg2;
2404
2405 {
2406   asymbol **sym1 = (asymbol **) arg1;
2407   asymbol **sym2 = (asymbol **) arg2;
2408   unsigned int count1, count2;
2409
2410   /* Get relocation count for each symbol.  Note that the count
2411      is stored in the udata pointer for section symbols!  */
2412   if ((*sym1)->flags & BSF_SECTION_SYM)
2413     count1 = (*sym1)->udata.i;
2414   else
2415     count1 = som_symbol_data (*sym1)->reloc_count;
2416
2417   if ((*sym2)->flags & BSF_SECTION_SYM)
2418     count2 = (*sym2)->udata.i;
2419   else
2420     count2 = som_symbol_data (*sym2)->reloc_count;
2421
2422   /* Return the appropriate value.  */
2423   if (count1 < count2)
2424     return 1;
2425   else if (count1 > count2)
2426     return -1;
2427   return 0;
2428 }
2429
2430 /* Return -1, 0, 1 indicating the relative ordering of subspace1
2431    and subspace.  */
2432
2433 static int
2434 compare_subspaces (arg1, arg2)
2435      const PTR arg1;
2436      const PTR arg2;
2437
2438 {
2439   asection **subspace1 = (asection **) arg1;
2440   asection **subspace2 = (asection **) arg2;
2441   unsigned int count1, count2;
2442
2443   if ((*subspace1)->target_index < (*subspace2)->target_index)
2444     return -1;
2445   else if ((*subspace2)->target_index < (*subspace1)->target_index)
2446     return 1;
2447   else
2448     return 0;
2449 }
2450
2451 /* Perform various work in preparation for emitting the fixup stream.  */
2452
2453 static void
2454 som_prep_for_fixups (abfd, syms, num_syms)
2455      bfd *abfd;
2456      asymbol **syms;
2457      unsigned long num_syms;
2458 {
2459   int i;
2460   asection *section;
2461   asymbol **sorted_syms;
2462
2463   /* Most SOM relocations involving a symbol have a length which is
2464      dependent on the index of the symbol.  So symbols which are
2465      used often in relocations should have a small index.  */
2466
2467   /* First initialize the counters for each symbol.  */
2468   for (i = 0; i < num_syms; i++)
2469     {
2470       /* Handle a section symbol; these have no pointers back to the
2471          SOM symbol info.  So we just use the udata field to hold the
2472          relocation count.  */
2473       if (som_symbol_data (syms[i]) == NULL
2474           || syms[i]->flags & BSF_SECTION_SYM)
2475         {
2476           syms[i]->flags |= BSF_SECTION_SYM;
2477           syms[i]->udata.i = 0;
2478         }
2479       else
2480         som_symbol_data (syms[i])->reloc_count = 0;
2481     }
2482
2483   /* Now that the counters are initialized, make a weighted count
2484      of how often a given symbol is used in a relocation.  */
2485   for (section = abfd->sections; section != NULL; section = section->next)
2486     {
2487       int i;
2488
2489       /* Does this section have any relocations?  */
2490       if (section->reloc_count <= 0)
2491         continue;
2492
2493       /* Walk through each relocation for this section.  */
2494       for (i = 1; i < section->reloc_count; i++)
2495         {
2496           arelent *reloc = section->orelocation[i];
2497           int scale;
2498
2499           /* A relocation against a symbol in the *ABS* section really
2500              does not have a symbol.  Likewise if the symbol isn't associated
2501              with any section.  */
2502           if (reloc->sym_ptr_ptr == NULL
2503               || bfd_is_abs_section ((*reloc->sym_ptr_ptr)->section))
2504             continue;
2505
2506           /* Scaling to encourage symbols involved in R_DP_RELATIVE
2507              and R_CODE_ONE_SYMBOL relocations to come first.  These
2508              two relocations have single byte versions if the symbol
2509              index is very small.  */
2510           if (reloc->howto->type == R_DP_RELATIVE
2511               || reloc->howto->type == R_CODE_ONE_SYMBOL)
2512             scale = 2;
2513           else
2514             scale = 1;
2515
2516           /* Handle section symbols by storing the count in the udata
2517              field.  It will not be used and the count is very important
2518              for these symbols.  */
2519           if ((*reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM)
2520             {
2521               (*reloc->sym_ptr_ptr)->udata.i =
2522                 (*reloc->sym_ptr_ptr)->udata.i + scale;
2523               continue;
2524             }
2525
2526           /* A normal symbol.  Increment the count.  */
2527           som_symbol_data (*reloc->sym_ptr_ptr)->reloc_count += scale;
2528         }
2529     }
2530
2531   /* Sort a copy of the symbol table, rather than the canonical
2532      output symbol table.  */
2533   sorted_syms = (asymbol **) bfd_zalloc (abfd, num_syms * sizeof (asymbol *));
2534   memcpy (sorted_syms, syms, num_syms * sizeof (asymbol *));
2535   qsort (sorted_syms, num_syms, sizeof (asymbol *), compare_syms);
2536   obj_som_sorted_syms (abfd) = sorted_syms;
2537
2538   /* Compute the symbol indexes, they will be needed by the relocation
2539      code.  */
2540   for (i = 0; i < num_syms; i++)
2541     {
2542       /* A section symbol.  Again, there is no pointer to backend symbol
2543          information, so we reuse the udata field again.  */
2544       if (sorted_syms[i]->flags & BSF_SECTION_SYM)
2545         sorted_syms[i]->udata.i = i;
2546       else
2547         som_symbol_data (sorted_syms[i])->index = i;
2548     }
2549 }
2550
2551 static boolean
2552 som_write_fixups (abfd, current_offset, total_reloc_sizep)
2553      bfd *abfd;
2554      unsigned long current_offset;
2555      unsigned int *total_reloc_sizep;
2556 {
2557   unsigned int i, j;
2558   /* Chunk of memory that we can use as buffer space, then throw
2559      away.  */
2560   unsigned char tmp_space[SOM_TMP_BUFSIZE];
2561   unsigned char *p;
2562   unsigned int total_reloc_size = 0;
2563   unsigned int subspace_reloc_size = 0;
2564   unsigned int num_spaces = obj_som_file_hdr (abfd)->space_total;
2565   asection *section = abfd->sections;
2566
2567   memset (tmp_space, 0, SOM_TMP_BUFSIZE);
2568   p = tmp_space;
2569
2570   /* All the fixups for a particular subspace are emitted in a single
2571      stream.  All the subspaces for a particular space are emitted
2572      as a single stream.
2573
2574      So, to get all the locations correct one must iterate through all the
2575      spaces, for each space iterate through its subspaces and output a
2576      fixups stream.  */
2577   for (i = 0; i < num_spaces; i++)
2578     {
2579       asection *subsection;
2580
2581       /* Find a space.  */
2582       while (!som_is_space (section))
2583         section = section->next;
2584
2585       /* Now iterate through each of its subspaces.  */
2586       for (subsection = abfd->sections;
2587            subsection != NULL;
2588            subsection = subsection->next)
2589         {
2590           int reloc_offset, current_rounding_mode;
2591
2592           /* Find a subspace of this space.  */
2593           if (!som_is_subspace (subsection)
2594               || !som_is_container (section, subsection))
2595             continue;
2596
2597           /* If this subspace does not have real data, then we are
2598              finised with it.  */
2599           if ((subsection->flags & SEC_HAS_CONTENTS) == 0)
2600             {
2601               som_section_data (subsection)->subspace_dict->fixup_request_index
2602                 = -1;
2603               continue;
2604             }
2605
2606           /* This subspace has some relocations.  Put the relocation stream
2607              index into the subspace record.  */
2608           som_section_data (subsection)->subspace_dict->fixup_request_index
2609             = total_reloc_size;
2610
2611           /* To make life easier start over with a clean slate for
2612              each subspace.  Seek to the start of the relocation stream
2613              for this subspace in preparation for writing out its fixup
2614              stream.  */
2615           if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) < 0)
2616             return false;
2617
2618           /* Buffer space has already been allocated.  Just perform some
2619              initialization here.  */
2620           p = tmp_space;
2621           subspace_reloc_size = 0;
2622           reloc_offset = 0;
2623           som_initialize_reloc_queue (reloc_queue);
2624           current_rounding_mode = R_N_MODE;
2625
2626           /* Translate each BFD relocation into one or more SOM
2627              relocations.  */
2628           for (j = 0; j < subsection->reloc_count; j++)
2629             {
2630               arelent *bfd_reloc = subsection->orelocation[j];
2631               unsigned int skip;
2632               int sym_num;
2633
2634               /* Get the symbol number.  Remember it's stored in a
2635                  special place for section symbols.  */
2636               if ((*bfd_reloc->sym_ptr_ptr)->flags & BSF_SECTION_SYM)
2637                 sym_num = (*bfd_reloc->sym_ptr_ptr)->udata.i;
2638               else
2639                 sym_num = som_symbol_data (*bfd_reloc->sym_ptr_ptr)->index;
2640
2641               /* If there is not enough room for the next couple relocations,
2642                  then dump the current buffer contents now.  Also reinitialize
2643                  the relocation queue.
2644
2645                  No single BFD relocation could ever translate into more
2646                  than 100 bytes of SOM relocations (20bytes is probably the
2647                  upper limit, but leave lots of space for growth).  */
2648               if (p - tmp_space + 100 > SOM_TMP_BUFSIZE)
2649                 {
2650                   if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2651                       != p - tmp_space)
2652                     return false;
2653
2654                   p = tmp_space;
2655                   som_initialize_reloc_queue (reloc_queue);
2656                 }
2657
2658               /* Emit R_NO_RELOCATION fixups to map any bytes which were
2659                  skipped.  */
2660               skip = bfd_reloc->address - reloc_offset;
2661               p = som_reloc_skip (abfd, skip, p,
2662                                   &subspace_reloc_size, reloc_queue);
2663
2664               /* Update reloc_offset for the next iteration.
2665
2666                  Many relocations do not consume input bytes.  They
2667                  are markers, or set state necessary to perform some
2668                  later relocation.  */
2669               switch (bfd_reloc->howto->type)
2670                 {
2671                 case R_ENTRY:
2672                 case R_ALT_ENTRY:
2673                 case R_EXIT:
2674                 case R_N_MODE:
2675                 case R_S_MODE:
2676                 case R_D_MODE:
2677                 case R_R_MODE:
2678                 case R_FSEL:
2679                 case R_LSEL:
2680                 case R_RSEL:
2681                 case R_COMP1:
2682                 case R_COMP2:
2683                 case R_BEGIN_BRTAB:
2684                 case R_END_BRTAB:
2685                 case R_BEGIN_TRY:
2686                 case R_END_TRY:
2687                 case R_N0SEL:
2688                 case R_N1SEL:
2689                   reloc_offset = bfd_reloc->address;
2690                   break;
2691
2692                 default:
2693                   reloc_offset = bfd_reloc->address + 4;
2694                   break;
2695                 }
2696
2697               /* Now the actual relocation we care about.  */
2698               switch (bfd_reloc->howto->type)
2699                 {
2700                 case R_PCREL_CALL:
2701                 case R_ABS_CALL:
2702                   p = som_reloc_call (abfd, p, &subspace_reloc_size,
2703                                       bfd_reloc, sym_num, reloc_queue);
2704                   break;
2705
2706                 case R_CODE_ONE_SYMBOL:
2707                 case R_DP_RELATIVE:
2708                   /* Account for any addend.  */
2709                   if (bfd_reloc->addend)
2710                     p = som_reloc_addend (abfd, bfd_reloc->addend, p,
2711                                           &subspace_reloc_size, reloc_queue);
2712
2713                   if (sym_num < 0x20)
2714                     {
2715                       bfd_put_8 (abfd, bfd_reloc->howto->type + sym_num, p);
2716                       subspace_reloc_size += 1;
2717                       p += 1;
2718                     }
2719                   else if (sym_num < 0x100)
2720                     {
2721                       bfd_put_8 (abfd, bfd_reloc->howto->type + 32, p);
2722                       bfd_put_8 (abfd, sym_num, p + 1);
2723                       p = try_prev_fixup (abfd, &subspace_reloc_size, p,
2724                                           2, reloc_queue);
2725                     }
2726                   else if (sym_num < 0x10000000)
2727                     {
2728                       bfd_put_8 (abfd, bfd_reloc->howto->type + 33, p);
2729                       bfd_put_8 (abfd, sym_num >> 16, p + 1);
2730                       bfd_put_16 (abfd, sym_num, p + 2);
2731                       p = try_prev_fixup (abfd, &subspace_reloc_size,
2732                                           p, 4, reloc_queue);
2733                     }
2734                   else
2735                     abort ();
2736                   break;
2737
2738                 case R_DATA_ONE_SYMBOL:
2739                 case R_DATA_PLABEL:
2740                 case R_CODE_PLABEL:
2741                 case R_DLT_REL:
2742                   /* Account for any addend using R_DATA_OVERRIDE.  */
2743                   if (bfd_reloc->howto->type != R_DATA_ONE_SYMBOL
2744                       && bfd_reloc->addend)
2745                     p = som_reloc_addend (abfd, bfd_reloc->addend, p,
2746                                           &subspace_reloc_size, reloc_queue);
2747
2748                   if (sym_num < 0x100)
2749                     {
2750                       bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2751                       bfd_put_8 (abfd, sym_num, p + 1);
2752                       p = try_prev_fixup (abfd, &subspace_reloc_size, p,
2753                                           2, reloc_queue);
2754                     }
2755                   else if (sym_num < 0x10000000)
2756                     {
2757                       bfd_put_8 (abfd, bfd_reloc->howto->type + 1, p);
2758                       bfd_put_8 (abfd, sym_num >> 16, p + 1);
2759                       bfd_put_16 (abfd, sym_num, p + 2);
2760                       p = try_prev_fixup (abfd, &subspace_reloc_size,
2761                                           p, 4, reloc_queue);
2762                     }
2763                   else
2764                     abort ();
2765                   break;
2766
2767                 case R_ENTRY:
2768                   {
2769                     int tmp;
2770                     arelent *tmp_reloc = NULL;
2771                     bfd_put_8 (abfd, R_ENTRY, p);
2772
2773                     /* R_ENTRY relocations have 64 bits of associated
2774                        data.  Unfortunately the addend field of a bfd
2775                        relocation is only 32 bits.  So, we split up
2776                        the 64bit unwind information and store part in
2777                        the R_ENTRY relocation, and the rest in the R_EXIT
2778                        relocation.  */
2779                     bfd_put_32 (abfd, bfd_reloc->addend, p + 1);
2780
2781                     /* Find the next R_EXIT relocation.  */
2782                     for (tmp = j; tmp < subsection->reloc_count; tmp++)
2783                       {
2784                         tmp_reloc = subsection->orelocation[tmp];
2785                         if (tmp_reloc->howto->type == R_EXIT)
2786                           break;
2787                       }
2788
2789                     if (tmp == subsection->reloc_count)
2790                       abort ();
2791
2792                     bfd_put_32 (abfd, tmp_reloc->addend, p + 5);
2793                     p = try_prev_fixup (abfd, &subspace_reloc_size,
2794                                         p, 9, reloc_queue);
2795                     break;
2796                   }
2797
2798                 case R_N_MODE:
2799                 case R_S_MODE:
2800                 case R_D_MODE:
2801                 case R_R_MODE:
2802                   /* If this relocation requests the current rounding
2803                      mode, then it is redundant.  */
2804                   if (bfd_reloc->howto->type != current_rounding_mode)
2805                     {
2806                       bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2807                       subspace_reloc_size += 1;
2808                       p += 1;
2809                       current_rounding_mode = bfd_reloc->howto->type;
2810                     }
2811                   break;
2812
2813                 case R_EXIT:
2814                 case R_ALT_ENTRY:
2815                 case R_FSEL:
2816                 case R_LSEL:
2817                 case R_RSEL:
2818                 case R_BEGIN_BRTAB:
2819                 case R_END_BRTAB:
2820                 case R_BEGIN_TRY:
2821                 case R_N0SEL:
2822                 case R_N1SEL:
2823                   bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2824                   subspace_reloc_size += 1;
2825                   p += 1;
2826                   break;
2827
2828                 case R_END_TRY:
2829                   /* The end of a exception handling region.  The reloc's
2830                      addend contains the offset of the exception handling
2831                      code.  */
2832                   if (bfd_reloc->addend == 0)
2833                     bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2834                   else if (bfd_reloc->addend < 1024)
2835                     {
2836                       bfd_put_8 (abfd, bfd_reloc->howto->type + 1, p);
2837                       bfd_put_8 (abfd, bfd_reloc->addend / 4, p + 1);
2838                       p = try_prev_fixup (abfd, &subspace_reloc_size,
2839                                           p, 2, reloc_queue);
2840                     }
2841                   else
2842                     {
2843                       bfd_put_8 (abfd, bfd_reloc->howto->type + 2, p);
2844                       bfd_put_8 (abfd, (bfd_reloc->addend / 4) >> 16, p + 1);
2845                       bfd_put_16 (abfd, bfd_reloc->addend / 4, p + 2);
2846                       p = try_prev_fixup (abfd, &subspace_reloc_size,
2847                                           p, 4, reloc_queue);
2848                     }
2849                   break;
2850
2851                 case R_COMP1:
2852                   /* The only time we generate R_COMP1, R_COMP2 and
2853                      R_CODE_EXPR relocs is for the difference of two
2854                      symbols.  Hence we can cheat here.  */
2855                   bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2856                   bfd_put_8 (abfd, 0x44, p + 1);
2857                   p = try_prev_fixup (abfd, &subspace_reloc_size,
2858                                       p, 2, reloc_queue);
2859                   break;
2860
2861                 case R_COMP2:
2862                   /* The only time we generate R_COMP1, R_COMP2 and
2863                      R_CODE_EXPR relocs is for the difference of two
2864                      symbols.  Hence we can cheat here.  */
2865                   bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2866                   bfd_put_8 (abfd, 0x80, p + 1);
2867                   bfd_put_8 (abfd, sym_num >> 16, p + 2);
2868                   bfd_put_16 (abfd, sym_num, p + 3);
2869                   p = try_prev_fixup (abfd, &subspace_reloc_size,
2870                                       p, 5, reloc_queue);
2871                   break;
2872
2873                 case R_CODE_EXPR:
2874                 case R_DATA_EXPR:
2875                   /* The only time we generate R_COMP1, R_COMP2 and
2876                      R_CODE_EXPR relocs is for the difference of two
2877                      symbols.  Hence we can cheat here.  */
2878                   bfd_put_8 (abfd, bfd_reloc->howto->type, p);
2879                   subspace_reloc_size += 1;
2880                   p += 1;
2881                   break;
2882
2883                 /* Put a "R_RESERVED" relocation in the stream if
2884                    we hit something we do not understand.  The linker
2885                    will complain loudly if this ever happens.  */
2886                 default:
2887                   bfd_put_8 (abfd, 0xff, p);
2888                   subspace_reloc_size += 1;
2889                   p += 1;
2890                   break;
2891                 }
2892             }
2893
2894           /* Last BFD relocation for a subspace has been processed.
2895              Map the rest of the subspace with R_NO_RELOCATION fixups.  */
2896           p = som_reloc_skip (abfd, bfd_section_size (abfd, subsection)
2897                                       - reloc_offset,
2898                               p, &subspace_reloc_size, reloc_queue);
2899
2900           /* Scribble out the relocations.  */
2901           if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
2902               != p - tmp_space)
2903             return false;
2904           p = tmp_space;
2905
2906           total_reloc_size += subspace_reloc_size;
2907           som_section_data (subsection)->subspace_dict->fixup_request_quantity
2908             = subspace_reloc_size;
2909         }
2910       section = section->next;
2911     }
2912   *total_reloc_sizep = total_reloc_size;
2913   return true;
2914 }
2915
2916 /* Write out the space/subspace string table.  */
2917
2918 static boolean
2919 som_write_space_strings (abfd, current_offset, string_sizep)
2920      bfd *abfd;
2921      unsigned long current_offset;
2922      unsigned int *string_sizep;
2923 {
2924   /* Chunk of memory that we can use as buffer space, then throw
2925      away.  */
2926   unsigned char tmp_space[SOM_TMP_BUFSIZE];
2927   unsigned char *p;
2928   unsigned int strings_size = 0;
2929   asection *section;
2930
2931   memset (tmp_space, 0, SOM_TMP_BUFSIZE);
2932   p = tmp_space;
2933
2934   /* Seek to the start of the space strings in preparation for writing
2935      them out.  */
2936   if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
2937     return false;
2938
2939   /* Walk through all the spaces and subspaces (order is not important)
2940      building up and writing string table entries for their names.  */
2941   for (section = abfd->sections; section != NULL; section = section->next)
2942     {
2943       int length;
2944
2945       /* Only work with space/subspaces; avoid any other sections
2946          which might have been made (.text for example).  */
2947       if (!som_is_space (section) && !som_is_subspace (section))
2948         continue;
2949
2950       /* Get the length of the space/subspace name.  */
2951       length = strlen (section->name);
2952
2953       /* If there is not enough room for the next entry, then dump the
2954          current buffer contents now.  Each entry will take 4 bytes to
2955          hold the string length + the string itself + null terminator.  */
2956       if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
2957         {
2958           if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
2959               != p - tmp_space)
2960             return false;
2961           /* Reset to beginning of the buffer space.  */
2962           p = tmp_space;
2963         }
2964
2965       /* First element in a string table entry is the length of the
2966          string.  Alignment issues are already handled.  */
2967       bfd_put_32 (abfd, length, p);
2968       p += 4;
2969       strings_size += 4;
2970
2971       /* Record the index in the space/subspace records.  */
2972       if (som_is_space (section))
2973         som_section_data (section)->space_dict->name.n_strx = strings_size;
2974       else
2975         som_section_data (section)->subspace_dict->name.n_strx = strings_size;
2976
2977       /* Next comes the string itself + a null terminator.  */
2978       strcpy (p, section->name);
2979       p += length + 1;
2980       strings_size += length + 1;
2981
2982       /* Always align up to the next word boundary.  */
2983       while (strings_size % 4)
2984         {
2985           bfd_put_8 (abfd, 0, p);
2986           p++;
2987           strings_size++;
2988         }
2989     }
2990
2991   /* Done with the space/subspace strings.  Write out any information
2992      contained in a partial block.  */
2993   if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
2994     return false;
2995   *string_sizep = strings_size;
2996   return true;
2997 }
2998
2999 /* Write out the symbol string table.  */
3000
3001 static boolean
3002 som_write_symbol_strings (abfd, current_offset, syms, num_syms, string_sizep)
3003      bfd *abfd;
3004      unsigned long current_offset;
3005      asymbol **syms;
3006      unsigned int num_syms;
3007      unsigned int *string_sizep;
3008 {
3009   unsigned int i;
3010
3011   /* Chunk of memory that we can use as buffer space, then throw
3012      away.  */
3013   unsigned char tmp_space[SOM_TMP_BUFSIZE];
3014   unsigned char *p;
3015   unsigned int strings_size = 0;
3016
3017   memset (tmp_space, 0, SOM_TMP_BUFSIZE);
3018   p = tmp_space;
3019
3020   /* Seek to the start of the space strings in preparation for writing
3021      them out.  */
3022   if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3023     return false;
3024
3025   for (i = 0; i < num_syms; i++)
3026     {
3027       int length = strlen (syms[i]->name);
3028
3029       /* If there is not enough room for the next entry, then dump the
3030          current buffer contents now.  */
3031      if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
3032         {
3033           if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
3034               != p - tmp_space)
3035             return false;
3036           /* Reset to beginning of the buffer space.  */
3037           p = tmp_space;
3038         }
3039
3040       /* First element in a string table entry is the length of the
3041          string.  This must always be 4 byte aligned.  This is also
3042          an appropriate time to fill in the string index field in the
3043          symbol table entry.  */
3044       bfd_put_32 (abfd, length, p);
3045       strings_size += 4;
3046       p += 4;
3047
3048       /* Next comes the string itself + a null terminator.  */
3049       strcpy (p, syms[i]->name);
3050
3051       som_symbol_data(syms[i])->stringtab_offset = strings_size;
3052       p += length + 1;
3053       strings_size += length + 1;
3054
3055       /* Always align up to the next word boundary.  */
3056       while (strings_size % 4)
3057         {
3058           bfd_put_8 (abfd, 0, p);
3059           strings_size++;
3060           p++;
3061         }
3062     }
3063
3064   /* Scribble out any partial block.  */
3065   if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
3066     return false;
3067
3068   *string_sizep = strings_size;
3069   return true;
3070 }
3071
3072 /* Compute variable information to be placed in the SOM headers,
3073    space/subspace dictionaries, relocation streams, etc.  Begin
3074    writing parts of the object file.  */
3075
3076 static boolean
3077 som_begin_writing (abfd)
3078      bfd *abfd;
3079 {
3080   unsigned long current_offset = 0;
3081   int strings_size = 0;
3082   unsigned int total_reloc_size = 0;
3083   unsigned long num_spaces, num_subspaces, i;
3084   asection *section;
3085   unsigned int total_subspaces = 0;
3086   struct som_exec_auxhdr *exec_header = NULL;
3087
3088   /* The file header will always be first in an object file,
3089      everything else can be in random locations.  To keep things
3090      "simple" BFD will lay out the object file in the manner suggested
3091      by the PRO ABI for PA-RISC Systems.  */
3092
3093   /* Before any output can really begin offsets for all the major
3094      portions of the object file must be computed.  So, starting
3095      with the initial file header compute (and sometimes write)
3096      each portion of the object file.  */
3097
3098   /* Make room for the file header, it's contents are not complete
3099      yet, so it can not be written at this time.  */
3100   current_offset += sizeof (struct header);
3101
3102   /* Any auxiliary headers will follow the file header.  Right now
3103      we support only the copyright and version headers.  */
3104   obj_som_file_hdr (abfd)->aux_header_location = current_offset;
3105   obj_som_file_hdr (abfd)->aux_header_size = 0;
3106   if (abfd->flags & (EXEC_P | DYNAMIC))
3107     {
3108       /* Parts of the exec header will be filled in later, so
3109          delay writing the header itself.  Fill in the defaults,
3110          and write it later.  */
3111       current_offset += sizeof (struct som_exec_auxhdr);
3112       obj_som_file_hdr (abfd)->aux_header_size
3113         += sizeof (struct som_exec_auxhdr);
3114       exec_header = obj_som_exec_hdr (abfd);
3115       exec_header->som_auxhdr.type = EXEC_AUX_ID;
3116       exec_header->som_auxhdr.length = 40;
3117     }
3118   if (obj_som_version_hdr (abfd) != NULL)
3119     {
3120       unsigned int len;
3121
3122       if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3123         return false;
3124
3125       /* Write the aux_id structure and the string length.  */
3126       len = sizeof (struct aux_id) + sizeof (unsigned int);
3127       obj_som_file_hdr (abfd)->aux_header_size += len;
3128       current_offset += len;
3129       if (bfd_write ((PTR) obj_som_version_hdr (abfd), len, 1, abfd) != len)
3130         return false;
3131
3132       /* Write the version string.  */
3133       len = obj_som_version_hdr (abfd)->header_id.length - sizeof (int);
3134       obj_som_file_hdr (abfd)->aux_header_size += len;
3135       current_offset += len;
3136       if (bfd_write ((PTR) obj_som_version_hdr (abfd)->user_string,
3137                      len, 1, abfd) != len)
3138         return false;
3139     }
3140
3141   if (obj_som_copyright_hdr (abfd) != NULL)
3142     {
3143       unsigned int len;
3144
3145       if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
3146         return false;
3147
3148       /* Write the aux_id structure and the string length.  */
3149       len = sizeof (struct aux_id) + sizeof (unsigned int);
3150       obj_som_file_hdr (abfd)->aux_header_size += len;
3151       current_offset += len;
3152       if (bfd_write ((PTR) obj_som_copyright_hdr (abfd), len, 1, abfd) != len)
3153         return false;
3154
3155       /* Write the copyright string.  */
3156       len = obj_som_copyright_hdr (abfd)->header_id.length - sizeof (int);
3157       obj_som_file_hdr (abfd)->aux_header_size += len;
3158       current_offset += len;
3159       if (bfd_write ((PTR) obj_som_copyright_hdr (abfd)->copyright,
3160                      len, 1, abfd) != len)
3161         return false;
3162     }
3163
3164   /* Next comes the initialization pointers; we have no initialization
3165      pointers, so current offset does not change.  */
3166   obj_som_file_hdr (abfd)->init_array_location = current_offset;
3167   obj_som_file_hdr (abfd)->init_array_total = 0;
3168
3169   /* Next are the space records.  These are fixed length records.
3170
3171      Count the number of spaces to determine how much room is needed
3172      in the object file for the space records.
3173
3174      The names of the spaces are stored in a separate string table,
3175      and the index for each space into the string table is computed
3176      below.  Therefore, it is not possible to write the space headers
3177      at this time.  */
3178   num_spaces = som_count_spaces (abfd);
3179   obj_som_file_hdr (abfd)->space_location = current_offset;
3180   obj_som_file_hdr (abfd)->space_total = num_spaces;
3181   current_offset += num_spaces * sizeof (struct space_dictionary_record);
3182
3183   /* Next are the subspace records.  These are fixed length records.
3184
3185      Count the number of subspaes to determine how much room is needed
3186      in the object file for the subspace records.
3187
3188      A variety if fields in the subspace record are still unknown at
3189      this time (index into string table, fixup stream location/size, etc).  */
3190   num_subspaces = som_count_subspaces (abfd);
3191   obj_som_file_hdr (abfd)->subspace_location = current_offset;
3192   obj_som_file_hdr (abfd)->subspace_total = num_subspaces;
3193   current_offset += num_subspaces * sizeof (struct subspace_dictionary_record);
3194
3195   /* Next is the string table for the space/subspace names.  We will
3196      build and write the string table on the fly.  At the same time
3197      we will fill in the space/subspace name index fields.  */
3198
3199   /* The string table needs to be aligned on a word boundary.  */
3200   if (current_offset % 4)
3201     current_offset += (4 - (current_offset % 4));
3202
3203   /* Mark the offset of the space/subspace string table in the
3204      file header.  */
3205   obj_som_file_hdr (abfd)->space_strings_location = current_offset;
3206
3207   /* Scribble out the space strings.  */
3208   if (som_write_space_strings (abfd, current_offset, &strings_size) == false)
3209     return false;
3210
3211   /* Record total string table size in the header and update the
3212      current offset.  */
3213   obj_som_file_hdr (abfd)->space_strings_size = strings_size;
3214   current_offset += strings_size;
3215
3216   /* Next is the compiler records.  We do not use these.  */
3217   obj_som_file_hdr (abfd)->compiler_location = current_offset;
3218   obj_som_file_hdr (abfd)->compiler_total = 0;
3219
3220   /* Now compute the file positions for the loadable subspaces, taking
3221      care to make sure everything stays properly aligned.  */
3222
3223   section = abfd->sections;
3224   for (i = 0; i < num_spaces; i++)
3225     {
3226       asection *subsection;
3227       int first_subspace;
3228       unsigned int subspace_offset = 0;
3229
3230       /* Find a space.  */
3231       while (!som_is_space (section))
3232         section = section->next;
3233
3234       first_subspace = 1;
3235       /* Now look for all its subspaces.  */
3236       for (subsection = abfd->sections;
3237            subsection != NULL;
3238            subsection = subsection->next)
3239         {
3240
3241           if (!som_is_subspace (subsection)
3242               || !som_is_container (section, subsection)
3243               || (subsection->flags & SEC_ALLOC) == 0)
3244             continue;
3245
3246           /* If this is the first subspace in the space, and we are
3247              building an executable, then take care to make sure all
3248              the alignments are correct and update the exec header.  */
3249           if (first_subspace
3250               && (abfd->flags & (EXEC_P | DYNAMIC)))
3251             {
3252               /* Demand paged executables have each space aligned to a
3253                  page boundary.  Sharable executables (write-protected
3254                  text) have just the private (aka data & bss) space aligned
3255                  to a page boundary.  Ugh.  Not true for HPUX.
3256
3257                  The HPUX kernel requires the text to always be page aligned
3258                  within the file regardless of the executable's type.  */
3259               if (abfd->flags & (D_PAGED | DYNAMIC)
3260                   || (subsection->flags & SEC_CODE)
3261                   || ((abfd->flags & WP_TEXT)
3262                       && (subsection->flags & SEC_DATA)))
3263                 current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3264
3265               /* Update the exec header.  */
3266               if (subsection->flags & SEC_CODE && exec_header->exec_tfile == 0)
3267                 {
3268                   exec_header->exec_tmem = section->vma;
3269                   exec_header->exec_tfile = current_offset;
3270                 }
3271               if (subsection->flags & SEC_DATA && exec_header->exec_dfile == 0)
3272                 {
3273                   exec_header->exec_dmem = section->vma;
3274                   exec_header->exec_dfile = current_offset;
3275                 }
3276
3277               /* Keep track of exactly where we are within a particular
3278                  space.  This is necessary as the braindamaged HPUX
3279                  loader will create holes between subspaces *and*
3280                  subspace alignments are *NOT* preserved.  What a crock.  */
3281               subspace_offset = subsection->vma;
3282
3283               /* Only do this for the first subspace within each space.  */
3284               first_subspace = 0;
3285             }
3286           else if (abfd->flags & (EXEC_P | DYNAMIC))
3287             {
3288               /* The braindamaged HPUX loader may have created a hole
3289                  between two subspaces.  It is *not* sufficient to use
3290                  the alignment specifications within the subspaces to
3291                  account for these holes -- I've run into at least one
3292                  case where the loader left one code subspace unaligned
3293                  in a final executable.
3294
3295                  To combat this we keep a current offset within each space,
3296                  and use the subspace vma fields to detect and preserve
3297                  holes.  What a crock!
3298
3299                  ps.  This is not necessary for unloadable space/subspaces.  */
3300               current_offset += subsection->vma - subspace_offset;
3301               if (subsection->flags & SEC_CODE)
3302                 exec_header->exec_tsize += subsection->vma - subspace_offset;
3303               else
3304                 exec_header->exec_dsize += subsection->vma - subspace_offset;
3305               subspace_offset += subsection->vma - subspace_offset;
3306             }
3307
3308
3309           subsection->target_index = total_subspaces++;
3310           /* This is real data to be loaded from the file.  */
3311           if (subsection->flags & SEC_LOAD)
3312             {
3313               /* Update the size of the code & data.  */
3314               if (abfd->flags & (EXEC_P | DYNAMIC)
3315                   && subsection->flags & SEC_CODE)
3316                 exec_header->exec_tsize += subsection->_cooked_size;
3317               else if (abfd->flags & (EXEC_P | DYNAMIC)
3318                        && subsection->flags & SEC_DATA)
3319                 exec_header->exec_dsize += subsection->_cooked_size;
3320               som_section_data (subsection)->subspace_dict->file_loc_init_value
3321                 = current_offset;
3322               subsection->filepos = current_offset;
3323               current_offset += bfd_section_size (abfd, subsection);
3324               subspace_offset += bfd_section_size (abfd, subsection);
3325             }
3326           /* Looks like uninitialized data.  */
3327           else
3328             {
3329               /* Update the size of the bss section.  */
3330               if (abfd->flags & (EXEC_P | DYNAMIC))
3331                 exec_header->exec_bsize += subsection->_cooked_size;
3332
3333               som_section_data (subsection)->subspace_dict->file_loc_init_value
3334                 = 0;
3335               som_section_data (subsection)->subspace_dict->
3336                 initialization_length = 0;
3337             }
3338         }
3339       /* Goto the next section.  */
3340       section = section->next;
3341     }
3342
3343   /* Finally compute the file positions for unloadable subspaces.
3344      If building an executable, start the unloadable stuff on its
3345      own page.  */
3346
3347   if (abfd->flags & (EXEC_P | DYNAMIC))
3348     current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3349
3350   obj_som_file_hdr (abfd)->unloadable_sp_location = current_offset;
3351   section = abfd->sections;
3352   for (i = 0; i < num_spaces; i++)
3353     {
3354       asection *subsection;
3355
3356       /* Find a space.  */
3357       while (!som_is_space (section))
3358         section = section->next;
3359
3360       if (abfd->flags & (EXEC_P | DYNAMIC))
3361         current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3362
3363       /* Now look for all its subspaces.  */
3364       for (subsection = abfd->sections;
3365            subsection != NULL;
3366            subsection = subsection->next)
3367         {
3368
3369           if (!som_is_subspace (subsection)
3370               || !som_is_container (section, subsection)
3371               || (subsection->flags & SEC_ALLOC) != 0)
3372             continue;
3373
3374           subsection->target_index = total_subspaces++;
3375           /* This is real data to be loaded from the file.  */
3376           if ((subsection->flags & SEC_LOAD) == 0)
3377             {
3378               som_section_data (subsection)->subspace_dict->file_loc_init_value
3379                 = current_offset;
3380               subsection->filepos = current_offset;
3381               current_offset += bfd_section_size (abfd, subsection);
3382             }
3383           /* Looks like uninitialized data.  */
3384           else
3385             {
3386               som_section_data (subsection)->subspace_dict->file_loc_init_value
3387                 = 0;
3388               som_section_data (subsection)->subspace_dict->
3389                 initialization_length = bfd_section_size (abfd, subsection);
3390             }
3391         }
3392       /* Goto the next section.  */
3393       section = section->next;
3394     }
3395
3396   /* If building an executable, then make sure to seek to and write
3397      one byte at the end of the file to make sure any necessary
3398      zeros are filled in.  Ugh.  */
3399   if (abfd->flags & (EXEC_P | DYNAMIC))
3400     current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
3401   if (bfd_seek (abfd, current_offset - 1, SEEK_SET) < 0)
3402     return false;
3403   if (bfd_write ((PTR) "", 1, 1, abfd) != 1)
3404     return false;
3405
3406   obj_som_file_hdr (abfd)->unloadable_sp_size
3407     = current_offset - obj_som_file_hdr (abfd)->unloadable_sp_location;
3408
3409   /* Loader fixups are not supported in any way shape or form.  */
3410   obj_som_file_hdr (abfd)->loader_fixup_location = 0;
3411   obj_som_file_hdr (abfd)->loader_fixup_total = 0;
3412
3413   /* Done.  Store the total size of the SOM so far.  */
3414   obj_som_file_hdr (abfd)->som_length = current_offset;
3415
3416   return true;
3417 }
3418
3419 /* Finally, scribble out the various headers to the disk.  */
3420
3421 static boolean
3422 som_finish_writing (abfd)
3423      bfd *abfd;
3424 {
3425   int num_spaces = som_count_spaces (abfd);
3426   asymbol **syms = bfd_get_outsymbols (abfd);
3427   int i, num_syms, strings_size;
3428   int subspace_index = 0;
3429   file_ptr location;
3430   asection *section;
3431   unsigned long current_offset;
3432   unsigned int total_reloc_size;
3433
3434   /* Next is the symbol table.  These are fixed length records.
3435
3436      Count the number of symbols to determine how much room is needed
3437      in the object file for the symbol table.
3438
3439      The names of the symbols are stored in a separate string table,
3440      and the index for each symbol name into the string table is computed
3441      below.  Therefore, it is not possible to write the symbol table
3442      at this time.
3443
3444      These used to be output before the subspace contents, but they
3445      were moved here to work around a stupid bug in the hpux linker
3446      (fixed in hpux10).  */
3447   current_offset = obj_som_file_hdr (abfd)->som_length;
3448
3449   /* Make sure we're on a word boundary.  */
3450   if (current_offset % 4)
3451     current_offset += (4 - (current_offset % 4));
3452
3453   num_syms = bfd_get_symcount (abfd);
3454   obj_som_file_hdr (abfd)->symbol_location = current_offset;
3455   obj_som_file_hdr (abfd)->symbol_total = num_syms;
3456   current_offset += num_syms * sizeof (struct symbol_dictionary_record);
3457
3458   /* Next are the symbol strings.
3459      Align them to a word boundary.  */
3460   if (current_offset % 4)
3461     current_offset += (4 - (current_offset % 4));
3462   obj_som_file_hdr (abfd)->symbol_strings_location = current_offset;
3463
3464   /* Scribble out the symbol strings.  */
3465   if (som_write_symbol_strings (abfd, current_offset, syms,
3466                                 num_syms, &strings_size)
3467       == false)
3468     return false;
3469
3470   /* Record total string table size in header and update the
3471      current offset.  */
3472   obj_som_file_hdr (abfd)->symbol_strings_size = strings_size;
3473   current_offset += strings_size;
3474
3475   /* Do prep work before handling fixups.  */
3476   som_prep_for_fixups (abfd,
3477                        bfd_get_outsymbols (abfd),
3478                        bfd_get_symcount (abfd));
3479
3480   /* At the end of the file is the fixup stream which starts on a
3481      word boundary.  */
3482   if (current_offset % 4)
3483     current_offset += (4 - (current_offset % 4));
3484   obj_som_file_hdr (abfd)->fixup_request_location = current_offset;
3485
3486   /* Write the fixups and update fields in subspace headers which
3487      relate to the fixup stream.  */
3488   if (som_write_fixups (abfd, current_offset, &total_reloc_size) == false)
3489     return false;
3490
3491   /* Record the total size of the fixup stream in the file header.  */
3492   obj_som_file_hdr (abfd)->fixup_request_total = total_reloc_size;
3493
3494   /* Done.  Store the total size of the SOM.  */
3495   obj_som_file_hdr (abfd)->som_length = current_offset + total_reloc_size;
3496
3497   /* Now that the symbol table information is complete, build and
3498      write the symbol table.  */
3499   if (som_build_and_write_symbol_table (abfd) == false)
3500     return false;
3501
3502   /* Subspaces are written first so that we can set up information
3503      about them in their containing spaces as the subspace is written.  */
3504
3505   /* Seek to the start of the subspace dictionary records.  */
3506   location = obj_som_file_hdr (abfd)->subspace_location;
3507   if (bfd_seek (abfd, location, SEEK_SET) < 0)
3508     return false;
3509
3510   section = abfd->sections;
3511   /* Now for each loadable space write out records for its subspaces.  */
3512   for (i = 0; i < num_spaces; i++)
3513     {
3514       asection *subsection;
3515
3516       /* Find a space.  */
3517       while (!som_is_space (section))
3518         section = section->next;
3519
3520       /* Now look for all its subspaces.  */
3521       for (subsection = abfd->sections;
3522            subsection != NULL;
3523            subsection = subsection->next)
3524         {
3525
3526           /* Skip any section which does not correspond to a space
3527              or subspace.  Or does not have SEC_ALLOC set (and therefore
3528              has no real bits on the disk).  */
3529           if (!som_is_subspace (subsection)
3530               || !som_is_container (section, subsection)
3531               || (subsection->flags & SEC_ALLOC) == 0)
3532             continue;
3533
3534           /* If this is the first subspace for this space, then save
3535              the index of the subspace in its containing space.  Also
3536              set "is_loadable" in the containing space.  */
3537
3538           if (som_section_data (section)->space_dict->subspace_quantity == 0)
3539             {
3540               som_section_data (section)->space_dict->is_loadable = 1;
3541               som_section_data (section)->space_dict->subspace_index
3542                 = subspace_index;
3543             }
3544
3545           /* Increment the number of subspaces seen and the number of
3546              subspaces contained within the current space.  */
3547           subspace_index++;
3548           som_section_data (section)->space_dict->subspace_quantity++;
3549
3550           /* Mark the index of the current space within the subspace's
3551              dictionary record.  */
3552           som_section_data (subsection)->subspace_dict->space_index = i;
3553
3554           /* Dump the current subspace header.  */
3555           if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
3556                          sizeof (struct subspace_dictionary_record), 1, abfd)
3557               != sizeof (struct subspace_dictionary_record))
3558             return false;
3559         }
3560       /* Goto the next section.  */
3561       section = section->next;
3562     }
3563
3564   /* Now repeat the process for unloadable subspaces.  */
3565   section = abfd->sections;
3566   /* Now for each space write out records for its subspaces.  */
3567   for (i = 0; i < num_spaces; i++)
3568     {
3569       asection *subsection;
3570
3571       /* Find a space.  */
3572       while (!som_is_space (section))
3573         section = section->next;
3574
3575       /* Now look for all its subspaces.  */
3576       for (subsection = abfd->sections;
3577            subsection != NULL;
3578            subsection = subsection->next)
3579         {
3580
3581           /* Skip any section which does not correspond to a space or
3582              subspace, or which SEC_ALLOC set (and therefore handled
3583              in the loadable spaces/subspaces code above).  */
3584
3585           if (!som_is_subspace (subsection)
3586               || !som_is_container (section, subsection)
3587               || (subsection->flags & SEC_ALLOC) != 0)
3588             continue;
3589
3590           /* If this is the first subspace for this space, then save
3591              the index of the subspace in its containing space.  Clear
3592              "is_loadable".  */
3593
3594           if (som_section_data (section)->space_dict->subspace_quantity == 0)
3595             {
3596               som_section_data (section)->space_dict->is_loadable = 0;
3597               som_section_data (section)->space_dict->subspace_index
3598                 = subspace_index;
3599             }
3600
3601           /* Increment the number of subspaces seen and the number of
3602              subspaces contained within the current space.  */
3603           som_section_data (section)->space_dict->subspace_quantity++;
3604           subspace_index++;
3605
3606           /* Mark the index of the current space within the subspace's
3607              dictionary record.  */
3608           som_section_data (subsection)->subspace_dict->space_index = i;
3609
3610           /* Dump this subspace header.  */
3611           if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
3612                          sizeof (struct subspace_dictionary_record), 1, abfd)
3613               != sizeof (struct subspace_dictionary_record))
3614             return false;
3615         }
3616       /* Goto the next section.  */
3617       section = section->next;
3618     }
3619
3620   /* All the subspace dictiondary records are written, and all the
3621      fields are set up in the space dictionary records.
3622
3623      Seek to the right location and start writing the space
3624      dictionary records.  */
3625   location = obj_som_file_hdr (abfd)->space_location;
3626   if (bfd_seek (abfd, location, SEEK_SET) < 0)
3627     return false;
3628
3629   section = abfd->sections;
3630   for (i = 0; i < num_spaces; i++)
3631     {
3632
3633       /* Find a space.  */
3634       while (!som_is_space (section))
3635         section = section->next;
3636
3637       /* Dump its header  */
3638       if (bfd_write ((PTR) som_section_data (section)->space_dict,
3639                      sizeof (struct space_dictionary_record), 1, abfd)
3640           != sizeof (struct space_dictionary_record))
3641         return false;
3642
3643       /* Goto the next section.  */
3644       section = section->next;
3645     }
3646
3647   /* Setting of the system_id has to happen very late now that copying of
3648      BFD private data happens *after* section contents are set.  */
3649   if (abfd->flags & (EXEC_P | DYNAMIC))
3650     obj_som_file_hdr(abfd)->system_id = obj_som_exec_data (abfd)->system_id;
3651   else if (bfd_get_mach (abfd) == pa11)
3652     obj_som_file_hdr(abfd)->system_id = CPU_PA_RISC1_1;
3653   else
3654     obj_som_file_hdr(abfd)->system_id = CPU_PA_RISC1_0;
3655
3656   /* Compute the checksum for the file header just before writing
3657      the header to disk.  */
3658   obj_som_file_hdr (abfd)->checksum = som_compute_checksum (abfd);
3659
3660   /* Only thing left to do is write out the file header.  It is always
3661      at location zero.  Seek there and write it.  */
3662   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) < 0)
3663     return false;
3664   if (bfd_write ((PTR) obj_som_file_hdr (abfd),
3665                  sizeof (struct header), 1, abfd)
3666       != sizeof (struct header))
3667     return false;
3668
3669   /* Now write the exec header.  */
3670   if (abfd->flags & (EXEC_P | DYNAMIC))
3671     {
3672       long tmp;
3673       struct som_exec_auxhdr *exec_header;
3674
3675       exec_header = obj_som_exec_hdr (abfd);
3676       exec_header->exec_entry = bfd_get_start_address (abfd);
3677       exec_header->exec_flags = obj_som_exec_data (abfd)->exec_flags;
3678
3679       /* Oh joys.  Ram some of the BSS data into the DATA section
3680          to be compatable with how the hp linker makes objects
3681          (saves memory space).  */
3682       tmp = exec_header->exec_dsize;
3683       tmp = SOM_ALIGN (tmp, PA_PAGESIZE);
3684       exec_header->exec_bsize -= (tmp - exec_header->exec_dsize);
3685       if (exec_header->exec_bsize < 0)
3686         exec_header->exec_bsize = 0;
3687       exec_header->exec_dsize = tmp;
3688
3689       if (bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location,
3690                     SEEK_SET) < 0)
3691         return false;
3692
3693       if (bfd_write ((PTR) exec_header, AUX_HDR_SIZE, 1, abfd)
3694           != AUX_HDR_SIZE)
3695         return false;
3696     }
3697   return true;
3698 }
3699
3700 /* Compute and return the checksum for a SOM file header.  */
3701
3702 static unsigned long
3703 som_compute_checksum (abfd)
3704      bfd *abfd;
3705 {
3706   unsigned long checksum, count, i;
3707   unsigned long *buffer = (unsigned long *) obj_som_file_hdr (abfd);
3708
3709   checksum = 0;
3710   count = sizeof (struct header) / sizeof (unsigned long);
3711   for (i = 0; i < count; i++)
3712     checksum ^= *(buffer + i);
3713
3714   return checksum;
3715 }
3716
3717 static void
3718 som_bfd_derive_misc_symbol_info (abfd, sym, info)
3719      bfd *abfd;
3720      asymbol *sym;
3721      struct som_misc_symbol_info *info;
3722 {
3723   /* Initialize.  */
3724   memset (info, 0, sizeof (struct som_misc_symbol_info));
3725
3726   /* The HP SOM linker requires detailed type information about
3727      all symbols (including undefined symbols!).  Unfortunately,
3728      the type specified in an import/export statement does not
3729      always match what the linker wants.  Severe braindamage.  */
3730
3731   /* Section symbols will not have a SOM symbol type assigned to
3732      them yet.  Assign all section symbols type ST_DATA.  */
3733   if (sym->flags & BSF_SECTION_SYM)
3734     info->symbol_type = ST_DATA;
3735   else
3736     {
3737       /* Common symbols must have scope SS_UNSAT and type
3738          ST_STORAGE or the linker will choke.  */
3739       if (bfd_is_com_section (sym->section))
3740         {
3741           info->symbol_scope = SS_UNSAT;
3742           info->symbol_type = ST_STORAGE;
3743         }
3744
3745       /* It is possible to have a symbol without an associated
3746          type.  This happens if the user imported the symbol
3747          without a type and the symbol was never defined
3748          locally.  If BSF_FUNCTION is set for this symbol, then
3749          assign it type ST_CODE (the HP linker requires undefined
3750          external functions to have type ST_CODE rather than ST_ENTRY).  */
3751       else if ((som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN
3752                 || som_symbol_data (sym)->som_type == SYMBOL_TYPE_CODE)
3753                && bfd_is_und_section (sym->section)
3754                && sym->flags & BSF_FUNCTION)
3755         info->symbol_type = ST_CODE;
3756
3757       /* Handle function symbols which were defined in this file.
3758          They should have type ST_ENTRY.  Also retrieve the argument
3759          relocation bits from the SOM backend information.  */
3760       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_ENTRY
3761                || (som_symbol_data (sym)->som_type == SYMBOL_TYPE_CODE
3762                    && (sym->flags & BSF_FUNCTION))
3763                || (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN
3764                    && (sym->flags & BSF_FUNCTION)))
3765         {
3766           info->symbol_type = ST_ENTRY;
3767           info->arg_reloc = som_symbol_data (sym)->tc_data.hppa_arg_reloc;
3768         }
3769
3770       /* For unknown symbols set the symbol's type based on the symbol's
3771          section (ST_DATA for DATA sections, ST_CODE for CODE sections).  */
3772       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN)
3773         {
3774           if (sym->section->flags & SEC_CODE)
3775             info->symbol_type = ST_CODE;
3776           else
3777             info->symbol_type = ST_DATA;
3778         }
3779
3780       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_UNKNOWN)
3781         info->symbol_type = ST_DATA;
3782
3783       /* From now on it's a very simple mapping.  */
3784       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_ABSOLUTE)
3785         info->symbol_type = ST_ABSOLUTE;
3786       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_CODE)
3787         info->symbol_type = ST_CODE;
3788       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_DATA)
3789         info->symbol_type = ST_DATA;
3790       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_MILLICODE)
3791         info->symbol_type = ST_MILLICODE;
3792       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_PLABEL)
3793         info->symbol_type = ST_PLABEL;
3794       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_PRI_PROG)
3795         info->symbol_type = ST_PRI_PROG;
3796       else if (som_symbol_data (sym)->som_type == SYMBOL_TYPE_SEC_PROG)
3797         info->symbol_type = ST_SEC_PROG;
3798     }
3799
3800   /* Now handle the symbol's scope.  Exported data which is not
3801      in the common section has scope SS_UNIVERSAL.  Note scope
3802      of common symbols was handled earlier!  */
3803   if (bfd_is_und_section (sym->section))
3804     info->symbol_scope = SS_UNSAT;
3805   else if (sym->flags & BSF_EXPORT && ! bfd_is_com_section (sym->section))
3806     info->symbol_scope = SS_UNIVERSAL;
3807   /* Anything else which is not in the common section has scope
3808      SS_LOCAL.  */
3809   else if (! bfd_is_com_section (sym->section))
3810     info->symbol_scope = SS_LOCAL;
3811
3812   /* Now set the symbol_info field.  It has no real meaning
3813      for undefined or common symbols, but the HP linker will
3814      choke if it's not set to some "reasonable" value.  We
3815      use zero as a reasonable value.  */
3816   if (bfd_is_com_section (sym->section)
3817       || bfd_is_und_section (sym->section)
3818       || bfd_is_abs_section (sym->section))
3819     info->symbol_info = 0;
3820   /* For all other symbols, the symbol_info field contains the
3821      subspace index of the space this symbol is contained in.  */
3822   else
3823     info->symbol_info = sym->section->target_index;
3824
3825   /* Set the symbol's value.  */
3826   info->symbol_value = sym->value + sym->section->vma;
3827 }
3828
3829 /* Build and write, in one big chunk, the entire symbol table for
3830    this BFD.  */
3831
3832 static boolean
3833 som_build_and_write_symbol_table (abfd)
3834      bfd *abfd;
3835 {
3836   unsigned int num_syms = bfd_get_symcount (abfd);
3837   file_ptr symtab_location = obj_som_file_hdr (abfd)->symbol_location;
3838   asymbol **bfd_syms = obj_som_sorted_syms (abfd);
3839   struct symbol_dictionary_record *som_symtab = NULL;
3840   int i, symtab_size;
3841
3842   /* Compute total symbol table size and allocate a chunk of memory
3843      to hold the symbol table as we build it.  */
3844   symtab_size = num_syms * sizeof (struct symbol_dictionary_record);
3845   som_symtab = (struct symbol_dictionary_record *) bfd_malloc (symtab_size);
3846   if (som_symtab == NULL && symtab_size != 0)
3847     goto error_return;
3848   memset (som_symtab, 0, symtab_size);
3849
3850   /* Walk over each symbol.  */
3851   for (i = 0; i < num_syms; i++)
3852     {
3853       struct som_misc_symbol_info info;
3854
3855       /* This is really an index into the symbol strings table.
3856          By the time we get here, the index has already been
3857          computed and stored into the name field in the BFD symbol.  */
3858       som_symtab[i].name.n_strx = som_symbol_data(bfd_syms[i])->stringtab_offset;
3859
3860       /* Derive SOM information from the BFD symbol.  */
3861       som_bfd_derive_misc_symbol_info (abfd, bfd_syms[i], &info);
3862
3863       /* Now use it.  */
3864       som_symtab[i].symbol_type = info.symbol_type;
3865       som_symtab[i].symbol_scope = info.symbol_scope;
3866       som_symtab[i].arg_reloc = info.arg_reloc;
3867       som_symtab[i].symbol_info = info.symbol_info;
3868       som_symtab[i].symbol_value = info.symbol_value;
3869     }
3870
3871   /* Everything is ready, seek to the right location and
3872      scribble out the symbol table.  */
3873   if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0)
3874     return false;
3875
3876   if (bfd_write ((PTR) som_symtab, symtab_size, 1, abfd) != symtab_size)
3877     goto error_return;
3878
3879   if (som_symtab != NULL)
3880     free (som_symtab);
3881   return true;
3882  error_return:
3883   if (som_symtab != NULL)
3884     free (som_symtab);
3885   return false;
3886 }
3887
3888 /* Write an object in SOM format.  */
3889
3890 static boolean
3891 som_write_object_contents (abfd)
3892      bfd *abfd;
3893 {
3894   if (abfd->output_has_begun == false)
3895     {
3896       /* Set up fixed parts of the file, space, and subspace headers.
3897          Notify the world that output has begun.  */
3898       som_prep_headers (abfd);
3899       abfd->output_has_begun = true;
3900       /* Start writing the object file.  This include all the string
3901          tables, fixup streams, and other portions of the object file.  */
3902       som_begin_writing (abfd);
3903     }
3904
3905   return (som_finish_writing (abfd));
3906 }
3907
3908 \f
3909 /* Read and save the string table associated with the given BFD.  */
3910
3911 static boolean
3912 som_slurp_string_table (abfd)
3913      bfd *abfd;
3914 {
3915   char *stringtab;
3916
3917   /* Use the saved version if its available.  */
3918   if (obj_som_stringtab (abfd) != NULL)
3919     return true;
3920
3921   /* I don't think this can currently happen, and I'm not sure it should
3922      really be an error, but it's better than getting unpredictable results
3923      from the host's malloc when passed a size of zero.  */
3924   if (obj_som_stringtab_size (abfd) == 0)
3925     {
3926       bfd_set_error (bfd_error_no_symbols);
3927       return false;
3928     }
3929
3930   /* Allocate and read in the string table.  */
3931   stringtab = bfd_malloc (obj_som_stringtab_size (abfd));
3932   if (stringtab == NULL)
3933     return false;
3934   memset (stringtab, 0, obj_som_stringtab_size (abfd));
3935
3936   if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
3937     return false;
3938
3939   if (bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd)
3940       != obj_som_stringtab_size (abfd))
3941     return false;
3942
3943   /* Save our results and return success. */
3944   obj_som_stringtab (abfd) = stringtab;
3945   return true;
3946 }
3947
3948 /* Return the amount of data (in bytes) required to hold the symbol
3949    table for this object.  */
3950
3951 static long
3952 som_get_symtab_upper_bound (abfd)
3953      bfd *abfd;
3954 {
3955   if (!som_slurp_symbol_table (abfd))
3956     return -1;
3957
3958   return (bfd_get_symcount (abfd) + 1) * (sizeof (asymbol *));
3959 }
3960
3961 /* Convert from a SOM subspace index to a BFD section.  */
3962
3963 static asection *
3964 bfd_section_from_som_symbol (abfd, symbol)
3965      bfd *abfd;
3966      struct symbol_dictionary_record *symbol;
3967 {
3968   asection *section;
3969
3970   /* The meaning of the symbol_info field changes for functions
3971      within executables.  So only use the quick symbol_info mapping for
3972      incomplete objects and non-function symbols in executables.  */
3973   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3974       || (symbol->symbol_type != ST_ENTRY
3975           && symbol->symbol_type != ST_PRI_PROG
3976           && symbol->symbol_type != ST_SEC_PROG
3977           && symbol->symbol_type != ST_MILLICODE))
3978     {
3979       unsigned int index = symbol->symbol_info;
3980       for (section = abfd->sections; section != NULL; section = section->next)
3981         if (section->target_index == index && som_is_subspace (section))
3982           return section;
3983
3984       /* Could be a symbol from an external library (such as an OMOS
3985          shared library).  Don't abort.  */
3986       return bfd_abs_section_ptr;
3987
3988     }
3989   else
3990     {
3991       unsigned int value = symbol->symbol_value;
3992
3993       /* For executables we will have to use the symbol's address and
3994          find out what section would contain that address.   Yuk.  */
3995       for (section = abfd->sections; section; section = section->next)
3996         {
3997           if (value >= section->vma
3998               && value <= section->vma + section->_cooked_size
3999               && som_is_subspace (section))
4000             return section;
4001         }
4002
4003       /* Could be a symbol from an external library (such as an OMOS
4004          shared library).  Don't abort.  */
4005       return bfd_abs_section_ptr;
4006
4007     }
4008 }
4009
4010 /* Read and save the symbol table associated with the given BFD.  */
4011
4012 static unsigned int
4013 som_slurp_symbol_table (abfd)
4014      bfd *abfd;
4015 {
4016   int symbol_count = bfd_get_symcount (abfd);
4017   int symsize = sizeof (struct symbol_dictionary_record);
4018   char *stringtab;
4019   struct symbol_dictionary_record *buf = NULL, *bufp, *endbufp;
4020   som_symbol_type *sym, *symbase;
4021
4022   /* Return saved value if it exists.  */
4023   if (obj_som_symtab (abfd) != NULL)
4024     goto successful_return;
4025
4026   /* Special case.  This is *not* an error.  */
4027   if (symbol_count == 0)
4028     goto successful_return;
4029
4030   if (!som_slurp_string_table (abfd))
4031     goto error_return;
4032
4033   stringtab = obj_som_stringtab (abfd);
4034
4035   symbase = ((som_symbol_type *)
4036              bfd_malloc (symbol_count * sizeof (som_symbol_type)));
4037   if (symbase == NULL)
4038     goto error_return;
4039   memset (symbase, 0, symbol_count * sizeof (som_symbol_type));
4040
4041   /* Read in the external SOM representation.  */
4042   buf = bfd_malloc (symbol_count * symsize);
4043   if (buf == NULL && symbol_count * symsize != 0)
4044     goto error_return;
4045   if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
4046     goto error_return;
4047   if (bfd_read (buf, symbol_count * symsize, 1, abfd)
4048       != symbol_count * symsize)
4049     goto error_return;
4050
4051   /* Iterate over all the symbols and internalize them.  */
4052   endbufp = buf + symbol_count;
4053   for (bufp = buf, sym = symbase; bufp < endbufp; ++bufp)
4054     {
4055
4056       /* I don't think we care about these.  */
4057       if (bufp->symbol_type == ST_SYM_EXT
4058           || bufp->symbol_type == ST_ARG_EXT)
4059         continue;
4060
4061       /* Set some private data we care about.  */
4062       if (bufp->symbol_type == ST_NULL)
4063         som_symbol_data (sym)->som_type = SYMBOL_TYPE_UNKNOWN;
4064       else if (bufp->symbol_type == ST_ABSOLUTE)
4065         som_symbol_data (sym)->som_type = SYMBOL_TYPE_ABSOLUTE;
4066       else if (bufp->symbol_type == ST_DATA)
4067         som_symbol_data (sym)->som_type = SYMBOL_TYPE_DATA;
4068       else if (bufp->symbol_type == ST_CODE)
4069         som_symbol_data (sym)->som_type = SYMBOL_TYPE_CODE;
4070       else if (bufp->symbol_type == ST_PRI_PROG)
4071         som_symbol_data (sym)->som_type = SYMBOL_TYPE_PRI_PROG;
4072       else if (bufp->symbol_type == ST_SEC_PROG)
4073         som_symbol_data (sym)->som_type = SYMBOL_TYPE_SEC_PROG;
4074       else if (bufp->symbol_type == ST_ENTRY)
4075         som_symbol_data (sym)->som_type = SYMBOL_TYPE_ENTRY;
4076       else if (bufp->symbol_type == ST_MILLICODE)
4077         som_symbol_data (sym)->som_type = SYMBOL_TYPE_MILLICODE;
4078       else if (bufp->symbol_type == ST_PLABEL)
4079         som_symbol_data (sym)->som_type = SYMBOL_TYPE_PLABEL;
4080       else
4081         som_symbol_data (sym)->som_type = SYMBOL_TYPE_UNKNOWN;
4082       som_symbol_data (sym)->tc_data.hppa_arg_reloc = bufp->arg_reloc;
4083
4084       /* Some reasonable defaults.  */
4085       sym->symbol.the_bfd = abfd;
4086       sym->symbol.name = bufp->name.n_strx + stringtab;
4087       sym->symbol.value = bufp->symbol_value;
4088       sym->symbol.section = 0;
4089       sym->symbol.flags = 0;
4090
4091       switch (bufp->symbol_type)
4092         {
4093         case ST_ENTRY:
4094         case ST_MILLICODE:
4095           sym->symbol.flags |= BSF_FUNCTION;
4096           sym->symbol.value &= ~0x3;
4097           break;
4098
4099         case ST_STUB:
4100         case ST_CODE:
4101         case ST_PRI_PROG:
4102         case ST_SEC_PROG:
4103           sym->symbol.value &= ~0x3;
4104           /* If the symbol's scope is ST_UNSAT, then these are
4105              undefined function symbols.  */
4106           if (bufp->symbol_scope == SS_UNSAT)
4107             sym->symbol.flags |= BSF_FUNCTION;
4108
4109
4110         default:
4111           break;
4112         }
4113
4114       /* Handle scoping and section information.  */
4115       switch (bufp->symbol_scope)
4116         {
4117         /* symbol_info field is undefined for SS_EXTERNAL and SS_UNSAT symbols,
4118            so the section associated with this symbol can't be known.  */
4119         case SS_EXTERNAL:
4120           if (bufp->symbol_type != ST_STORAGE)
4121             sym->symbol.section = bfd_und_section_ptr;
4122           else
4123             sym->symbol.section = bfd_com_section_ptr;
4124           sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
4125           break;
4126
4127         case SS_UNSAT:
4128           if (bufp->symbol_type != ST_STORAGE)
4129             sym->symbol.section = bfd_und_section_ptr;
4130           else
4131             sym->symbol.section = bfd_com_section_ptr;
4132           break;
4133
4134         case SS_UNIVERSAL:
4135           sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
4136           sym->symbol.section = bfd_section_from_som_symbol (abfd, bufp);
4137           sym->symbol.value -= sym->symbol.section->vma;
4138           break;
4139
4140 #if 0
4141         /* SS_GLOBAL and SS_LOCAL are two names for the same thing.
4142            Sound dumb?  It is.  */
4143         case SS_GLOBAL:
4144 #endif
4145         case SS_LOCAL:
4146           sym->symbol.flags |= BSF_LOCAL;
4147           sym->symbol.section = bfd_section_from_som_symbol (abfd, bufp);
4148           sym->symbol.value -= sym->symbol.section->vma;
4149           break;
4150         }
4151
4152       /* Mark section symbols and symbols used by the debugger.
4153          Note $START$ is a magic code symbol, NOT a section symbol.  */
4154       if (sym->symbol.name[0] == '$'
4155           && sym->symbol.name[strlen (sym->symbol.name) - 1] == '$'
4156           && !strcmp (sym->symbol.name, sym->symbol.section->name))
4157         sym->symbol.flags |= BSF_SECTION_SYM;
4158       else if (!strncmp (sym->symbol.name, "L$0\002", 4))
4159         {
4160           sym->symbol.flags |= BSF_SECTION_SYM;
4161           sym->symbol.name = sym->symbol.section->name;
4162         }
4163       else if (!strncmp (sym->symbol.name, "L$0\001", 4))
4164         sym->symbol.flags |= BSF_DEBUGGING;
4165
4166       /* Note increment at bottom of loop, since we skip some symbols
4167          we can not include it as part of the for statement.  */
4168       sym++;
4169     }
4170
4171   /* We modify the symbol count to record the number of BFD symbols we
4172      created.  */
4173   bfd_get_symcount (abfd) = sym - symbase;
4174
4175   /* Save our results and return success.  */
4176   obj_som_symtab (abfd) = symbase;
4177  successful_return:
4178   if (buf != NULL)
4179     free (buf);
4180   return (true);
4181
4182  error_return:
4183   if (buf != NULL)
4184     free (buf);
4185   return false;
4186 }
4187
4188 /* Canonicalize a SOM symbol table.  Return the number of entries
4189    in the symbol table.  */
4190
4191 static long
4192 som_get_symtab (abfd, location)
4193      bfd *abfd;
4194      asymbol **location;
4195 {
4196   int i;
4197   som_symbol_type *symbase;
4198
4199   if (!som_slurp_symbol_table (abfd))
4200     return -1;
4201
4202   i = bfd_get_symcount (abfd);
4203   symbase = obj_som_symtab (abfd);
4204
4205   for (; i > 0; i--, location++, symbase++)
4206     *location = &symbase->symbol;
4207
4208   /* Final null pointer.  */
4209   *location = 0;
4210   return (bfd_get_symcount (abfd));
4211 }
4212
4213 /* Make a SOM symbol.  There is nothing special to do here.  */
4214
4215 static asymbol *
4216 som_make_empty_symbol (abfd)
4217      bfd *abfd;
4218 {
4219   som_symbol_type *new =
4220   (som_symbol_type *) bfd_zalloc (abfd, sizeof (som_symbol_type));
4221   if (new == NULL)
4222     return 0;
4223   new->symbol.the_bfd = abfd;
4224
4225   return &new->symbol;
4226 }
4227
4228 /* Print symbol information.  */
4229
4230 static void
4231 som_print_symbol (ignore_abfd, afile, symbol, how)
4232      bfd *ignore_abfd;
4233      PTR afile;
4234      asymbol *symbol;
4235      bfd_print_symbol_type how;
4236 {
4237   FILE *file = (FILE *) afile;
4238   switch (how)
4239     {
4240     case bfd_print_symbol_name:
4241       fprintf (file, "%s", symbol->name);
4242       break;
4243     case bfd_print_symbol_more:
4244       fprintf (file, "som ");
4245       fprintf_vma (file, symbol->value);
4246       fprintf (file, " %lx", (long) symbol->flags);
4247       break;
4248     case bfd_print_symbol_all:
4249       {
4250         CONST char *section_name;
4251         section_name = symbol->section ? symbol->section->name : "(*none*)";
4252         bfd_print_symbol_vandf ((PTR) file, symbol);
4253         fprintf (file, " %s\t%s", section_name, symbol->name);
4254         break;
4255       }
4256     }
4257 }
4258
4259 static boolean
4260 som_bfd_is_local_label_name (abfd, name)
4261      bfd *abfd;
4262      const char *name;
4263 {
4264   return (name[0] == 'L' && name[1] == '$');
4265 }
4266
4267 /* Count or process variable-length SOM fixup records.
4268
4269    To avoid code duplication we use this code both to compute the number
4270    of relocations requested by a stream, and to internalize the stream.
4271
4272    When computing the number of relocations requested by a stream the
4273    variables rptr, section, and symbols have no meaning.
4274
4275    Return the number of relocations requested by the fixup stream.  When
4276    not just counting
4277
4278    This needs at least two or three more passes to get it cleaned up.  */
4279
4280 static unsigned int
4281 som_set_reloc_info (fixup, end, internal_relocs, section, symbols, just_count)
4282      unsigned char *fixup;
4283      unsigned int end;
4284      arelent *internal_relocs;
4285      asection *section;
4286      asymbol **symbols;
4287      boolean just_count;
4288 {
4289   unsigned int op, varname, deallocate_contents = 0;
4290   unsigned char *end_fixups = &fixup[end];
4291   const struct fixup_format *fp;
4292   char *cp;
4293   unsigned char *save_fixup;
4294   int variables[26], stack[20], c, v, count, prev_fixup, *sp, saved_unwind_bits;
4295   const int *subop;
4296   arelent *rptr= internal_relocs;
4297   unsigned int offset = 0;
4298
4299 #define var(c)          variables[(c) - 'A']
4300 #define push(v)         (*sp++ = (v))
4301 #define pop()           (*--sp)
4302 #define emptystack()    (sp == stack)
4303
4304   som_initialize_reloc_queue (reloc_queue);
4305   memset (variables, 0, sizeof (variables));
4306   memset (stack, 0, sizeof (stack));
4307   count = 0;
4308   prev_fixup = 0;
4309   saved_unwind_bits = 0;
4310   sp = stack;
4311
4312   while (fixup < end_fixups)
4313     {
4314
4315       /* Save pointer to the start of this fixup.  We'll use
4316          it later to determine if it is necessary to put this fixup
4317          on the queue.  */
4318       save_fixup = fixup;
4319
4320       /* Get the fixup code and its associated format.  */
4321       op = *fixup++;
4322       fp = &som_fixup_formats[op];
4323
4324       /* Handle a request for a previous fixup.  */
4325       if (*fp->format == 'P')
4326         {
4327           /* Get pointer to the beginning of the prev fixup, move
4328              the repeated fixup to the head of the queue.  */
4329           fixup = reloc_queue[fp->D].reloc;
4330           som_reloc_queue_fix (reloc_queue, fp->D);
4331           prev_fixup = 1;
4332
4333           /* Get the fixup code and its associated format.  */
4334           op = *fixup++;
4335           fp = &som_fixup_formats[op];
4336         }
4337
4338       /* If this fixup will be passed to BFD, set some reasonable defaults.  */
4339       if (! just_count
4340           && som_hppa_howto_table[op].type != R_NO_RELOCATION
4341           && som_hppa_howto_table[op].type != R_DATA_OVERRIDE)
4342         {
4343           rptr->address = offset;
4344           rptr->howto = &som_hppa_howto_table[op];
4345           rptr->addend = 0;
4346           rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4347         }
4348
4349       /* Set default input length to 0.  Get the opcode class index
4350          into D.  */
4351       var ('L') = 0;
4352       var ('D') = fp->D;
4353       var ('U') = saved_unwind_bits;
4354
4355       /* Get the opcode format.  */
4356       cp = fp->format;
4357
4358       /* Process the format string.  Parsing happens in two phases,
4359          parse RHS, then assign to LHS.  Repeat until no more
4360          characters in the format string.  */
4361       while (*cp)
4362         {
4363           /* The variable this pass is going to compute a value for.  */
4364           varname = *cp++;
4365
4366           /* Start processing RHS.  Continue until a NULL or '=' is found.  */
4367           do
4368             {
4369               c = *cp++;
4370
4371               /* If this is a variable, push it on the stack.  */
4372               if (isupper (c))
4373                 push (var (c));
4374
4375               /* If this is a lower case letter, then it represents
4376                  additional data from the fixup stream to be pushed onto
4377                  the stack.  */
4378               else if (islower (c))
4379                 {
4380                   int bits = (c - 'a') * 8;
4381                   for (v = 0; c > 'a'; --c)
4382                     v = (v << 8) | *fixup++;
4383                   if (varname == 'V')
4384                     v = sign_extend (v, bits);
4385                   push (v);
4386                 }
4387
4388               /* A decimal constant.  Push it on the stack.  */
4389               else if (isdigit (c))
4390                 {
4391                   v = c - '0';
4392                   while (isdigit (*cp))
4393                     v = (v * 10) + (*cp++ - '0');
4394                   push (v);
4395                 }
4396               else
4397
4398                 /* An operator.  Pop two two values from the stack and
4399                    use them as operands to the given operation.  Push
4400                    the result of the operation back on the stack.  */
4401                 switch (c)
4402                   {
4403                   case '+':
4404                     v = pop ();
4405                     v += pop ();
4406                     push (v);
4407                     break;
4408                   case '*':
4409                     v = pop ();
4410                     v *= pop ();
4411                     push (v);
4412                     break;
4413                   case '<':
4414                     v = pop ();
4415                     v = pop () << v;
4416                     push (v);
4417                     break;
4418                   default:
4419                     abort ();
4420                   }
4421             }
4422           while (*cp && *cp != '=');
4423
4424           /* Move over the equal operator.  */
4425           cp++;
4426
4427           /* Pop the RHS off the stack.  */
4428           c = pop ();
4429
4430           /* Perform the assignment.  */
4431           var (varname) = c;
4432
4433           /* Handle side effects. and special 'O' stack cases.  */
4434           switch (varname)
4435             {
4436             /* Consume some bytes from the input space.  */
4437             case 'L':
4438               offset += c;
4439               break;
4440             /* A symbol to use in the relocation.  Make a note
4441                of this if we are not just counting.  */
4442             case 'S':
4443               if (! just_count)
4444                 rptr->sym_ptr_ptr = &symbols[c];
4445               break;
4446             /* Argument relocation bits for a function call.  */
4447             case 'R':
4448               if (! just_count)
4449                 {
4450                   unsigned int tmp = var ('R');
4451                   rptr->addend = 0;
4452
4453                   if ((som_hppa_howto_table[op].type == R_PCREL_CALL
4454                        && R_PCREL_CALL + 10 > op)
4455                       || (som_hppa_howto_table[op].type == R_ABS_CALL
4456                           && R_ABS_CALL + 10 > op))
4457                     {
4458                       /* Simple encoding.  */
4459                       if (tmp > 4)
4460                         {
4461                           tmp -= 5;
4462                           rptr->addend |= 1;
4463                         }
4464                       if (tmp == 4)
4465                         rptr->addend |= 1 << 8 | 1 << 6 | 1 << 4 | 1 << 2;
4466                       else if (tmp == 3)
4467                         rptr->addend |= 1 << 8 | 1 << 6 | 1 << 4;
4468                       else if (tmp == 2)
4469                         rptr->addend |= 1 << 8 | 1 << 6;
4470                       else if (tmp == 1)
4471                         rptr->addend |= 1 << 8;
4472                     }
4473                   else
4474                     {
4475                       unsigned int tmp1, tmp2;
4476
4477                       /* First part is easy -- low order two bits are
4478                          directly copied, then shifted away.  */
4479                       rptr->addend = tmp & 0x3;
4480                       tmp >>= 2;
4481
4482                       /* Diving the result by 10 gives us the second
4483                          part.  If it is 9, then the first two words
4484                          are a double precision paramater, else it is
4485                          3 * the first arg bits + the 2nd arg bits.  */
4486                       tmp1 = tmp / 10;
4487                       tmp -= tmp1 * 10;
4488                       if (tmp1 == 9)
4489                         rptr->addend += (0xe << 6);
4490                       else
4491                         {
4492                           /* Get the two pieces.  */
4493                           tmp2 = tmp1 / 3;
4494                           tmp1 -= tmp2 * 3;
4495                           /* Put them in the addend.  */
4496                           rptr->addend += (tmp2 << 8) + (tmp1 << 6);
4497                         }
4498
4499                       /* What's left is the third part.  It's unpacked
4500                          just like the second.  */
4501                       if (tmp == 9)
4502                         rptr->addend += (0xe << 2);
4503                       else
4504                         {
4505                           tmp2 = tmp / 3;
4506                           tmp -= tmp2 * 3;
4507                           rptr->addend += (tmp2 << 4) + (tmp << 2);
4508                         }
4509                     }
4510                   rptr->addend = HPPA_R_ADDEND (rptr->addend, 0);
4511                 }
4512               break;
4513             /* Handle the linker expression stack.  */
4514             case 'O':
4515               switch (op)
4516                 {
4517                 case R_COMP1:
4518                   subop = comp1_opcodes;
4519                   break;
4520                 case R_COMP2:
4521                   subop = comp2_opcodes;
4522                   break;
4523                 case R_COMP3:
4524                   subop = comp3_opcodes;
4525                   break;
4526                 default:
4527                   abort ();
4528                 }
4529               while (*subop <= (unsigned char) c)
4530                 ++subop;
4531               --subop;
4532               break;
4533             /* The lower 32unwind bits must be persistent.  */
4534             case 'U':
4535               saved_unwind_bits = var ('U');
4536               break;
4537
4538             default:
4539               break;
4540             }
4541         }
4542
4543       /* If we used a previous fixup, clean up after it.  */
4544       if (prev_fixup)
4545         {
4546           fixup = save_fixup + 1;
4547           prev_fixup = 0;
4548         }
4549       /* Queue it.  */
4550       else if (fixup > save_fixup + 1)
4551         som_reloc_queue_insert (save_fixup, fixup - save_fixup, reloc_queue);
4552
4553       /* We do not pass R_DATA_OVERRIDE or R_NO_RELOCATION
4554          fixups to BFD.  */
4555       if (som_hppa_howto_table[op].type != R_DATA_OVERRIDE
4556           && som_hppa_howto_table[op].type != R_NO_RELOCATION)
4557         {
4558           /* Done with a single reloction. Loop back to the top.  */
4559           if (! just_count)
4560             {
4561               if (som_hppa_howto_table[op].type == R_ENTRY)
4562                 rptr->addend = var ('T');
4563               else if (som_hppa_howto_table[op].type == R_EXIT)
4564                 rptr->addend = var ('U');
4565               else if (som_hppa_howto_table[op].type == R_PCREL_CALL
4566                        || som_hppa_howto_table[op].type == R_ABS_CALL)
4567                 ;
4568               else if (som_hppa_howto_table[op].type == R_DATA_ONE_SYMBOL)
4569                 {
4570                   unsigned addend = var ('V');
4571
4572                   /* Try what was specified in R_DATA_OVERRIDE first
4573                      (if anything).  Then the hard way using the
4574                      section contents.  */
4575                   rptr->addend = var ('V');
4576
4577                   if (rptr->addend == 0 && !section->contents)
4578                     {
4579                       /* Got to read the damn contents first.  We don't
4580                          bother saving the contents (yet).  Add it one
4581                          day if the need arises.  */
4582                       section->contents = bfd_malloc (section->_raw_size);
4583                       if (section->contents == NULL)
4584                         return -1;
4585
4586                       deallocate_contents = 1;
4587                       bfd_get_section_contents (section->owner,
4588                                                 section,
4589                                                 section->contents,
4590                                                 0,
4591                                                 section->_raw_size);
4592                     }
4593                   else if (rptr->addend == 0)
4594                     rptr->addend = bfd_get_32 (section->owner,
4595                                                (section->contents
4596                                                 + offset - var ('L')));
4597
4598                 }
4599               else
4600                 rptr->addend = var ('V');
4601               rptr++;
4602             }
4603           count++;
4604           /* Now that we've handled a "full" relocation, reset
4605              some state.  */
4606           memset (variables, 0, sizeof (variables));
4607           memset (stack, 0, sizeof (stack));
4608         }
4609     }
4610   if (deallocate_contents)
4611     free (section->contents);
4612
4613   return count;
4614
4615 #undef var
4616 #undef push
4617 #undef pop
4618 #undef emptystack
4619 }
4620
4621 /* Read in the relocs (aka fixups in SOM terms) for a section.
4622
4623    som_get_reloc_upper_bound calls this routine with JUST_COUNT
4624    set to true to indicate it only needs a count of the number
4625    of actual relocations.  */
4626
4627 static boolean
4628 som_slurp_reloc_table (abfd, section, symbols, just_count)
4629      bfd *abfd;
4630      asection *section;
4631      asymbol **symbols;
4632      boolean just_count;
4633 {
4634   char *external_relocs;
4635   unsigned int fixup_stream_size;
4636   arelent *internal_relocs;
4637   unsigned int num_relocs;
4638
4639   fixup_stream_size = som_section_data (section)->reloc_size;
4640   /* If there were no relocations, then there is nothing to do.  */
4641   if (section->reloc_count == 0)
4642     return true;
4643
4644   /* If reloc_count is -1, then the relocation stream has not been
4645      parsed.  We must do so now to know how many relocations exist.  */
4646   if (section->reloc_count == -1)
4647     {
4648       external_relocs = (char *) bfd_malloc (fixup_stream_size);
4649       if (external_relocs == (char *) NULL)
4650         return false;
4651       /* Read in the external forms. */
4652       if (bfd_seek (abfd,
4653                     obj_som_reloc_filepos (abfd) + section->rel_filepos,
4654                     SEEK_SET)
4655           != 0)
4656         return false;
4657       if (bfd_read (external_relocs, 1, fixup_stream_size, abfd)
4658           != fixup_stream_size)
4659         return false;
4660
4661       /* Let callers know how many relocations found.
4662          also save the relocation stream as we will
4663          need it again.  */
4664       section->reloc_count = som_set_reloc_info (external_relocs,
4665                                                  fixup_stream_size,
4666                                                  NULL, NULL, NULL, true);
4667
4668       som_section_data (section)->reloc_stream = external_relocs;
4669     }
4670
4671   /* If the caller only wanted a count, then return now.  */
4672   if (just_count)
4673     return true;
4674
4675   num_relocs = section->reloc_count;
4676   external_relocs = som_section_data (section)->reloc_stream;
4677   /* Return saved information about the relocations if it is available.  */
4678   if (section->relocation != (arelent *) NULL)
4679     return true;
4680
4681   internal_relocs = (arelent *)
4682     bfd_zalloc (abfd, (num_relocs * sizeof (arelent)));
4683   if (internal_relocs == (arelent *) NULL)
4684     return false;
4685
4686   /* Process and internalize the relocations.  */
4687   som_set_reloc_info (external_relocs, fixup_stream_size,
4688                       internal_relocs, section, symbols, false);
4689
4690   /* We're done with the external relocations.  Free them.  */
4691   free (external_relocs);
4692   som_section_data (section)->reloc_stream = NULL;
4693
4694   /* Save our results and return success.  */
4695   section->relocation = internal_relocs;
4696   return (true);
4697 }
4698
4699 /* Return the number of bytes required to store the relocation
4700    information associated with the given section.  */
4701
4702 static long
4703 som_get_reloc_upper_bound (abfd, asect)
4704      bfd *abfd;
4705      sec_ptr asect;
4706 {
4707   /* If section has relocations, then read in the relocation stream
4708      and parse it to determine how many relocations exist.  */
4709   if (asect->flags & SEC_RELOC)
4710     {
4711       if (! som_slurp_reloc_table (abfd, asect, NULL, true))
4712         return -1;
4713       return (asect->reloc_count + 1) * sizeof (arelent *);
4714     }
4715   /* There are no relocations.  */
4716   return 0;
4717 }
4718
4719 /* Convert relocations from SOM (external) form into BFD internal
4720    form.  Return the number of relocations.  */
4721
4722 static long
4723 som_canonicalize_reloc (abfd, section, relptr, symbols)
4724      bfd *abfd;
4725      sec_ptr section;
4726      arelent **relptr;
4727      asymbol **symbols;
4728 {
4729   arelent *tblptr;
4730   int count;
4731
4732   if (som_slurp_reloc_table (abfd, section, symbols, false) == false)
4733     return -1;
4734
4735   count = section->reloc_count;
4736   tblptr = section->relocation;
4737
4738   while (count--)
4739     *relptr++ = tblptr++;
4740
4741   *relptr = (arelent *) NULL;
4742   return section->reloc_count;
4743 }
4744
4745 extern const bfd_target som_vec;
4746
4747 /* A hook to set up object file dependent section information.  */
4748
4749 static boolean
4750 som_new_section_hook (abfd, newsect)
4751      bfd *abfd;
4752      asection *newsect;
4753 {
4754   newsect->used_by_bfd =
4755     (PTR) bfd_zalloc (abfd, sizeof (struct som_section_data_struct));
4756   if (!newsect->used_by_bfd)
4757     return false;
4758   newsect->alignment_power = 3;
4759
4760   /* We allow more than three sections internally */
4761   return true;
4762 }
4763
4764 /* Copy any private info we understand from the input symbol
4765    to the output symbol.  */
4766
4767 static boolean
4768 som_bfd_copy_private_symbol_data (ibfd, isymbol, obfd, osymbol)
4769      bfd *ibfd;
4770      asymbol *isymbol;
4771      bfd *obfd;
4772      asymbol *osymbol;
4773 {
4774   struct som_symbol *input_symbol = (struct som_symbol *) isymbol;
4775   struct som_symbol *output_symbol = (struct som_symbol *) osymbol;
4776
4777   /* One day we may try to grok other private data.  */
4778   if (ibfd->xvec->flavour != bfd_target_som_flavour
4779       || obfd->xvec->flavour != bfd_target_som_flavour)
4780     return false;
4781
4782   /* The only private information we need to copy is the argument relocation
4783      bits.  */
4784   output_symbol->tc_data.hppa_arg_reloc = input_symbol->tc_data.hppa_arg_reloc;
4785
4786   return true;
4787 }
4788
4789 /* Copy any private info we understand from the input section
4790    to the output section.  */
4791 static boolean
4792 som_bfd_copy_private_section_data (ibfd, isection, obfd, osection)
4793      bfd *ibfd;
4794      asection *isection;
4795      bfd *obfd;
4796      asection *osection;
4797 {
4798   /* One day we may try to grok other private data.  */
4799   if (ibfd->xvec->flavour != bfd_target_som_flavour
4800       || obfd->xvec->flavour != bfd_target_som_flavour
4801       || (!som_is_space (isection) && !som_is_subspace (isection)))
4802     return true;
4803
4804   som_section_data (osection)->copy_data
4805     = (struct som_copyable_section_data_struct *)
4806       bfd_zalloc (obfd, sizeof (struct som_copyable_section_data_struct));
4807   if (som_section_data (osection)->copy_data == NULL)
4808     return false;
4809
4810   memcpy (som_section_data (osection)->copy_data,
4811           som_section_data (isection)->copy_data,
4812           sizeof (struct som_copyable_section_data_struct));
4813
4814   /* Reparent if necessary.  */
4815   if (som_section_data (osection)->copy_data->container)
4816     som_section_data (osection)->copy_data->container =
4817       som_section_data (osection)->copy_data->container->output_section;
4818
4819   return true;
4820 }
4821
4822 /* Copy any private info we understand from the input bfd
4823    to the output bfd.  */
4824
4825 static boolean
4826 som_bfd_copy_private_bfd_data (ibfd, obfd)
4827      bfd *ibfd, *obfd;
4828 {
4829   /* One day we may try to grok other private data.  */
4830   if (ibfd->xvec->flavour != bfd_target_som_flavour
4831       || obfd->xvec->flavour != bfd_target_som_flavour)
4832     return true;
4833
4834   /* Allocate some memory to hold the data we need.  */
4835   obj_som_exec_data (obfd) = (struct som_exec_data *)
4836     bfd_zalloc (obfd, sizeof (struct som_exec_data));
4837   if (obj_som_exec_data (obfd) == NULL)
4838     return false;
4839
4840   /* Now copy the data.  */
4841   memcpy (obj_som_exec_data (obfd), obj_som_exec_data (ibfd),
4842           sizeof (struct som_exec_data));
4843
4844   return true;
4845 }
4846
4847 /* Set backend info for sections which can not be described
4848    in the BFD data structures.  */
4849
4850 boolean
4851 bfd_som_set_section_attributes (section, defined, private, sort_key, spnum)
4852      asection *section;
4853      int defined;
4854      int private;
4855      unsigned int sort_key;
4856      int spnum;
4857 {
4858   /* Allocate memory to hold the magic information.  */
4859   if (som_section_data (section)->copy_data == NULL)
4860     {
4861       som_section_data (section)->copy_data
4862         = (struct som_copyable_section_data_struct *)
4863           bfd_zalloc (section->owner,
4864                       sizeof (struct som_copyable_section_data_struct));
4865       if (som_section_data (section)->copy_data == NULL)
4866         return false;
4867     }
4868   som_section_data (section)->copy_data->sort_key = sort_key;
4869   som_section_data (section)->copy_data->is_defined = defined;
4870   som_section_data (section)->copy_data->is_private = private;
4871   som_section_data (section)->copy_data->container = section;
4872   som_section_data (section)->copy_data->space_number = spnum;
4873   return true;
4874 }
4875
4876 /* Set backend info for subsections which can not be described
4877    in the BFD data structures.  */
4878
4879 boolean
4880 bfd_som_set_subsection_attributes (section, container, access,
4881                                    sort_key, quadrant)
4882      asection *section;
4883      asection *container;
4884      int access;
4885      unsigned int sort_key;
4886      int quadrant;
4887 {
4888   /* Allocate memory to hold the magic information.  */
4889   if (som_section_data (section)->copy_data == NULL)
4890     {
4891       som_section_data (section)->copy_data
4892         = (struct som_copyable_section_data_struct *)
4893           bfd_zalloc (section->owner,
4894                       sizeof (struct som_copyable_section_data_struct));
4895       if (som_section_data (section)->copy_data == NULL)
4896         return false;
4897     }
4898   som_section_data (section)->copy_data->sort_key = sort_key;
4899   som_section_data (section)->copy_data->access_control_bits = access;
4900   som_section_data (section)->copy_data->quadrant = quadrant;
4901   som_section_data (section)->copy_data->container = container;
4902   return true;
4903 }
4904
4905 /* Set the full SOM symbol type.  SOM needs far more symbol information
4906    than any other object file format I'm aware of.  It is mandatory
4907    to be able to know if a symbol is an entry point, millicode, data,
4908    code, absolute, storage request, or procedure label.  If you get
4909    the symbol type wrong your program will not link.  */
4910
4911 void
4912 bfd_som_set_symbol_type (symbol, type)
4913      asymbol *symbol;
4914      unsigned int type;
4915 {
4916   som_symbol_data (symbol)->som_type = type;
4917 }
4918
4919 /* Attach an auxiliary header to the BFD backend so that it may be
4920    written into the object file.  */
4921 boolean
4922 bfd_som_attach_aux_hdr (abfd, type, string)
4923      bfd *abfd;
4924      int type;
4925      char *string;
4926 {
4927   if (type == VERSION_AUX_ID)
4928     {
4929       int len = strlen (string);
4930       int pad = 0;
4931
4932       if (len % 4)
4933         pad = (4 - (len % 4));
4934       obj_som_version_hdr (abfd) = (struct user_string_aux_hdr *)
4935         bfd_zalloc (abfd, sizeof (struct aux_id)
4936                               + sizeof (unsigned int) + len + pad);
4937       if (!obj_som_version_hdr (abfd))
4938         return false;
4939       obj_som_version_hdr (abfd)->header_id.type = VERSION_AUX_ID;
4940       obj_som_version_hdr (abfd)->header_id.length = len + pad;
4941       obj_som_version_hdr (abfd)->header_id.length += sizeof (int);
4942       obj_som_version_hdr (abfd)->string_length = len;
4943       strncpy (obj_som_version_hdr (abfd)->user_string, string, len);
4944     }
4945   else if (type == COPYRIGHT_AUX_ID)
4946     {
4947       int len = strlen (string);
4948       int pad = 0;
4949
4950       if (len % 4)
4951         pad = (4 - (len % 4));
4952       obj_som_copyright_hdr (abfd) = (struct copyright_aux_hdr *)
4953         bfd_zalloc (abfd, sizeof (struct aux_id)
4954                             + sizeof (unsigned int) + len + pad);
4955       if (!obj_som_copyright_hdr (abfd))
4956         return false;
4957       obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID;
4958       obj_som_copyright_hdr (abfd)->header_id.length = len + pad;
4959       obj_som_copyright_hdr (abfd)->header_id.length += sizeof (int);
4960       obj_som_copyright_hdr (abfd)->string_length = len;
4961       strcpy (obj_som_copyright_hdr (abfd)->copyright, string);
4962     }
4963   return true;
4964 }
4965
4966 static boolean
4967 som_get_section_contents (abfd, section, location, offset, count)
4968      bfd *abfd;
4969      sec_ptr section;
4970      PTR location;
4971      file_ptr offset;
4972      bfd_size_type count;
4973 {
4974   if (count == 0 || ((section->flags & SEC_HAS_CONTENTS) == 0))
4975     return true;
4976   if ((bfd_size_type)(offset+count) > section->_raw_size
4977       || bfd_seek (abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
4978       || bfd_read (location, (bfd_size_type)1, count, abfd) != count)
4979     return (false); /* on error */
4980   return (true);
4981 }
4982
4983 static boolean
4984 som_set_section_contents (abfd, section, location, offset, count)
4985      bfd *abfd;
4986      sec_ptr section;
4987      PTR location;
4988      file_ptr offset;
4989      bfd_size_type count;
4990 {
4991   if (abfd->output_has_begun == false)
4992     {
4993       /* Set up fixed parts of the file, space, and subspace headers.
4994          Notify the world that output has begun.  */
4995       som_prep_headers (abfd);
4996       abfd->output_has_begun = true;
4997       /* Start writing the object file.  This include all the string
4998          tables, fixup streams, and other portions of the object file.  */
4999       som_begin_writing (abfd);
5000     }
5001
5002   /* Only write subspaces which have "real" contents (eg. the contents
5003      are not generated at run time by the OS).  */
5004   if (!som_is_subspace (section)
5005       || ((section->flags & SEC_HAS_CONTENTS) == 0))
5006     return true;
5007
5008   /* Seek to the proper offset within the object file and write the
5009      data.  */
5010   offset += som_section_data (section)->subspace_dict->file_loc_init_value;
5011   if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5012     return false;
5013
5014   if (bfd_write ((PTR) location, 1, count, abfd) != count)
5015     return false;
5016   return true;
5017 }
5018
5019 static boolean
5020 som_set_arch_mach (abfd, arch, machine)
5021      bfd *abfd;
5022      enum bfd_architecture arch;
5023      unsigned long machine;
5024 {
5025   /* Allow any architecture to be supported by the SOM backend */
5026   return bfd_default_set_arch_mach (abfd, arch, machine);
5027 }
5028
5029 static boolean
5030 som_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
5031                         functionname_ptr, line_ptr)
5032      bfd *abfd;
5033      asection *section;
5034      asymbol **symbols;
5035      bfd_vma offset;
5036      CONST char **filename_ptr;
5037      CONST char **functionname_ptr;
5038      unsigned int *line_ptr;
5039 {
5040   return (false);
5041 }
5042
5043 static int
5044 som_sizeof_headers (abfd, reloc)
5045      bfd *abfd;
5046      boolean reloc;
5047 {
5048   (*_bfd_error_handler) (_("som_sizeof_headers unimplemented"));
5049   fflush (stderr);
5050   abort ();
5051   return (0);
5052 }
5053
5054 /* Return the single-character symbol type corresponding to
5055    SOM section S, or '?' for an unknown SOM section.  */
5056
5057 static char
5058 som_section_type (s)
5059      const char *s;
5060 {
5061   const struct section_to_type *t;
5062
5063   for (t = &stt[0]; t->section; t++)
5064     if (!strcmp (s, t->section))
5065       return t->type;
5066   return '?';
5067 }
5068
5069 static int
5070 som_decode_symclass (symbol)
5071      asymbol *symbol;
5072 {
5073   char c;
5074
5075   if (bfd_is_com_section (symbol->section))
5076     return 'C';
5077   if (bfd_is_und_section (symbol->section))
5078     return 'U';
5079   if (bfd_is_ind_section (symbol->section))
5080     return 'I';
5081   if (!(symbol->flags & (BSF_GLOBAL|BSF_LOCAL)))
5082     return '?';
5083
5084   if (bfd_is_abs_section (symbol->section)
5085       || (som_symbol_data (symbol) != NULL
5086           && som_symbol_data (symbol)->som_type == SYMBOL_TYPE_ABSOLUTE))
5087     c = 'a';
5088   else if (symbol->section)
5089     c = som_section_type (symbol->section->name);
5090   else
5091     return '?';
5092   if (symbol->flags & BSF_GLOBAL)
5093     c = toupper (c);
5094   return c;
5095 }
5096
5097 /* Return information about SOM symbol SYMBOL in RET.  */
5098
5099 static void
5100 som_get_symbol_info (ignore_abfd, symbol, ret)
5101      bfd *ignore_abfd;
5102      asymbol *symbol;
5103      symbol_info *ret;
5104 {
5105   ret->type = som_decode_symclass (symbol);
5106   if (ret->type != 'U')
5107     ret->value = symbol->value+symbol->section->vma;
5108   else
5109     ret->value = 0;
5110   ret->name = symbol->name;
5111 }
5112
5113 /* Count the number of symbols in the archive symbol table.  Necessary
5114    so that we can allocate space for all the carsyms at once.  */
5115
5116 static boolean
5117 som_bfd_count_ar_symbols (abfd, lst_header, count)
5118      bfd *abfd;
5119      struct lst_header *lst_header;
5120      symindex *count;
5121 {
5122   unsigned int i;
5123   unsigned int *hash_table = NULL;
5124   file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
5125
5126   hash_table =
5127     (unsigned int *) bfd_malloc (lst_header->hash_size
5128                                  * sizeof (unsigned int));
5129   if (hash_table == NULL && lst_header->hash_size != 0)
5130     goto error_return;
5131
5132   /* Don't forget to initialize the counter!  */
5133   *count = 0;
5134
5135   /* Read in the hash table.  The has table is an array of 32bit file offsets
5136      which point to the hash chains.  */
5137   if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
5138       != lst_header->hash_size * 4)
5139     goto error_return;
5140
5141   /* Walk each chain counting the number of symbols found on that particular
5142      chain.  */
5143   for (i = 0; i < lst_header->hash_size; i++)
5144     {
5145       struct lst_symbol_record lst_symbol;
5146
5147       /* An empty chain has zero as it's file offset.  */
5148       if (hash_table[i] == 0)
5149         continue;
5150
5151       /* Seek to the first symbol in this hash chain.  */
5152       if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
5153         goto error_return;
5154
5155       /* Read in this symbol and update the counter.  */
5156       if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5157           != sizeof (lst_symbol))
5158         goto error_return;
5159
5160       (*count)++;
5161
5162       /* Now iterate through the rest of the symbols on this chain.  */
5163       while (lst_symbol.next_entry)
5164         {
5165
5166           /* Seek to the next symbol.  */
5167           if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET)
5168               < 0)
5169             goto error_return;
5170
5171           /* Read the symbol in and update the counter.  */
5172           if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5173               != sizeof (lst_symbol))
5174             goto error_return;
5175
5176           (*count)++;
5177         }
5178     }
5179   if (hash_table != NULL)
5180     free (hash_table);
5181   return true;
5182
5183  error_return:
5184   if (hash_table != NULL)
5185     free (hash_table);
5186   return false;
5187 }
5188
5189 /* Fill in the canonical archive symbols (SYMS) from the archive described
5190    by ABFD and LST_HEADER.  */
5191
5192 static boolean
5193 som_bfd_fill_in_ar_symbols (abfd, lst_header, syms)
5194      bfd *abfd;
5195      struct lst_header *lst_header;
5196      carsym **syms;
5197 {
5198   unsigned int i, len;
5199   carsym *set = syms[0];
5200   unsigned int *hash_table = NULL;
5201   struct som_entry *som_dict = NULL;
5202   file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
5203
5204   hash_table =
5205     (unsigned int *) bfd_malloc (lst_header->hash_size
5206                                  * sizeof (unsigned int));
5207   if (hash_table == NULL && lst_header->hash_size != 0)
5208     goto error_return;
5209
5210   som_dict =
5211     (struct som_entry *) bfd_malloc (lst_header->module_count
5212                                      * sizeof (struct som_entry));
5213   if (som_dict == NULL && lst_header->module_count != 0)
5214     goto error_return;
5215
5216   /* Read in the hash table.  The has table is an array of 32bit file offsets
5217      which point to the hash chains.  */
5218   if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
5219       != lst_header->hash_size * 4)
5220     goto error_return;
5221
5222   /* Seek to and read in the SOM dictionary.  We will need this to fill
5223      in the carsym's filepos field.  */
5224   if (bfd_seek (abfd, lst_filepos + lst_header->dir_loc, SEEK_SET) < 0)
5225     goto error_return;
5226
5227   if (bfd_read ((PTR) som_dict, lst_header->module_count,
5228                 sizeof (struct som_entry), abfd)
5229       != lst_header->module_count * sizeof (struct som_entry))
5230     goto error_return;
5231
5232   /* Walk each chain filling in the carsyms as we go along.  */
5233   for (i = 0; i < lst_header->hash_size; i++)
5234     {
5235       struct lst_symbol_record lst_symbol;
5236
5237       /* An empty chain has zero as it's file offset.  */
5238       if (hash_table[i] == 0)
5239         continue;
5240
5241       /* Seek to and read the first symbol on the chain.  */
5242       if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
5243         goto error_return;
5244
5245       if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5246           != sizeof (lst_symbol))
5247         goto error_return;
5248
5249       /* Get the name of the symbol, first get the length which is stored
5250          as a 32bit integer just before the symbol.
5251
5252          One might ask why we don't just read in the entire string table
5253          and index into it.  Well, according to the SOM ABI the string
5254          index can point *anywhere* in the archive to save space, so just
5255          using the string table would not be safe.  */
5256       if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
5257                             + lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
5258         goto error_return;
5259
5260       if (bfd_read (&len, 1, 4, abfd) != 4)
5261         goto error_return;
5262
5263       /* Allocate space for the name and null terminate it too.  */
5264       set->name = bfd_zalloc (abfd, len + 1);
5265       if (!set->name)
5266         goto error_return;
5267       if (bfd_read (set->name, 1, len, abfd) != len)
5268         goto error_return;
5269
5270       set->name[len] = 0;
5271
5272       /* Fill in the file offset.  Note that the "location" field points
5273          to the SOM itself, not the ar_hdr in front of it.  */
5274       set->file_offset = som_dict[lst_symbol.som_index].location
5275                           - sizeof (struct ar_hdr);
5276
5277       /* Go to the next symbol.  */
5278       set++;
5279
5280       /* Iterate through the rest of the chain.  */
5281       while (lst_symbol.next_entry)
5282         {
5283           /* Seek to the next symbol and read it in.  */
5284           if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET) <0)
5285             goto error_return;
5286
5287           if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
5288               != sizeof (lst_symbol))
5289             goto error_return;
5290
5291           /* Seek to the name length & string and read them in.  */
5292           if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
5293                                 + lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
5294             goto error_return;
5295
5296           if (bfd_read (&len, 1, 4, abfd) != 4)
5297             goto error_return;
5298
5299           /* Allocate space for the name and null terminate it too.  */
5300           set->name = bfd_zalloc (abfd, len + 1);
5301           if (!set->name)
5302             goto error_return;
5303
5304           if (bfd_read (set->name, 1, len, abfd) != len)
5305             goto error_return;
5306           set->name[len] = 0;
5307
5308           /* Fill in the file offset.  Note that the "location" field points
5309              to the SOM itself, not the ar_hdr in front of it.  */
5310           set->file_offset = som_dict[lst_symbol.som_index].location
5311                                - sizeof (struct ar_hdr);
5312
5313           /* Go on to the next symbol.  */
5314           set++;
5315         }
5316     }
5317   /* If we haven't died by now, then we successfully read the entire
5318      archive symbol table.  */
5319   if (hash_table != NULL)
5320     free (hash_table);
5321   if (som_dict != NULL)
5322     free (som_dict);
5323   return true;
5324
5325  error_return:
5326   if (hash_table != NULL)
5327     free (hash_table);
5328   if (som_dict != NULL)
5329     free (som_dict);
5330   return false;
5331 }
5332
5333 /* Read in the LST from the archive.  */
5334 static boolean
5335 som_slurp_armap (abfd)
5336      bfd *abfd;
5337 {
5338   struct lst_header lst_header;
5339   struct ar_hdr ar_header;
5340   unsigned int parsed_size;
5341   struct artdata *ardata = bfd_ardata (abfd);
5342   char nextname[17];
5343   int i = bfd_read ((PTR) nextname, 1, 16, abfd);
5344
5345   /* Special cases.  */
5346   if (i == 0)
5347     return true;
5348   if (i != 16)
5349     return false;
5350
5351   if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) < 0)
5352     return false;
5353
5354   /* For archives without .o files there is no symbol table.  */
5355   if (strncmp (nextname, "/               ", 16))
5356     {
5357       bfd_has_map (abfd) = false;
5358       return true;
5359     }
5360
5361   /* Read in and sanity check the archive header.  */
5362   if (bfd_read ((PTR) &ar_header, 1, sizeof (struct ar_hdr), abfd)
5363       != sizeof (struct ar_hdr))
5364     return false;
5365
5366   if (strncmp (ar_header.ar_fmag, ARFMAG, 2))
5367     {
5368       bfd_set_error (bfd_error_malformed_archive);
5369       return false;
5370     }
5371
5372   /* How big is the archive symbol table entry?  */
5373   errno = 0;
5374   parsed_size = strtol (ar_header.ar_size, NULL, 10);
5375   if (errno != 0)
5376     {
5377       bfd_set_error (bfd_error_malformed_archive);
5378       return false;
5379     }
5380
5381   /* Save off the file offset of the first real user data.  */
5382   ardata->first_file_filepos = bfd_tell (abfd) + parsed_size;
5383
5384   /* Read in the library symbol table.  We'll make heavy use of this
5385      in just a minute.  */
5386   if (bfd_read ((PTR) & lst_header, 1, sizeof (struct lst_header), abfd)
5387       != sizeof (struct lst_header))
5388     return false;
5389
5390   /* Sanity check.  */
5391   if (lst_header.a_magic != LIBMAGIC)
5392     {
5393       bfd_set_error (bfd_error_malformed_archive);
5394       return false;
5395     }
5396
5397   /* Count the number of symbols in the library symbol table.  */
5398   if (som_bfd_count_ar_symbols (abfd, &lst_header, &ardata->symdef_count)
5399       == false)
5400     return false;
5401
5402   /* Get back to the start of the library symbol table.  */
5403   if (bfd_seek (abfd, ardata->first_file_filepos - parsed_size
5404                         + sizeof (struct lst_header), SEEK_SET) < 0)
5405     return false;
5406
5407   /* Initializae the cache and allocate space for the library symbols.  */
5408   ardata->cache = 0;
5409   ardata->symdefs = (carsym *) bfd_alloc (abfd,
5410                                           (ardata->symdef_count
5411                                            * sizeof (carsym)));
5412   if (!ardata->symdefs)
5413     return false;
5414
5415   /* Now fill in the canonical archive symbols.  */
5416   if (som_bfd_fill_in_ar_symbols (abfd, &lst_header, &ardata->symdefs)
5417       == false)
5418     return false;
5419
5420   /* Seek back to the "first" file in the archive.  Note the "first"
5421      file may be the extended name table.  */
5422   if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) < 0)
5423     return false;
5424
5425   /* Notify the generic archive code that we have a symbol map.  */
5426   bfd_has_map (abfd) = true;
5427   return true;
5428 }
5429
5430 /* Begin preparing to write a SOM library symbol table.
5431
5432    As part of the prep work we need to determine the number of symbols
5433    and the size of the associated string section.  */
5434
5435 static boolean
5436 som_bfd_prep_for_ar_write (abfd, num_syms, stringsize)
5437      bfd *abfd;
5438      unsigned int *num_syms, *stringsize;
5439 {
5440   bfd *curr_bfd = abfd->archive_head;
5441
5442   /* Some initialization.  */
5443   *num_syms = 0;
5444   *stringsize = 0;
5445
5446   /* Iterate over each BFD within this archive.  */
5447   while (curr_bfd != NULL)
5448     {
5449       unsigned int curr_count, i;
5450       som_symbol_type *sym;
5451
5452       /* Don't bother for non-SOM objects.  */
5453       if (curr_bfd->format != bfd_object
5454           || curr_bfd->xvec->flavour != bfd_target_som_flavour)
5455         {
5456           curr_bfd = curr_bfd->next;
5457           continue;
5458         }
5459
5460       /* Make sure the symbol table has been read, then snag a pointer
5461          to it.  It's a little slimey to grab the symbols via obj_som_symtab,
5462          but doing so avoids allocating lots of extra memory.  */
5463       if (som_slurp_symbol_table (curr_bfd) == false)
5464         return false;
5465
5466       sym = obj_som_symtab (curr_bfd);
5467       curr_count = bfd_get_symcount (curr_bfd);
5468
5469       /* Examine each symbol to determine if it belongs in the
5470          library symbol table.  */
5471       for (i = 0; i < curr_count; i++, sym++)
5472         {
5473           struct som_misc_symbol_info info;
5474
5475           /* Derive SOM information from the BFD symbol.  */
5476           som_bfd_derive_misc_symbol_info (curr_bfd, &sym->symbol, &info);
5477
5478           /* Should we include this symbol?  */
5479           if (info.symbol_type == ST_NULL
5480               || info.symbol_type == ST_SYM_EXT
5481               || info.symbol_type == ST_ARG_EXT)
5482             continue;
5483
5484           /* Only global symbols and unsatisfied commons.  */
5485           if (info.symbol_scope != SS_UNIVERSAL
5486               && info.symbol_type != ST_STORAGE)
5487             continue;
5488
5489           /* Do no include undefined symbols.  */
5490           if (bfd_is_und_section (sym->symbol.section))
5491             continue;
5492
5493           /* Bump the various counters, being careful to honor
5494              alignment considerations in the string table.  */
5495           (*num_syms)++;
5496           *stringsize = *stringsize + strlen (sym->symbol.name) + 5;
5497           while (*stringsize % 4)
5498             (*stringsize)++;
5499         }
5500
5501       curr_bfd = curr_bfd->next;
5502     }
5503   return true;
5504 }
5505
5506 /* Hash a symbol name based on the hashing algorithm presented in the
5507    SOM ABI.  */
5508 static unsigned int
5509 som_bfd_ar_symbol_hash (symbol)
5510      asymbol *symbol;
5511 {
5512   unsigned int len = strlen (symbol->name);
5513
5514   /* Names with length 1 are special.  */
5515   if (len == 1)
5516     return 0x1000100 | (symbol->name[0] << 16) | symbol->name[0];
5517
5518   return ((len & 0x7f) << 24) | (symbol->name[1] << 16)
5519           | (symbol->name[len-2] << 8) | symbol->name[len-1];
5520 }
5521
5522 /* Do the bulk of the work required to write the SOM library
5523    symbol table.  */
5524
5525 static boolean
5526 som_bfd_ar_write_symbol_stuff (abfd, nsyms, string_size, lst, elength)
5527      bfd *abfd;
5528      unsigned int nsyms, string_size;
5529      struct lst_header lst;
5530      unsigned elength;
5531 {
5532   file_ptr lst_filepos;
5533   char *strings = NULL, *p;
5534   struct lst_symbol_record *lst_syms = NULL, *curr_lst_sym;
5535   bfd *curr_bfd;
5536   unsigned int *hash_table = NULL;
5537   struct som_entry *som_dict = NULL;
5538   struct lst_symbol_record **last_hash_entry = NULL;
5539   unsigned int curr_som_offset, som_index = 0;
5540
5541   hash_table =
5542     (unsigned int *) bfd_malloc (lst.hash_size * sizeof (unsigned int));
5543   if (hash_table == NULL && lst.hash_size != 0)
5544     goto error_return;
5545   som_dict =
5546     (struct som_entry *) bfd_malloc (lst.module_count
5547                                      * sizeof (struct som_entry));
5548   if (som_dict == NULL && lst.module_count != 0)
5549     goto error_return;
5550
5551   last_hash_entry =
5552     ((struct lst_symbol_record **)
5553      bfd_malloc (lst.hash_size * sizeof (struct lst_symbol_record *)));
5554   if (last_hash_entry == NULL && lst.hash_size != 0)
5555     goto error_return;
5556
5557   /* Lots of fields are file positions relative to the start
5558      of the lst record.  So save its location.  */
5559   lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
5560
5561   /* Some initialization.  */
5562   memset (hash_table, 0, 4 * lst.hash_size);
5563   memset (som_dict, 0, lst.module_count * sizeof (struct som_entry));
5564   memset (last_hash_entry, 0,
5565           lst.hash_size * sizeof (struct lst_symbol_record *));
5566
5567   /* Symbols have som_index fields, so we have to keep track of the
5568      index of each SOM in the archive.
5569
5570      The SOM dictionary has (among other things) the absolute file
5571      position for the SOM which a particular dictionary entry
5572      describes.  We have to compute that information as we iterate
5573      through the SOMs/symbols.  */
5574   som_index = 0;
5575
5576   /* We add in the size of the archive header twice as the location
5577      in the SOM dictionary is the actual offset of the SOM, not the
5578      archive header before the SOM.  */
5579   curr_som_offset = 8 + 2 * sizeof (struct ar_hdr) + lst.file_end;
5580
5581   /* Make room for the archive header and the contents of the
5582      extended string table.  Note that elength includes the size
5583      of the archive header for the extended name table!  */
5584   if (elength)
5585     curr_som_offset += elength;
5586
5587   /* Make sure we're properly aligned.  */
5588   curr_som_offset = (curr_som_offset + 0x1) & ~0x1;
5589
5590   /* FIXME should be done with buffers just like everything else... */
5591   lst_syms = bfd_malloc (nsyms * sizeof (struct lst_symbol_record));
5592   if (lst_syms == NULL && nsyms != 0)
5593     goto error_return;
5594   strings = bfd_malloc (string_size);
5595   if (strings == NULL && string_size != 0)
5596     goto error_return;
5597
5598   p = strings;
5599   curr_lst_sym = lst_syms;
5600
5601   curr_bfd = abfd->archive_head;
5602   while (curr_bfd != NULL)
5603     {
5604       unsigned int curr_count, i;
5605       som_symbol_type *sym;
5606
5607       /* Don't bother for non-SOM objects.  */
5608       if (curr_bfd->format != bfd_object
5609           || curr_bfd->xvec->flavour != bfd_target_som_flavour)
5610         {
5611           curr_bfd = curr_bfd->next;
5612           continue;
5613         }
5614
5615       /* Make sure the symbol table has been read, then snag a pointer
5616          to it.  It's a little slimey to grab the symbols via obj_som_symtab,
5617          but doing so avoids allocating lots of extra memory.  */
5618       if (som_slurp_symbol_table (curr_bfd) == false)
5619         goto error_return;
5620
5621       sym = obj_som_symtab (curr_bfd);
5622       curr_count = bfd_get_symcount (curr_bfd);
5623
5624       for (i = 0; i < curr_count; i++, sym++)
5625         {
5626           struct som_misc_symbol_info info;
5627
5628           /* Derive SOM information from the BFD symbol.  */
5629           som_bfd_derive_misc_symbol_info (curr_bfd, &sym->symbol, &info);
5630
5631           /* Should we include this symbol?  */
5632           if (info.symbol_type == ST_NULL
5633               || info.symbol_type == ST_SYM_EXT
5634               || info.symbol_type == ST_ARG_EXT)
5635             continue;
5636
5637           /* Only global symbols and unsatisfied commons.  */
5638           if (info.symbol_scope != SS_UNIVERSAL
5639               && info.symbol_type != ST_STORAGE)
5640             continue;
5641
5642           /* Do no include undefined symbols.  */
5643           if (bfd_is_und_section (sym->symbol.section))
5644             continue;
5645
5646           /* If this is the first symbol from this SOM, then update
5647              the SOM dictionary too.  */
5648           if (som_dict[som_index].location == 0)
5649             {
5650               som_dict[som_index].location = curr_som_offset;
5651               som_dict[som_index].length = arelt_size (curr_bfd);
5652             }
5653
5654           /* Fill in the lst symbol record.  */
5655           curr_lst_sym->hidden = 0;
5656           curr_lst_sym->secondary_def = 0;
5657           curr_lst_sym->symbol_type = info.symbol_type;
5658           curr_lst_sym->symbol_scope = info.symbol_scope;
5659           curr_lst_sym->check_level = 0;
5660           curr_lst_sym->must_qualify = 0;
5661           curr_lst_sym->initially_frozen = 0;
5662           curr_lst_sym->memory_resident = 0;
5663           curr_lst_sym->is_common = bfd_is_com_section (sym->symbol.section);
5664           curr_lst_sym->dup_common = 0;
5665           curr_lst_sym->xleast = 0;
5666           curr_lst_sym->arg_reloc = info.arg_reloc;
5667           curr_lst_sym->name.n_strx = p - strings + 4;
5668           curr_lst_sym->qualifier_name.n_strx = 0;
5669           curr_lst_sym->symbol_info = info.symbol_info;
5670           curr_lst_sym->symbol_value = info.symbol_value;
5671           curr_lst_sym->symbol_descriptor = 0;
5672           curr_lst_sym->reserved = 0;
5673           curr_lst_sym->som_index = som_index;
5674           curr_lst_sym->symbol_key = som_bfd_ar_symbol_hash (&sym->symbol);
5675           curr_lst_sym->next_entry = 0;
5676
5677           /* Insert into the hash table.  */
5678           if (hash_table[curr_lst_sym->symbol_key % lst.hash_size])
5679             {
5680               struct lst_symbol_record *tmp;
5681
5682               /* There is already something at the head of this hash chain,
5683                  so tack this symbol onto the end of the chain.  */
5684               tmp = last_hash_entry[curr_lst_sym->symbol_key % lst.hash_size];
5685               tmp->next_entry
5686                 = (curr_lst_sym - lst_syms) * sizeof (struct lst_symbol_record)
5687                   + lst.hash_size * 4
5688                   + lst.module_count * sizeof (struct som_entry)
5689                   + sizeof (struct lst_header);
5690             }
5691           else
5692             {
5693               /* First entry in this hash chain.  */
5694               hash_table[curr_lst_sym->symbol_key % lst.hash_size]
5695                 = (curr_lst_sym - lst_syms) * sizeof (struct lst_symbol_record)
5696                   + lst.hash_size * 4
5697                   + lst.module_count * sizeof (struct som_entry)
5698                   + sizeof (struct lst_header);
5699             }
5700
5701           /* Keep track of the last symbol we added to this chain so we can
5702              easily update its next_entry pointer.  */
5703           last_hash_entry[curr_lst_sym->symbol_key % lst.hash_size]
5704             = curr_lst_sym;
5705
5706
5707           /* Update the string table.  */
5708           bfd_put_32 (abfd, strlen (sym->symbol.name), p);
5709           p += 4;
5710           strcpy (p, sym->symbol.name);
5711           p += strlen (sym->symbol.name) + 1;
5712           while ((int)p % 4)
5713             {
5714               bfd_put_8 (abfd, 0, p);
5715               p++;
5716             }
5717
5718           /* Head to the next symbol.  */
5719           curr_lst_sym++;
5720         }
5721
5722       /* Keep track of where each SOM will finally reside; then look
5723          at the next BFD.  */
5724       curr_som_offset += arelt_size (curr_bfd) + sizeof (struct ar_hdr);
5725
5726       /* A particular object in the archive may have an odd length; the
5727          linker requires objects begin on an even boundary.  So round
5728          up the current offset as necessary.  */
5729       curr_som_offset = (curr_som_offset + 0x1) & ~0x1;
5730       curr_bfd = curr_bfd->next;
5731       som_index++;
5732     }
5733
5734   /* Now scribble out the hash table.  */
5735   if (bfd_write ((PTR) hash_table, lst.hash_size, 4, abfd)
5736       != lst.hash_size * 4)
5737     goto error_return;
5738
5739   /* Then the SOM dictionary.  */
5740   if (bfd_write ((PTR) som_dict, lst.module_count,
5741                  sizeof (struct som_entry), abfd)
5742       != lst.module_count * sizeof (struct som_entry))
5743     goto error_return;
5744
5745   /* The library symbols.  */
5746   if (bfd_write ((PTR) lst_syms, nsyms, sizeof (struct lst_symbol_record), abfd)
5747       != nsyms * sizeof (struct lst_symbol_record))
5748     goto error_return;
5749
5750   /* And finally the strings.  */
5751   if (bfd_write ((PTR) strings, string_size, 1, abfd) != string_size)
5752     goto error_return;
5753
5754   if (hash_table != NULL)
5755     free (hash_table);
5756   if (som_dict != NULL)
5757     free (som_dict);
5758   if (last_hash_entry != NULL)
5759     free (last_hash_entry);
5760   if (lst_syms != NULL)
5761     free (lst_syms);
5762   if (strings != NULL)
5763     free (strings);
5764   return true;
5765
5766  error_return:
5767   if (hash_table != NULL)
5768     free (hash_table);
5769   if (som_dict != NULL)
5770     free (som_dict);
5771   if (last_hash_entry != NULL)
5772     free (last_hash_entry);
5773   if (lst_syms != NULL)
5774     free (lst_syms);
5775   if (strings != NULL)
5776     free (strings);
5777
5778   return false;
5779 }
5780
5781 /* Write out the LST for the archive.
5782
5783    You'll never believe this is really how armaps are handled in SOM...  */
5784
5785 /*ARGSUSED*/
5786 static boolean
5787 som_write_armap (abfd, elength, map, orl_count, stridx)
5788      bfd *abfd;
5789      unsigned int elength;
5790      struct orl *map;
5791      unsigned int orl_count;
5792      int stridx;
5793 {
5794   bfd *curr_bfd;
5795   struct stat statbuf;
5796   unsigned int i, lst_size, nsyms, stringsize;
5797   struct ar_hdr hdr;
5798   struct lst_header lst;
5799   int *p;
5800
5801   /* We'll use this for the archive's date and mode later.  */
5802   if (stat (abfd->filename, &statbuf) != 0)
5803     {
5804       bfd_set_error (bfd_error_system_call);
5805       return false;
5806     }
5807   /* Fudge factor.  */
5808   bfd_ardata (abfd)->armap_timestamp = statbuf.st_mtime + 60;
5809
5810   /* Account for the lst header first.  */
5811   lst_size = sizeof (struct lst_header);
5812
5813   /* Start building the LST header.  */
5814   /* FIXME:  Do we need to examine each element to determine the
5815      largest id number?  */
5816   lst.system_id = CPU_PA_RISC1_0;
5817   lst.a_magic = LIBMAGIC;
5818   lst.version_id = VERSION_ID;
5819   lst.file_time.secs = 0;
5820   lst.file_time.nanosecs = 0;
5821
5822   lst.hash_loc = lst_size;
5823   lst.hash_size = SOM_LST_HASH_SIZE;
5824
5825   /* Hash table is a SOM_LST_HASH_SIZE 32bit offsets.  */
5826   lst_size += 4 * SOM_LST_HASH_SIZE;
5827
5828   /* We need to count the number of SOMs in this archive.  */
5829   curr_bfd = abfd->archive_head;
5830   lst.module_count = 0;
5831   while (curr_bfd != NULL)
5832     {
5833       /* Only true SOM objects count.  */
5834       if (curr_bfd->format == bfd_object
5835           && curr_bfd->xvec->flavour == bfd_target_som_flavour)
5836         lst.module_count++;
5837       curr_bfd = curr_bfd->next;
5838     }
5839   lst.module_limit = lst.module_count;
5840   lst.dir_loc = lst_size;
5841   lst_size += sizeof (struct som_entry) * lst.module_count;
5842
5843   /* We don't support import/export tables, auxiliary headers,
5844      or free lists yet.  Make the linker work a little harder
5845      to make our life easier.  */
5846
5847   lst.export_loc = 0;
5848   lst.export_count = 0;
5849   lst.import_loc = 0;
5850   lst.aux_loc = 0;
5851   lst.aux_size = 0;
5852
5853   /* Count how many symbols we will have on the hash chains and the
5854      size of the associated string table.  */
5855   if (som_bfd_prep_for_ar_write (abfd, &nsyms, &stringsize) == false)
5856     return false;
5857
5858   lst_size += sizeof (struct lst_symbol_record) * nsyms;
5859
5860   /* For the string table.  One day we might actually use this info
5861      to avoid small seeks/reads when reading archives.  */
5862   lst.string_loc = lst_size;
5863   lst.string_size = stringsize;
5864   lst_size += stringsize;
5865
5866   /* SOM ABI says this must be zero.  */
5867   lst.free_list = 0;
5868   lst.file_end = lst_size;
5869
5870   /* Compute the checksum.  Must happen after the entire lst header
5871      has filled in.  */
5872   p = (int *)&lst;
5873   lst.checksum = 0;
5874   for (i = 0; i < sizeof (struct lst_header)/sizeof (int) - 1; i++)
5875     lst.checksum ^= *p++;
5876
5877   sprintf (hdr.ar_name, "/               ");
5878   sprintf (hdr.ar_date, "%ld", bfd_ardata (abfd)->armap_timestamp);
5879   sprintf (hdr.ar_uid, "%ld", (long) getuid ());
5880   sprintf (hdr.ar_gid, "%ld", (long) getgid ());
5881   sprintf (hdr.ar_mode, "%-8o", (unsigned int) statbuf.st_mode);
5882   sprintf (hdr.ar_size, "%-10d", (int) lst_size);
5883   hdr.ar_fmag[0] = '`';
5884   hdr.ar_fmag[1] = '\012';
5885
5886   /* Turn any nulls into spaces.  */
5887   for (i = 0; i < sizeof (struct ar_hdr); i++)
5888     if (((char *) (&hdr))[i] == '\0')
5889       (((char *) (&hdr))[i]) = ' ';
5890
5891   /* Scribble out the ar header.  */
5892   if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
5893       != sizeof (struct ar_hdr))
5894     return false;
5895
5896   /* Now scribble out the lst header.  */
5897   if (bfd_write ((PTR) &lst, 1, sizeof (struct lst_header), abfd)
5898       != sizeof (struct lst_header))
5899     return false;
5900
5901   /* Build and write the armap.  */
5902   if (som_bfd_ar_write_symbol_stuff (abfd, nsyms, stringsize, lst, elength)
5903       == false)
5904     return false;
5905
5906   /* Done.  */
5907   return true;
5908 }
5909
5910 /* Free all information we have cached for this BFD.  We can always
5911    read it again later if we need it.  */
5912
5913 static boolean
5914 som_bfd_free_cached_info (abfd)
5915      bfd *abfd;
5916 {
5917   asection *o;
5918
5919   if (bfd_get_format (abfd) != bfd_object)
5920     return true;
5921
5922 #define FREE(x) if (x != NULL) { free (x); x = NULL; }
5923   /* Free the native string and symbol tables.  */
5924   FREE (obj_som_symtab (abfd));
5925   FREE (obj_som_stringtab (abfd));
5926   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5927     {
5928       /* Free the native relocations.  */
5929       o->reloc_count = -1;
5930       FREE (som_section_data (o)->reloc_stream);
5931       /* Free the generic relocations.  */
5932       FREE (o->relocation);
5933     }
5934 #undef FREE
5935
5936   return true;
5937 }
5938
5939 /* End of miscellaneous support functions. */
5940
5941 /* Linker support functions.  */
5942 static boolean
5943 som_bfd_link_split_section (abfd, sec)
5944      bfd *abfd;
5945      asection *sec;
5946 {
5947   return (som_is_subspace (sec) && sec->_raw_size > 240000);
5948 }
5949
5950 #define som_close_and_cleanup           som_bfd_free_cached_info
5951
5952 #define som_read_ar_hdr                 _bfd_generic_read_ar_hdr
5953 #define som_openr_next_archived_file    bfd_generic_openr_next_archived_file
5954 #define som_get_elt_at_index            _bfd_generic_get_elt_at_index
5955 #define som_generic_stat_arch_elt       bfd_generic_stat_arch_elt
5956 #define som_truncate_arname             bfd_bsd_truncate_arname
5957 #define som_slurp_extended_name_table   _bfd_slurp_extended_name_table
5958 #define som_construct_extended_name_table \
5959   _bfd_archive_coff_construct_extended_name_table
5960 #define som_update_armap_timestamp      bfd_true
5961 #define som_bfd_print_private_bfd_data  _bfd_generic_bfd_print_private_bfd_data
5962
5963 #define som_get_lineno                  _bfd_nosymbols_get_lineno
5964 #define som_bfd_make_debug_symbol       _bfd_nosymbols_bfd_make_debug_symbol
5965 #define som_read_minisymbols            _bfd_generic_read_minisymbols
5966 #define som_minisymbol_to_symbol        _bfd_generic_minisymbol_to_symbol
5967 #define som_get_section_contents_in_window \
5968   _bfd_generic_get_section_contents_in_window
5969
5970 #define som_bfd_get_relocated_section_contents \
5971  bfd_generic_get_relocated_section_contents
5972 #define som_bfd_relax_section bfd_generic_relax_section
5973 #define som_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5974 #define som_bfd_link_add_symbols _bfd_generic_link_add_symbols
5975 #define som_bfd_final_link _bfd_generic_final_link
5976
5977
5978 const bfd_target som_vec =
5979 {
5980   "som",                        /* name */
5981   bfd_target_som_flavour,
5982   BFD_ENDIAN_BIG,               /* target byte order */
5983   BFD_ENDIAN_BIG,               /* target headers byte order */
5984   (HAS_RELOC | EXEC_P |         /* object flags */
5985    HAS_LINENO | HAS_DEBUG |
5986    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | DYNAMIC),
5987   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
5988    | SEC_ALLOC | SEC_LOAD | SEC_RELOC),         /* section flags */
5989
5990 /* leading_symbol_char: is the first char of a user symbol
5991    predictable, and if so what is it */
5992   0,
5993   '/',                          /* ar_pad_char */
5994   14,                           /* ar_max_namelen */
5995   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
5996   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
5997   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
5998   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
5999   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
6000   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
6001   {_bfd_dummy_target,
6002    som_object_p,                /* bfd_check_format */
6003    bfd_generic_archive_p,
6004    _bfd_dummy_target
6005   },
6006   {
6007     bfd_false,
6008     som_mkobject,
6009     _bfd_generic_mkarchive,
6010     bfd_false
6011   },
6012   {
6013     bfd_false,
6014     som_write_object_contents,
6015     _bfd_write_archive_contents,
6016     bfd_false,
6017   },
6018 #undef som
6019
6020   BFD_JUMP_TABLE_GENERIC (som),
6021   BFD_JUMP_TABLE_COPY (som),
6022   BFD_JUMP_TABLE_CORE (_bfd_nocore),
6023   BFD_JUMP_TABLE_ARCHIVE (som),
6024   BFD_JUMP_TABLE_SYMBOLS (som),
6025   BFD_JUMP_TABLE_RELOCS (som),
6026   BFD_JUMP_TABLE_WRITE (som),
6027   BFD_JUMP_TABLE_LINK (som),
6028   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
6029
6030   (PTR) 0
6031 };
6032
6033 #endif /* HOST_HPPAHPUX || HOST_HPPABSD || HOST_HPPAOSF */