bfd/som.c

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