gas/config/tc-hppa.c

   1 /* tc-hppa.c -- Assemble for the PA
   2    Copyright (C) 1989, 93, 94, 95, 96, 97, 98, 1999
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22
  23 /* HP PA-RISC support was contributed by the Center for Software Science
  24    at the University of Utah.  */
  25
  26 #include <stdio.h>
  27 #include <ctype.h>
  28
  29 #include "as.h"
  30 #include "subsegs.h"
  31
  32 #include "bfd/libhppa.h"
  33 #include "bfd/libbfd.h"
  34
  35 /* Be careful, this file includes data *declarations*.  */
  36 #include "opcode/hppa.h"
  37
  38 #if defined (OBJ_ELF) && defined (OBJ_SOM)
  39 error only one of OBJ_ELF and OBJ_SOM can be defined
  40 #endif
  41
  42 /* A "convient" place to put object file dependencies which do
  43    not need to be seen outside of tc-hppa.c.  */
  44 #ifdef OBJ_ELF
  45 /* Object file formats specify relocation types.  */
  46 typedef elf_hppa_reloc_type reloc_type;
  47
  48 /* Object file formats specify BFD symbol types.  */
  49 typedef elf_symbol_type obj_symbol_type;
  50
  51 #ifdef BFD64
  52 /* How to generate a relocation.  */
  53 #define hppa_gen_reloc_type _bfd_elf64_hppa_gen_reloc_type
  54 #else
  55 #define hppa_gen_reloc_type _bfd_elf32_hppa_gen_reloc_type
  56 #endif
  57
  58 /* ELF objects can have versions, but apparently do not have anywhere
  59    to store a copyright string.  */
  60 #define obj_version obj_elf_version
  61 #define obj_copyright obj_elf_version
  62
  63 #define UNWIND_SECTION_NAME ".PARISC.unwind"
  64 #endif
  65
  66 #ifdef OBJ_SOM
  67 /* Names of various debugging spaces/subspaces.  */
  68 #define GDB_DEBUG_SPACE_NAME "$GDB_DEBUG$"
  69 #define GDB_STRINGS_SUBSPACE_NAME "$GDB_STRINGS$"
  70 #define GDB_SYMBOLS_SUBSPACE_NAME "$GDB_SYMBOLS$"
  71 #define UNWIND_SECTION_NAME "$UNWIND$"
  72
  73 /* Object file formats specify relocation types.  */
  74 typedef int reloc_type;
  75
  76 /* SOM objects can have both a version string and a copyright string.  */
  77 #define obj_version obj_som_version
  78 #define obj_copyright obj_som_copyright
  79
  80 /* How to generate a relocation.  */
  81 #define hppa_gen_reloc_type hppa_som_gen_reloc_type
  82
  83 /* Object file formats specify BFD symbol types.  */
  84 typedef som_symbol_type obj_symbol_type;
  85
  86 /* This apparently isn't in older versions of hpux reloc.h.  */
  87 #ifndef R_DLT_REL
  88 #define R_DLT_REL 0x78
  89 #endif
  90 #endif
  91
  92 #ifndef R_N0SEL
  93 #define R_N0SEL 0xd8
  94 #endif
  95
  96 #ifndef R_N1SEL
  97 #define R_N1SEL 0xd9
  98 #endif
  99
 100 /* Various structures and types used internally in tc-hppa.c.  */
 101
 102 /* Unwind table and descriptor.  FIXME: Sync this with GDB version.  */
 103
 104 struct unwind_desc
 105   {
 106     unsigned int cannot_unwind:1;
 107     unsigned int millicode:1;
 108     unsigned int millicode_save_rest:1;
 109     unsigned int region_desc:2;
 110     unsigned int save_sr:2;
 111     unsigned int entry_fr:4;
 112     unsigned int entry_gr:5;
 113     unsigned int args_stored:1;
 114     unsigned int call_fr:5;
 115     unsigned int call_gr:5;
 116     unsigned int save_sp:1;
 117     unsigned int save_rp:1;
 118     unsigned int save_rp_in_frame:1;
 119     unsigned int extn_ptr_defined:1;
 120     unsigned int cleanup_defined:1;
 121
 122     unsigned int hpe_interrupt_marker:1;
 123     unsigned int hpux_interrupt_marker:1;
 124     unsigned int reserved:3;
 125     unsigned int frame_size:27;
 126   };
 127
 128 struct unwind_table
 129   {
 130     /* Starting and ending offsets of the region described by
 131        descriptor.  */
 132     unsigned int start_offset;
 133     unsigned int end_offset;
 134     struct unwind_desc descriptor;
 135   };
 136
 137 /* This structure is used by the .callinfo, .enter, .leave pseudo-ops to
 138    control the entry and exit code they generate. It is also used in
 139    creation of the correct stack unwind descriptors.
 140
 141    NOTE:  GAS does not support .enter and .leave for the generation of
 142    prologues and epilogues.  FIXME.
 143
 144    The fields in structure roughly correspond to the arguments available on the
 145    .callinfo pseudo-op.  */
 146
 147 struct call_info
 148   {
 149     /* The unwind descriptor being built.  */
 150     struct unwind_table ci_unwind;
 151
 152     /* Name of this function.  */
 153     symbolS *start_symbol;
 154
 155     /* (temporary) symbol used to mark the end of this function.  */
 156     symbolS *end_symbol;
 157
 158     /* Next entry in the chain.  */
 159     struct call_info *ci_next;
 160   };
 161
 162 /* Operand formats for FP instructions.   Note not all FP instructions
 163    allow all four formats to be used (for example fmpysub only allows
 164    SGL and DBL).  */
 165 typedef enum
 166   {
 167     SGL, DBL, ILLEGAL_FMT, QUAD, W, UW, DW, UDW, QW, UQW
 168   }
 169 fp_operand_format;
 170
 171 /* This fully describes the symbol types which may be attached to
 172    an EXPORT or IMPORT directive.  Only SOM uses this formation
 173    (ELF has no need for it).  */
 174 typedef enum
 175   {
 176     SYMBOL_TYPE_UNKNOWN,
 177     SYMBOL_TYPE_ABSOLUTE,
 178     SYMBOL_TYPE_CODE,
 179     SYMBOL_TYPE_DATA,
 180     SYMBOL_TYPE_ENTRY,
 181     SYMBOL_TYPE_MILLICODE,
 182     SYMBOL_TYPE_PLABEL,
 183     SYMBOL_TYPE_PRI_PROG,
 184     SYMBOL_TYPE_SEC_PROG,
 185   }
 186 pa_symbol_type;
 187
 188 /* This structure contains information needed to assemble
 189    individual instructions.  */
 190 struct pa_it
 191   {
 192     /* Holds the opcode after parsing by pa_ip.  */
 193     unsigned long opcode;
 194
 195     /* Holds an expression associated with the current instruction.  */
 196     expressionS exp;
 197
 198     /* Does this instruction use PC-relative addressing.  */
 199     int pcrel;
 200
 201     /* Floating point formats for operand1 and operand2.  */
 202     fp_operand_format fpof1;
 203     fp_operand_format fpof2;
 204
 205
 206     /* Holds the field selector for this instruction
 207        (for example L%, LR%, etc).  */
 208     long field_selector;
 209
 210     /* Holds any argument relocation bits associated with this
 211        instruction.  (instruction should be some sort of call).  */
 212     long arg_reloc;
 213
 214     /* The format specification for this instruction.  */
 215     int format;
 216
 217     /* The relocation (if any) associated with this instruction.  */
 218     reloc_type reloc;
 219   };
 220
 221 /* PA-89 floating point registers are arranged like this:
 222
 223
 224    +--------------+--------------+
 225    |   0 or 16L   |  16 or 16R   |
 226    +--------------+--------------+
 227    |   1 or 17L   |  17 or 17R   |
 228    +--------------+--------------+
 229    |              |              |
 230
 231    .              .              .
 232    .              .              .
 233    .              .              .
 234
 235    |              |              |
 236    +--------------+--------------+
 237    |  14 or 30L   |  30 or 30R   |
 238    +--------------+--------------+
 239    |  15 or 31L   |  31 or 31R   |
 240    +--------------+--------------+
 241
 242
 243    The following is a version of pa_parse_number that
 244    handles the L/R notation and returns the correct
 245    value to put into the instruction register field.
 246    The correct value to put into the instruction is
 247    encoded in the structure 'pa_11_fp_reg_struct'.  */
 248
 249 struct pa_11_fp_reg_struct
 250   {
 251     /* The register number.  */
 252     char number_part;
 253
 254     /* L/R selector.  */
 255     char l_r_select;
 256   };
 257
 258 /* Additional information needed to build argument relocation stubs.  */
 259 struct call_desc
 260   {
 261     /* The argument relocation specification.  */
 262     unsigned int arg_reloc;
 263
 264     /* Number of arguments.  */
 265     unsigned int arg_count;
 266   };
 267
 268 #ifdef OBJ_SOM
 269 /* This structure defines an entry in the subspace dictionary
 270    chain.  */
 271
 272 struct subspace_dictionary_chain
 273   {
 274     /* Nonzero if this space has been defined by the user code.  */
 275     unsigned int ssd_defined;
 276
 277     /* Name of this subspace.  */
 278     char *ssd_name;
 279
 280     /* GAS segment and subsegment associated with this subspace.  */
 281     asection *ssd_seg;
 282     int ssd_subseg;
 283
 284     /* Next space in the subspace dictionary chain.  */
 285     struct subspace_dictionary_chain *ssd_next;
 286   };
 287
 288 typedef struct subspace_dictionary_chain ssd_chain_struct;
 289
 290 /* This structure defines an entry in the subspace dictionary
 291    chain.  */
 292
 293 struct space_dictionary_chain
 294   {
 295     /* Nonzero if this space has been defined by the user code or
 296        as a default space.  */
 297     unsigned int sd_defined;
 298
 299     /* Nonzero if this spaces has been defined by the user code.  */
 300     unsigned int sd_user_defined;
 301
 302     /* The space number (or index).  */
 303     unsigned int sd_spnum;
 304
 305     /* The name of this subspace.  */
 306     char *sd_name;
 307
 308     /* GAS segment to which this subspace corresponds.  */
 309     asection *sd_seg;
 310
 311     /* Current subsegment number being used.  */
 312     int sd_last_subseg;
 313
 314     /* The chain of subspaces contained within this space.  */
 315     ssd_chain_struct *sd_subspaces;
 316
 317     /* The next entry in the space dictionary chain.  */
 318     struct space_dictionary_chain *sd_next;
 319   };
 320
 321 typedef struct space_dictionary_chain sd_chain_struct;
 322
 323 /* This structure defines attributes of the default subspace
 324    dictionary entries.  */
 325
 326 struct default_subspace_dict
 327   {
 328     /* Name of the subspace.  */
 329     char *name;
 330
 331     /* FIXME.  Is this still needed?  */
 332     char defined;
 333
 334     /* Nonzero if this subspace is loadable.  */
 335     char loadable;
 336
 337     /* Nonzero if this subspace contains only code.  */
 338     char code_only;
 339
 340     /* Nonzero if this is a common subspace.  */
 341     char common;
 342
 343     /* Nonzero if this is a common subspace which allows symbols
 344        to be multiply defined.  */
 345     char dup_common;
 346
 347     /* Nonzero if this subspace should be zero filled.  */
 348     char zero;
 349
 350     /* Sort key for this subspace.  */
 351     unsigned char sort;
 352
 353     /* Access control bits for this subspace.  Can represent RWX access
 354        as well as privilege level changes for gateways.  */
 355     int access;
 356
 357     /* Index of containing space.  */
 358     int space_index;
 359
 360     /* Alignment (in bytes) of this subspace.  */
 361     int alignment;
 362
 363     /* Quadrant within space where this subspace should be loaded.  */
 364     int quadrant;
 365
 366     /* An index into the default spaces array.  */
 367     int def_space_index;
 368
 369     /* Subsegment associated with this subspace.  */
 370     subsegT subsegment;
 371   };
 372
 373 /* This structure defines attributes of the default space
 374    dictionary entries.  */
 375
 376 struct default_space_dict
 377   {
 378     /* Name of the space.  */
 379     char *name;
 380
 381     /* Space number.  It is possible to identify spaces within
 382        assembly code numerically!  */
 383     int spnum;
 384
 385     /* Nonzero if this space is loadable.  */
 386     char loadable;
 387
 388     /* Nonzero if this space is "defined".  FIXME is still needed */
 389     char defined;
 390
 391     /* Nonzero if this space can not be shared.  */
 392     char private;
 393
 394     /* Sort key for this space.  */
 395     unsigned char sort;
 396
 397     /* Segment associated with this space.  */
 398     asection *segment;
 399   };
 400 #endif
 401
 402 /* Structure for previous label tracking.  Needed so that alignments,
 403    callinfo declarations, etc can be easily attached to a particular
 404    label.  */
 405 typedef struct label_symbol_struct
 406   {
 407     struct symbol *lss_label;
 408 #ifdef OBJ_SOM
 409     sd_chain_struct *lss_space;
 410 #endif
 411 #ifdef OBJ_ELF
 412     segT lss_segment;
 413 #endif
 414     struct label_symbol_struct *lss_next;
 415   }
 416 label_symbol_struct;
 417
 418 /* Extra information needed to perform fixups (relocations) on the PA.  */
 419 struct hppa_fix_struct
 420   {
 421     /* The field selector.  */
 422     enum hppa_reloc_field_selector_type_alt fx_r_field;
 423
 424     /* Type of fixup.  */
 425     int fx_r_type;
 426
 427     /* Format of fixup.  */
 428     int fx_r_format;
 429
 430     /* Argument relocation bits.  */
 431     long fx_arg_reloc;
 432
 433     /* The segment this fixup appears in.  */
 434     segT segment;
 435   };
 436
 437 /* Structure to hold information about predefined registers.  */
 438
 439 struct pd_reg
 440   {
 441     char *name;
 442     int value;
 443   };
 444
 445 /* This structure defines the mapping from a FP condition string
 446    to a condition number which can be recorded in an instruction.  */
 447 struct fp_cond_map
 448   {
 449     char *string;
 450     int cond;
 451   };
 452
 453 /* This structure defines a mapping from a field selector
 454    string to a field selector type.  */
 455 struct selector_entry
 456   {
 457     char *prefix;
 458     int field_selector;
 459   };
 460
 461 /* Prototypes for functions local to tc-hppa.c.  */
 462
 463 #ifdef OBJ_SOM
 464 static void pa_check_current_space_and_subspace PARAMS ((void));
 465 #endif
 466
 467 static fp_operand_format pa_parse_fp_format PARAMS ((char **s));
 468 static void pa_cons PARAMS ((int));
 469 static void pa_data PARAMS ((int));
 470 static void pa_float_cons PARAMS ((int));
 471 static void pa_fill PARAMS ((int));
 472 static void pa_lcomm PARAMS ((int));
 473 static void pa_lsym PARAMS ((int));
 474 static void pa_stringer PARAMS ((int));
 475 static void pa_text PARAMS ((int));
 476 static void pa_version PARAMS ((int));
 477 static int pa_parse_fp_cmp_cond PARAMS ((char **));
 478 static int get_expression PARAMS ((char *));
 479 static int pa_get_absolute_expression PARAMS ((struct pa_it *, char **));
 480 static int evaluate_absolute PARAMS ((struct pa_it *));
 481 static unsigned int pa_build_arg_reloc PARAMS ((char *));
 482 static unsigned int pa_align_arg_reloc PARAMS ((unsigned int, unsigned int));
 483 static int pa_parse_nullif PARAMS ((char **));
 484 static int pa_parse_nonneg_cmpsub_cmpltr PARAMS ((char **, int));
 485 static int pa_parse_neg_cmpsub_cmpltr PARAMS ((char **, int));
 486 static int pa_parse_neg_add_cmpltr PARAMS ((char **, int));
 487 static int pa_parse_nonneg_add_cmpltr PARAMS ((char **, int));
 488 static void pa_block PARAMS ((int));
 489 static void pa_brtab PARAMS ((int));
 490 static void pa_try PARAMS ((int));
 491 static void pa_call PARAMS ((int));
 492 static void pa_call_args PARAMS ((struct call_desc *));
 493 static void pa_callinfo PARAMS ((int));
 494 static void pa_code PARAMS ((int));
 495 static void pa_comm PARAMS ((int));
 496 static void pa_copyright PARAMS ((int));
 497 static void pa_end PARAMS ((int));
 498 static void pa_enter PARAMS ((int));
 499 static void pa_entry PARAMS ((int));
 500 static void pa_equ PARAMS ((int));
 501 static void pa_exit PARAMS ((int));
 502 static void pa_export PARAMS ((int));
 503 static void pa_type_args PARAMS ((symbolS *, int));
 504 static void pa_import PARAMS ((int));
 505 static void pa_label PARAMS ((int));
 506 static void pa_leave PARAMS ((int));
 507 static void pa_level PARAMS ((int));
 508 static void pa_origin PARAMS ((int));
 509 static void pa_proc PARAMS ((int));
 510 static void pa_procend PARAMS ((int));
 511 static void pa_param PARAMS ((int));
 512 static void pa_undefine_label PARAMS ((void));
 513 static int need_pa11_opcode PARAMS ((struct pa_it *,
 514                                      struct pa_11_fp_reg_struct *));
 515 static int pa_parse_number PARAMS ((char **, struct pa_11_fp_reg_struct *));
 516 static label_symbol_struct *pa_get_label PARAMS ((void));
 517 #ifdef OBJ_SOM
 518 static void pa_compiler PARAMS ((int));
 519 static void pa_align PARAMS ((int));
 520 static void pa_space PARAMS ((int));
 521 static void pa_spnum PARAMS ((int));
 522 static void pa_subspace PARAMS ((int));
 523 static sd_chain_struct *create_new_space PARAMS ((char *, int, int,
 524                                                   int, int, int,
 525                                                   asection *, int));
 526 static ssd_chain_struct *create_new_subspace PARAMS ((sd_chain_struct *,
 527                                                       char *, int, int,
 528                                                       int, int, int,
 529                                                       int, int, int, int,
 530                                                       int, asection *));
 531 static ssd_chain_struct *update_subspace PARAMS ((sd_chain_struct *,
 532                                                   char *, int, int, int,
 533                                                   int, int, int, int,
 534                                                   int, int, int,
 535                                                   asection *));
 536 static sd_chain_struct *is_defined_space PARAMS ((char *));
 537 static ssd_chain_struct *is_defined_subspace PARAMS ((char *));
 538 static sd_chain_struct *pa_segment_to_space PARAMS ((asection *));
 539 static ssd_chain_struct *pa_subsegment_to_subspace PARAMS ((asection *,
 540                                                             subsegT));
 541 static sd_chain_struct *pa_find_space_by_number PARAMS ((int));
 542 static unsigned int pa_subspace_start PARAMS ((sd_chain_struct *, int));
 543 static sd_chain_struct *pa_parse_space_stmt PARAMS ((char *, int));
 544 static int pa_next_subseg PARAMS ((sd_chain_struct *));
 545 static void pa_spaces_begin PARAMS ((void));
 546 #endif
 547 static void pa_ip PARAMS ((char *));
 548 static void fix_new_hppa PARAMS ((fragS *, int, int, symbolS *,
 549                                   long, expressionS *, int,
 550                                   bfd_reloc_code_real_type,
 551                                   enum hppa_reloc_field_selector_type_alt,
 552                                   int, long, int *));
 553 static int is_end_of_statement PARAMS ((void));
 554 static int reg_name_search PARAMS ((char *));
 555 static int pa_chk_field_selector PARAMS ((char **));
 556 static int is_same_frag PARAMS ((fragS *, fragS *));
 557 static void process_exit PARAMS ((void));
 558 static int log2 PARAMS ((int));
 559 static unsigned int pa_stringer_aux PARAMS ((char *));
 560
 561 #ifdef OBJ_ELF
 562 static void hppa_elf_mark_end_of_function PARAMS ((void));
 563 static void pa_build_unwind_subspace PARAMS ((struct call_info *));
 564 #endif
 565
 566 /* File and gloally scoped variable declarations.  */
 567
 568 #ifdef OBJ_SOM
 569 /* Root and final entry in the space chain.  */
 570 static sd_chain_struct *space_dict_root;
 571 static sd_chain_struct *space_dict_last;
 572
 573 /* The current space and subspace.  */
 574 static sd_chain_struct *current_space;
 575 static ssd_chain_struct *current_subspace;
 576 #endif
 577
 578 /* Root of the call_info chain.  */
 579 static struct call_info *call_info_root;
 580
 581 /* The last call_info (for functions) structure
 582    seen so it can be associated with fixups and
 583    function labels.  */
 584 static struct call_info *last_call_info;
 585
 586 /* The last call description (for actual calls).  */
 587 static struct call_desc last_call_desc;
 588
 589 /* handle of the OPCODE hash table */
 590 static struct hash_control *op_hash = NULL;
 591
 592 /* This array holds the chars that always start a comment.  If the
 593    pre-processor is disabled, these aren't very useful.  */
 594 const char comment_chars[] = ";";
 595
 596 /* Table of pseudo ops for the PA.  FIXME -- how many of these
 597    are now redundant with the overall GAS and the object file
 598    dependent tables?  */
 599 const pseudo_typeS md_pseudo_table[] =
 600 {
 601   /* align pseudo-ops on the PA specify the actual alignment requested,
 602      not the log2 of the requested alignment.  */
 603 #ifdef OBJ_SOM
 604   {"align", pa_align, 8},
 605 #endif
 606 #ifdef OBJ_ELF
 607   {"align", s_align_bytes, 8},
 608 #endif
 609   {"begin_brtab", pa_brtab, 1},
 610   {"begin_try", pa_try, 1},
 611   {"block", pa_block, 1},
 612   {"blockz", pa_block, 0},
 613   {"byte", pa_cons, 1},
 614   {"call", pa_call, 0},
 615   {"callinfo", pa_callinfo, 0},
 616   {"code", pa_code, 0},
 617   {"comm", pa_comm, 0},
 618 #ifdef OBJ_SOM
 619   {"compiler", pa_compiler, 0},
 620 #endif
 621   {"copyright", pa_copyright, 0},
 622   {"data", pa_data, 0},
 623   {"double", pa_float_cons, 'd'},
 624   {"dword", pa_cons, 8},
 625   {"end", pa_end, 0},
 626   {"end_brtab", pa_brtab, 0},
 627   {"end_try", pa_try, 0},
 628   {"enter", pa_enter, 0},
 629   {"entry", pa_entry, 0},
 630   {"equ", pa_equ, 0},
 631   {"exit", pa_exit, 0},
 632   {"export", pa_export, 0},
 633   {"fill", pa_fill, 0},
 634   {"float", pa_float_cons, 'f'},
 635   {"half", pa_cons, 2},
 636   {"import", pa_import, 0},
 637   {"int", pa_cons, 4},
 638   {"label", pa_label, 0},
 639   {"lcomm", pa_lcomm, 0},
 640   {"leave", pa_leave, 0},
 641   {"level", pa_level, 0},
 642   {"long", pa_cons, 4},
 643   {"lsym", pa_lsym, 0},
 644 #ifdef OBJ_SOM
 645   {"nsubspa", pa_subspace, 1},
 646 #endif
 647   {"octa", pa_cons, 16},
 648   {"org", pa_origin, 0},
 649   {"origin", pa_origin, 0},
 650   {"param", pa_param, 0},
 651   {"proc", pa_proc, 0},
 652   {"procend", pa_procend, 0},
 653   {"quad", pa_cons, 8},
 654   {"reg", pa_equ, 1},
 655   {"short", pa_cons, 2},
 656   {"single", pa_float_cons, 'f'},
 657 #ifdef OBJ_SOM
 658   {"space", pa_space, 0},
 659   {"spnum", pa_spnum, 0},
 660 #endif
 661   {"string", pa_stringer, 0},
 662   {"stringz", pa_stringer, 1},
 663 #ifdef OBJ_SOM
 664   {"subspa", pa_subspace, 0},
 665 #endif
 666   {"text", pa_text, 0},
 667   {"version", pa_version, 0},
 668   {"word", pa_cons, 4},
 669   {NULL, 0, 0}
 670 };
 671
 672 /* This array holds the chars that only start a comment at the beginning of
 673    a line.  If the line seems to have the form '# 123 filename'
 674    .line and .file directives will appear in the pre-processed output.
 675
 676    Note that input_file.c hand checks for '#' at the beginning of the
 677    first line of the input file.  This is because the compiler outputs
 678    #NO_APP at the beginning of its output.
 679
 680    Also note that C style comments will always work. */
 681 const char line_comment_chars[] = "#";
 682
 683 /* This array holds the characters which act as line separators.  */
 684 const char line_separator_chars[] = "!";
 685
 686 /* Chars that can be used to separate mant from exp in floating point nums.  */
 687 const char EXP_CHARS[] = "eE";
 688
 689 /* Chars that mean this number is a floating point constant.
 690    As in 0f12.456 or 0d1.2345e12.
 691
 692    Be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
 693    changed in read.c.  Ideally it shouldn't hae to know abou it at
 694    all, but nothing is ideal around here.  */
 695 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 696
 697 static struct pa_it the_insn;
 698
 699 /* Points to the end of an expression just parsed by get_expressoin
 700    and friends.  FIXME.  This shouldn't be handled with a file-global
 701    variable.  */
 702 static char *expr_end;
 703
 704 /* Nonzero if a .callinfo appeared within the current procedure.  */
 705 static int callinfo_found;
 706
 707 /* Nonzero if the assembler is currently within a .entry/.exit pair.  */
 708 static int within_entry_exit;
 709
 710 /* Nonzero if the assembler is currently within a procedure definition.  */
 711 static int within_procedure;
 712
 713 /* Handle on strucutre which keep track of the last symbol
 714    seen in each subspace.  */
 715 static label_symbol_struct *label_symbols_rootp = NULL;
 716
 717 /* Holds the last field selector.  */
 718 static int hppa_field_selector;
 719
 720 #ifdef OBJ_SOM
 721 /* A dummy bfd symbol so that all relocations have symbols of some kind.  */
 722 static symbolS *dummy_symbol;
 723 #endif
 724
 725 /* Nonzero if errors are to be printed.  */
 726 static int print_errors = 1;
 727
 728 /* List of registers that are pre-defined:
 729
 730    Each general register has one predefined name of the form
 731    %r<REGNUM> which has the value <REGNUM>.
 732
 733    Space and control registers are handled in a similar manner,
 734    but use %sr<REGNUM> and %cr<REGNUM> as their predefined names.
 735
 736    Likewise for the floating point registers, but of the form
 737    %fr<REGNUM>.  Floating point registers have additional predefined
 738    names with 'L' and 'R' suffixes (e.g. %fr19L, %fr19R) which
 739    again have the value <REGNUM>.
 740
 741    Many registers also have synonyms:
 742
 743    %r26 - %r23 have %arg0 - %arg3 as synonyms
 744    %r28 - %r29 have %ret0 - %ret1 as synonyms
 745    %r30 has %sp as a synonym
 746    %r27 has %dp as a synonym
 747    %r2  has %rp as a synonym
 748
 749    Almost every control register has a synonym; they are not listed
 750    here for brevity.
 751
 752    The table is sorted. Suitable for searching by a binary search. */
 753
 754 static const struct pd_reg pre_defined_registers[] =
 755 {
 756   {"%arg0", 26},
 757   {"%arg1", 25},
 758   {"%arg2", 24},
 759   {"%arg3", 23},
 760   {"%cr0", 0},
 761   {"%cr10", 10},
 762   {"%cr11", 11},
 763   {"%cr12", 12},
 764   {"%cr13", 13},
 765   {"%cr14", 14},
 766   {"%cr15", 15},
 767   {"%cr16", 16},
 768   {"%cr17", 17},
 769   {"%cr18", 18},
 770   {"%cr19", 19},
 771   {"%cr20", 20},
 772   {"%cr21", 21},
 773   {"%cr22", 22},
 774   {"%cr23", 23},
 775   {"%cr24", 24},
 776   {"%cr25", 25},
 777   {"%cr26", 26},
 778   {"%cr27", 27},
 779   {"%cr28", 28},
 780   {"%cr29", 29},
 781   {"%cr30", 30},
 782   {"%cr31", 31},
 783   {"%cr8", 8},
 784   {"%cr9", 9},
 785   {"%dp", 27},
 786   {"%eiem", 15},
 787   {"%eirr", 23},
 788   {"%fr0", 0},
 789   {"%fr0l", 0},
 790   {"%fr0r", 0},
 791   {"%fr1", 1},
 792   {"%fr10", 10},
 793   {"%fr10l", 10},
 794   {"%fr10r", 10},
 795   {"%fr11", 11},
 796   {"%fr11l", 11},
 797   {"%fr11r", 11},
 798   {"%fr12", 12},
 799   {"%fr12l", 12},
 800   {"%fr12r", 12},
 801   {"%fr13", 13},
 802   {"%fr13l", 13},
 803   {"%fr13r", 13},
 804   {"%fr14", 14},
 805   {"%fr14l", 14},
 806   {"%fr14r", 14},
 807   {"%fr15", 15},
 808   {"%fr15l", 15},
 809   {"%fr15r", 15},
 810   {"%fr16", 16},
 811   {"%fr16l", 16},
 812   {"%fr16r", 16},
 813   {"%fr17", 17},
 814   {"%fr17l", 17},
 815   {"%fr17r", 17},
 816   {"%fr18", 18},
 817   {"%fr18l", 18},
 818   {"%fr18r", 18},
 819   {"%fr19", 19},
 820   {"%fr19l", 19},
 821   {"%fr19r", 19},
 822   {"%fr1l", 1},
 823   {"%fr1r", 1},
 824   {"%fr2", 2},
 825   {"%fr20", 20},
 826   {"%fr20l", 20},
 827   {"%fr20r", 20},
 828   {"%fr21", 21},
 829   {"%fr21l", 21},
 830   {"%fr21r", 21},
 831   {"%fr22", 22},
 832   {"%fr22l", 22},
 833   {"%fr22r", 22},
 834   {"%fr23", 23},
 835   {"%fr23l", 23},
 836   {"%fr23r", 23},
 837   {"%fr24", 24},
 838   {"%fr24l", 24},
 839   {"%fr24r", 24},
 840   {"%fr25", 25},
 841   {"%fr25l", 25},
 842   {"%fr25r", 25},
 843   {"%fr26", 26},
 844   {"%fr26l", 26},
 845   {"%fr26r", 26},
 846   {"%fr27", 27},
 847   {"%fr27l", 27},
 848   {"%fr27r", 27},
 849   {"%fr28", 28},
 850   {"%fr28l", 28},
 851   {"%fr28r", 28},
 852   {"%fr29", 29},
 853   {"%fr29l", 29},
 854   {"%fr29r", 29},
 855   {"%fr2l", 2},
 856   {"%fr2r", 2},
 857   {"%fr3", 3},
 858   {"%fr30", 30},
 859   {"%fr30l", 30},
 860   {"%fr30r", 30},
 861   {"%fr31", 31},
 862   {"%fr31l", 31},
 863   {"%fr31r", 31},
 864   {"%fr3l", 3},
 865   {"%fr3r", 3},
 866   {"%fr4", 4},
 867   {"%fr4l", 4},
 868   {"%fr4r", 4},
 869   {"%fr5", 5},
 870   {"%fr5l", 5},
 871   {"%fr5r", 5},
 872   {"%fr6", 6},
 873   {"%fr6l", 6},
 874   {"%fr6r", 6},
 875   {"%fr7", 7},
 876   {"%fr7l", 7},
 877   {"%fr7r", 7},
 878   {"%fr8", 8},
 879   {"%fr8l", 8},
 880   {"%fr8r", 8},
 881   {"%fr9", 9},
 882   {"%fr9l", 9},
 883   {"%fr9r", 9},
 884   {"%hta", 25},
 885   {"%iir", 19},
 886   {"%ior", 21},
 887   {"%ipsw", 22},
 888   {"%isr", 20},
 889   {"%itmr", 16},
 890   {"%iva", 14},
 891   {"%pcoq", 18},
 892   {"%pcsq", 17},
 893   {"%pidr1", 8},
 894   {"%pidr2", 9},
 895   {"%pidr3", 12},
 896   {"%pidr4", 13},
 897   {"%ppda", 24},
 898   {"%r0", 0},
 899   {"%r1", 1},
 900   {"%r10", 10},
 901   {"%r11", 11},
 902   {"%r12", 12},
 903   {"%r13", 13},
 904   {"%r14", 14},
 905   {"%r15", 15},
 906   {"%r16", 16},
 907   {"%r17", 17},
 908   {"%r18", 18},
 909   {"%r19", 19},
 910   {"%r2", 2},
 911   {"%r20", 20},
 912   {"%r21", 21},
 913   {"%r22", 22},
 914   {"%r23", 23},
 915   {"%r24", 24},
 916   {"%r25", 25},
 917   {"%r26", 26},
 918   {"%r27", 27},
 919   {"%r28", 28},
 920   {"%r29", 29},
 921   {"%r3", 3},
 922   {"%r30", 30},
 923   {"%r31", 31},
 924   {"%r4", 4},
 925   {"%r5", 5},
 926   {"%r6", 6},
 927   {"%r7", 7},
 928   {"%r8", 8},
 929   {"%r9", 9},
 930   {"%rctr", 0},
 931   {"%ret0", 28},
 932   {"%ret1", 29},
 933   {"%rp", 2},
 934   {"%sar", 11},
 935   {"%sp", 30},
 936   {"%sr0", 0},
 937   {"%sr1", 1},
 938   {"%sr2", 2},
 939   {"%sr3", 3},
 940   {"%sr4", 4},
 941   {"%sr5", 5},
 942   {"%sr6", 6},
 943   {"%sr7", 7},
 944   {"%tr0", 24},
 945   {"%tr1", 25},
 946   {"%tr2", 26},
 947   {"%tr3", 27},
 948   {"%tr4", 28},
 949   {"%tr5", 29},
 950   {"%tr6", 30},
 951   {"%tr7", 31}
 952 };
 953
 954 /* This table is sorted by order of the length of the string. This is
 955    so we check for <> before we check for <. If we had a <> and checked
 956    for < first, we would get a false match.  */
 957 static const struct fp_cond_map fp_cond_map[] =
 958 {
 959   {"false?", 0},
 960   {"false", 1},
 961   {"true?", 30},
 962   {"true", 31},
 963   {"!<=>", 3},
 964   {"!?>=", 8},
 965   {"!?<=", 16},
 966   {"!<>", 7},
 967   {"!>=", 11},
 968   {"!?>", 12},
 969   {"?<=", 14},
 970   {"!<=", 19},
 971   {"!?<", 20},
 972   {"?>=", 22},
 973   {"!?=", 24},
 974   {"!=t", 27},
 975   {"<=>", 29},
 976   {"=t", 5},
 977   {"?=", 6},
 978   {"?<", 10},
 979   {"<=", 13},
 980   {"!>", 15},
 981   {"?>", 18},
 982   {">=", 21},
 983   {"!<", 23},
 984   {"<>", 25},
 985   {"!=", 26},
 986   {"!?", 28},
 987   {"?", 2},
 988   {"=", 4},
 989   {"<", 9},
 990   {">", 17}
 991 };
 992
 993 static const struct selector_entry selector_table[] =
 994 {
 995   {"f", e_fsel},
 996   {"l", e_lsel},
 997   {"ld", e_ldsel},
 998   {"lp", e_lpsel},
 999   {"lr", e_lrsel},
1000   {"ls", e_lssel},
1001   {"lt", e_ltsel},
1002   {"ltp", e_ltpsel},
1003   {"n", e_nsel},
1004   {"nl", e_nlsel},
1005   {"nlr", e_nlrsel},
1006   {"p", e_psel},
1007   {"r", e_rsel},
1008   {"rd", e_rdsel},
1009   {"rp", e_rpsel},
1010   {"rr", e_rrsel},
1011   {"rs", e_rssel},
1012   {"rt", e_rtsel},
1013   {"rtp", e_rtpsel},
1014   {"t", e_tsel},
1015 };
1016
1017 #ifdef OBJ_SOM
1018 /* default space and subspace dictionaries */
1019
1020 #define GDB_SYMBOLS          GDB_SYMBOLS_SUBSPACE_NAME
1021 #define GDB_STRINGS          GDB_STRINGS_SUBSPACE_NAME
1022
1023 /* pre-defined subsegments (subspaces) for the HPPA.  */
1024 #define SUBSEG_CODE   0
1025 #define SUBSEG_LIT    1
1026 #define SUBSEG_MILLI  2
1027 #define SUBSEG_DATA   0
1028 #define SUBSEG_BSS    2
1029 #define SUBSEG_UNWIND 3
1030 #define SUBSEG_GDB_STRINGS 0
1031 #define SUBSEG_GDB_SYMBOLS 1
1032
1033 static struct default_subspace_dict pa_def_subspaces[] =
1034 {
1035   {"$CODE$", 1, 1, 1, 0, 0, 0, 24, 0x2c, 0, 8, 0, 0, SUBSEG_CODE},
1036   {"$DATA$", 1, 1, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, SUBSEG_DATA},
1037   {"$LIT$", 1, 1, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, SUBSEG_LIT},
1038   {"$MILLICODE$", 1, 1, 0, 0, 0, 0, 8, 0x2c, 0, 8, 0, 0, SUBSEG_MILLI},
1039   {"$BSS$", 1, 1, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, SUBSEG_BSS},
1040   {NULL, 0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
1041 };
1042
1043 static struct default_space_dict pa_def_spaces[] =
1044 {
1045   {"$TEXT$", 0, 1, 1, 0, 8, ASEC_NULL},
1046   {"$PRIVATE$", 1, 1, 1, 1, 16, ASEC_NULL},
1047   {NULL, 0, 0, 0, 0, 0, ASEC_NULL}
1048 };
1049
1050 /* Misc local definitions used by the assembler.  */
1051
1052 /* These macros are used to maintain spaces/subspaces.  */
1053 #define SPACE_DEFINED(space_chain)      (space_chain)->sd_defined
1054 #define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
1055 #define SPACE_SPNUM(space_chain)        (space_chain)->sd_spnum
1056 #define SPACE_NAME(space_chain)         (space_chain)->sd_name
1057
1058 #define SUBSPACE_DEFINED(ss_chain)      (ss_chain)->ssd_defined
1059 #define SUBSPACE_NAME(ss_chain)         (ss_chain)->ssd_name
1060 #endif
1061
1062 /* Return nonzero if the string pointed to by S potentially represents
1063    a right or left half of a FP register  */
1064 #define IS_R_SELECT(S)   (*(S) == 'R' || *(S) == 'r')
1065 #define IS_L_SELECT(S)   (*(S) == 'L' || *(S) == 'l')
1066
1067 /* Insert FIELD into OPCODE starting at bit START.  Continue pa_ip
1068    main loop after insertion.  */
1069
1070 #define INSERT_FIELD_AND_CONTINUE(OPCODE, FIELD, START) \
1071   { \
1072     ((OPCODE) |= (FIELD) << (START)); \
1073     continue; \
1074   }
1075
1076 /* Simple range checking for FIELD againt HIGH and LOW bounds.
1077    IGNORE is used to suppress the error message.  */
1078
1079 #define CHECK_FIELD(FIELD, HIGH, LOW, IGNORE) \
1080   { \
1081     if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1082       { \
1083         if (! IGNORE) \
1084           as_bad (_("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1085                   (int) (FIELD));\
1086         break; \
1087       } \
1088   }
1089
1090 #define is_DP_relative(exp)                     \
1091   ((exp).X_op == O_subtract                     \
1092    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$global$") == 0)
1093
1094 #define is_PC_relative(exp)                     \
1095   ((exp).X_op == O_subtract                     \
1096    && strcmp (S_GET_NAME ((exp).X_op_symbol), "$PIC_pcrel$0") == 0)
1097
1098 /* We need some complex handling for stabs (sym1 - sym2).  Luckily, we'll
1099    always be able to reduce the expression to a constant, so we don't
1100    need real complex handling yet.  */
1101 #define is_complex(exp)                         \
1102   ((exp).X_op != O_constant && (exp).X_op != O_symbol)
1103
1104 /* Actual functions to implement the PA specific code for the assembler.  */
1105
1106 /* Called before writing the object file.  Make sure entry/exit and
1107    proc/procend pairs match.  */
1108
1109 void
1110 pa_check_eof ()
1111 {
1112   if (within_entry_exit)
1113     as_fatal (_("Missing .exit\n"));
1114
1115   if (within_procedure)
1116     as_fatal (_("Missing .procend\n"));
1117 }
1118
1119 /* Returns a pointer to the label_symbol_struct for the current space.
1120    or NULL if no label_symbol_struct exists for the current space.  */
1121
1122 static label_symbol_struct *
1123 pa_get_label ()
1124 {
1125   label_symbol_struct *label_chain;
1126
1127   for (label_chain = label_symbols_rootp;
1128        label_chain;
1129        label_chain = label_chain->lss_next)
1130     {
1131 #ifdef OBJ_SOM
1132     if (current_space == label_chain->lss_space && label_chain->lss_label)
1133       return label_chain;
1134 #endif
1135 #ifdef OBJ_ELF
1136     if (now_seg == label_chain->lss_segment && label_chain->lss_label)
1137       return label_chain;
1138 #endif
1139     }
1140
1141   return NULL;
1142 }
1143
1144 /* Defines a label for the current space.  If one is already defined,
1145    this function will replace it with the new label.  */
1146
1147 void
1148 pa_define_label (symbol)
1149      symbolS *symbol;
1150 {
1151   label_symbol_struct *label_chain = pa_get_label ();
1152
1153   if (label_chain)
1154     label_chain->lss_label = symbol;
1155   else
1156     {
1157       /* Create a new label entry and add it to the head of the chain.  */
1158       label_chain
1159         = (label_symbol_struct *) xmalloc (sizeof (label_symbol_struct));
1160       label_chain->lss_label = symbol;
1161 #ifdef OBJ_SOM
1162       label_chain->lss_space = current_space;
1163 #endif
1164 #ifdef OBJ_ELF
1165       label_chain->lss_segment = now_seg;
1166 #endif
1167       label_chain->lss_next = NULL;
1168
1169       if (label_symbols_rootp)
1170         label_chain->lss_next = label_symbols_rootp;
1171
1172       label_symbols_rootp = label_chain;
1173     }
1174 }
1175
1176 /* Removes a label definition for the current space.
1177    If there is no label_symbol_struct entry, then no action is taken.  */
1178
1179 static void
1180 pa_undefine_label ()
1181 {
1182   label_symbol_struct *label_chain;
1183   label_symbol_struct *prev_label_chain = NULL;
1184
1185   for (label_chain = label_symbols_rootp;
1186        label_chain;
1187        label_chain = label_chain->lss_next)
1188     {
1189       if (1
1190 #ifdef OBJ_SOM
1191           && current_space == label_chain->lss_space && label_chain->lss_label
1192 #endif
1193 #ifdef OBJ_ELF
1194           && now_seg == label_chain->lss_segment && label_chain->lss_label
1195 #endif
1196           )
1197         {
1198           /* Remove the label from the chain and free its memory.  */
1199           if (prev_label_chain)
1200             prev_label_chain->lss_next = label_chain->lss_next;
1201           else
1202             label_symbols_rootp = label_chain->lss_next;
1203
1204           free (label_chain);
1205           break;
1206         }
1207       prev_label_chain = label_chain;
1208     }
1209 }
1210
1211
1212 /* An HPPA-specific version of fix_new.  This is required because the HPPA
1213    code needs to keep track of some extra stuff.  Each call to fix_new_hppa
1214    results in the creation of an instance of an hppa_fix_struct.  An
1215    hppa_fix_struct stores the extra information along with a pointer to the
1216    original fixS.  This is attached to the original fixup via the
1217    tc_fix_data field.  */
1218
1219 static void
1220 fix_new_hppa (frag, where, size, add_symbol, offset, exp, pcrel,
1221               r_type, r_field, r_format, arg_reloc, unwind_bits)
1222      fragS *frag;
1223      int where;
1224      int size;
1225      symbolS *add_symbol;
1226      long offset;
1227      expressionS *exp;
1228      int pcrel;
1229      bfd_reloc_code_real_type r_type;
1230      enum hppa_reloc_field_selector_type_alt r_field;
1231      int r_format;
1232      long arg_reloc;
1233      int* unwind_bits;
1234 {
1235   fixS *new_fix;
1236
1237   struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
1238   obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
1239
1240   if (exp != NULL)
1241     new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
1242   else
1243     new_fix = fix_new (frag, where, size, add_symbol, offset, pcrel, r_type);
1244   new_fix->tc_fix_data = (void *) hppa_fix;
1245   hppa_fix->fx_r_type = r_type;
1246   hppa_fix->fx_r_field = r_field;
1247   hppa_fix->fx_r_format = r_format;
1248   hppa_fix->fx_arg_reloc = arg_reloc;
1249   hppa_fix->segment = now_seg;
1250 #ifdef OBJ_SOM
1251   if (r_type == R_ENTRY || r_type == R_EXIT)
1252     new_fix->fx_offset = *unwind_bits;
1253 #endif
1254
1255   /* foo-$global$ is used to access non-automatic storage.  $global$
1256      is really just a marker and has served its purpose, so eliminate
1257      it now so as not to confuse write.c.  */
1258   if (new_fix->fx_subsy
1259       && !strcmp (S_GET_NAME (new_fix->fx_subsy), "$global$"))
1260     new_fix->fx_subsy = NULL;
1261 }
1262
1263 /* Parse a .byte, .word, .long expression for the HPPA.  Called by
1264    cons via the TC_PARSE_CONS_EXPRESSION macro.  */
1265
1266 void
1267 parse_cons_expression_hppa (exp)
1268      expressionS *exp;
1269 {
1270   hppa_field_selector = pa_chk_field_selector (&input_line_pointer);
1271   expression (exp);
1272 }
1273
1274 /* This fix_new is called by cons via TC_CONS_FIX_NEW.
1275    hppa_field_selector is set by the parse_cons_expression_hppa.  */
1276
1277 void
1278 cons_fix_new_hppa (frag, where, size, exp)
1279      fragS *frag;
1280      int where;
1281      int size;
1282      expressionS *exp;
1283 {
1284   unsigned int rel_type;
1285
1286   /* Get a base relocation type.  */
1287   if (is_DP_relative (*exp))
1288     rel_type = R_HPPA_GOTOFF;
1289   else if (is_complex (*exp))
1290     rel_type = R_HPPA_COMPLEX;
1291   else
1292     rel_type = R_HPPA;
1293
1294   if (hppa_field_selector != e_psel && hppa_field_selector != e_fsel)
1295     as_warn (_("Invalid field selector.  Assuming F%%."));
1296
1297   fix_new_hppa (frag, where, size,
1298                 (symbolS *) NULL, (offsetT) 0, exp, 0, rel_type,
1299                 hppa_field_selector, size * 8, 0, NULL);
1300
1301   /* Reset field selector to its default state.  */
1302   hppa_field_selector = 0;
1303 }
1304
1305 /* This function is called once, at assembler startup time.  It should
1306    set up all the tables, etc. that the MD part of the assembler will need.  */
1307
1308 void
1309 md_begin ()
1310 {
1311   const char *retval = NULL;
1312   int lose = 0;
1313   unsigned int i = 0;
1314
1315   last_call_info = NULL;
1316   call_info_root = NULL;
1317
1318   /* Set the default machine type.  */
1319   if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
1320     as_warn (_("could not set architecture and machine"));
1321
1322   /* Folding of text and data segments fails miserably on the PA.
1323      Warn user and disable "-R" option.  */
1324   if (flag_readonly_data_in_text)
1325     {
1326       as_warn (_("-R option not supported on this target."));
1327       flag_readonly_data_in_text = 0;
1328     }
1329
1330 #ifdef OBJ_SOM
1331   pa_spaces_begin ();
1332 #endif
1333
1334   op_hash = hash_new ();
1335
1336   while (i < NUMOPCODES)
1337     {
1338       const char *name = pa_opcodes[i].name;
1339       retval = hash_insert (op_hash, name, (struct pa_opcode *) &pa_opcodes[i]);
1340       if (retval != NULL && *retval != '\0')
1341         {
1342           as_fatal (_("Internal error: can't hash `%s': %s\n"), name, retval);
1343           lose = 1;
1344         }
1345       do
1346         {
1347           if ((pa_opcodes[i].match & pa_opcodes[i].mask)
1348               != pa_opcodes[i].match)
1349             {
1350               fprintf (stderr, _("internal error: losing opcode: `%s' \"%s\"\n"),
1351                        pa_opcodes[i].name, pa_opcodes[i].args);
1352               lose = 1;
1353             }
1354           ++i;
1355         }
1356       while (i < NUMOPCODES && !strcmp (pa_opcodes[i].name, name));
1357     }
1358
1359   if (lose)
1360     as_fatal (_("Broken assembler.  No assembly attempted."));
1361
1362 #ifdef OBJ_SOM
1363   /* SOM will change text_section.  To make sure we never put
1364      anything into the old one switch to the new one now.  */
1365   subseg_set (text_section, 0);
1366 #endif
1367
1368 #ifdef OBJ_SOM
1369   dummy_symbol = symbol_find_or_make ("L$dummy");
1370   S_SET_SEGMENT (dummy_symbol, text_section);
1371   /* Force the symbol to be converted to a real symbol. */
1372   (void) symbol_get_bfdsym (dummy_symbol);
1373 #endif
1374 }
1375
1376 /* Assemble a single instruction storing it into a frag.  */
1377 void
1378 md_assemble (str)
1379      char *str;
1380 {
1381   char *to;
1382
1383   /* The had better be something to assemble.  */
1384   assert (str);
1385
1386   /* If we are within a procedure definition, make sure we've
1387      defined a label for the procedure; handle case where the
1388      label was defined after the .PROC directive.
1389
1390      Note there's not need to diddle with the segment or fragment
1391      for the label symbol in this case.  We have already switched
1392      into the new $CODE$ subspace at this point.  */
1393   if (within_procedure && last_call_info->start_symbol == NULL)
1394     {
1395       label_symbol_struct *label_symbol = pa_get_label ();
1396
1397       if (label_symbol)
1398         {
1399           if (label_symbol->lss_label)
1400             {
1401               last_call_info->start_symbol = label_symbol->lss_label;
1402               symbol_get_bfdsym (label_symbol->lss_label)->flags
1403                 |= BSF_FUNCTION;
1404 #ifdef OBJ_SOM
1405               /* Also handle allocation of a fixup to hold the unwind
1406                  information when the label appears after the proc/procend.  */
1407               if (within_entry_exit)
1408                 {
1409                   char *where = frag_more (0);
1410
1411                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
1412                                 NULL, (offsetT) 0, NULL,
1413                                 0, R_HPPA_ENTRY, e_fsel, 0, 0,
1414                                 (int *)&last_call_info->ci_unwind.descriptor);
1415                 }
1416 #endif
1417             }
1418           else
1419             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
1420         }
1421       else
1422         as_bad (_("Missing function name for .PROC"));
1423     }
1424
1425   /* Assemble the instruction.  Results are saved into "the_insn".  */
1426   pa_ip (str);
1427
1428   /* Get somewhere to put the assembled instrution.  */
1429   to = frag_more (4);
1430
1431   /* Output the opcode. */
1432   md_number_to_chars (to, the_insn.opcode, 4);
1433
1434   /* If necessary output more stuff.  */
1435   if (the_insn.reloc != R_HPPA_NONE)
1436     fix_new_hppa (frag_now, (to - frag_now->fr_literal), 4, NULL,
1437                   (offsetT) 0, &the_insn.exp, the_insn.pcrel,
1438                   the_insn.reloc, the_insn.field_selector,
1439                   the_insn.format, the_insn.arg_reloc, NULL);
1440 }
1441
1442 /* Do the real work for assembling a single instruction.  Store results
1443    into the global "the_insn" variable.  */
1444
1445 static void
1446 pa_ip (str)
1447      char *str;
1448 {
1449   char *error_message = "";
1450   char *s, c, *argstart, *name, *save_s;
1451   const char *args;
1452   int match = FALSE;
1453   int comma = 0;
1454   int cmpltr, nullif, flag, cond, num;
1455   unsigned long opcode;
1456   struct pa_opcode *insn;
1457
1458 #ifdef OBJ_SOM
1459   /* We must have a valid space and subspace.  */
1460   pa_check_current_space_and_subspace ();
1461 #endif
1462
1463   /* Convert everything up to the first whitespace character into lower
1464      case.  */
1465   for (s = str; *s != ' ' && *s != '\t' && *s != '\n' && *s != '\0'; s++)
1466     if (isupper (*s))
1467       *s = tolower (*s);
1468
1469   /* Skip to something interesting.  */
1470   for (s = str; isupper (*s) || islower (*s) || (*s >= '0' && *s <= '3'); ++s)
1471     ;
1472
1473   switch (*s)
1474     {
1475
1476     case '\0':
1477       break;
1478
1479     case ',':
1480       comma = 1;
1481
1482       /*FALLTHROUGH */
1483
1484     case ' ':
1485       *s++ = '\0';
1486       break;
1487
1488     default:
1489       as_fatal (_("Unknown opcode: `%s'"), str);
1490     }
1491
1492   save_s = str;
1493
1494   /* Look up the opcode in the has table.  */
1495   if ((insn = (struct pa_opcode *) hash_find (op_hash, str)) == NULL)
1496     {
1497       as_bad ("Unknown opcode: `%s'", str);
1498       return;
1499     }
1500
1501   if (comma)
1502     {
1503       *--s = ',';
1504     }
1505
1506   /* Mark the location where arguments for the instruction start, then
1507      start processing them.  */
1508   argstart = s;
1509   for (;;)
1510     {
1511       /* Do some initialization.  */
1512       opcode = insn->match;
1513       memset (&the_insn, 0, sizeof (the_insn));
1514
1515       the_insn.reloc = R_HPPA_NONE;
1516
1517       /* If this instruction is specific to a particular architecture,
1518          then set a new architecture.  */
1519       /* But do not automatically promote to pa2.0.  The automatic promotion
1520          crud is for compatability with HP's old assemblers only.  */
1521       if (insn->arch < 20
1522           && bfd_get_mach (stdoutput) < insn->arch)
1523         {
1524           if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, insn->arch))
1525             as_warn (_("could not update architecture and machine"));
1526         }
1527       else if (bfd_get_mach (stdoutput) < insn->arch)
1528         {
1529           match = FALSE;
1530           goto failed;
1531         }
1532
1533       /* Build the opcode, checking as we go to make
1534          sure that the operands match.  */
1535       for (args = insn->args;; ++args)
1536         {
1537           switch (*args)
1538             {
1539
1540             /* End of arguments.  */
1541             case '\0':
1542               if (*s == '\0')
1543                 match = TRUE;
1544               break;
1545
1546             case '+':
1547               if (*s == '+')
1548                 {
1549                   ++s;
1550                   continue;
1551                 }
1552               if (*s == '-')
1553                 continue;
1554               break;
1555
1556             /* These must match exactly.  */
1557             case '(':
1558             case ')':
1559             case ',':
1560             case ' ':
1561               if (*s++ == *args)
1562                 continue;
1563               break;
1564
1565             /* Handle a 5 bit register or control register field at 10.  */
1566             case 'b':
1567             case '^':
1568               num = pa_parse_number (&s, 0);
1569               CHECK_FIELD (num, 31, 0, 0);
1570               INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
1571
1572             /* Handle %sar or %cr11.  No bits get set, we just verify that it
1573                is there.  */
1574             case '!':
1575               /* Skip whitespace before register.  */
1576               while (*s == ' ' || *s == '\t')
1577                 s = s + 1;
1578
1579               if (!strncasecmp(s, "%sar", 4))
1580                 {
1581                   s += 4;
1582                   continue;
1583                 }
1584               else if (!strncasecmp(s, "%cr11", 5))
1585                 {
1586                   s += 5;
1587                   continue;
1588                 }
1589               break;
1590
1591             /* Handle a 5 bit register field at 15.  */
1592             case 'x':
1593               num = pa_parse_number (&s, 0);
1594               CHECK_FIELD (num, 31, 0, 0);
1595               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
1596
1597             /* Handle a 5 bit register field at 31.  */
1598             case 'y':
1599             case 't':
1600               num = pa_parse_number (&s, 0);
1601               CHECK_FIELD (num, 31, 0, 0);
1602               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
1603
1604             /* Handle a 5 bit field length at 31.  */
1605             case 'T':
1606               num = pa_get_absolute_expression (&the_insn, &s);
1607               s = expr_end;
1608               CHECK_FIELD (num, 32, 1, 0);
1609               INSERT_FIELD_AND_CONTINUE (opcode, 32 - num, 0);
1610
1611             /* Handle a 5 bit immediate at 15.  */
1612             case '5':
1613               num = pa_get_absolute_expression (&the_insn, &s);
1614               s = expr_end;
1615               CHECK_FIELD (num, 15, -16, 0);
1616               low_sign_unext (num, 5, &num);
1617               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
1618
1619             /* Handle a 5 bit immediate at 31.  */
1620             case 'V':
1621               num = pa_get_absolute_expression (&the_insn, &s);
1622               s = expr_end;
1623               CHECK_FIELD (num, 15, -16, 0)
1624               low_sign_unext (num, 5, &num);
1625               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
1626
1627             /* Handle an unsigned 5 bit immediate at 31.  */
1628             case 'r':
1629               num = pa_get_absolute_expression (&the_insn, &s);
1630               s = expr_end;
1631               CHECK_FIELD (num, 31, 0, 0);
1632               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
1633
1634             /* Handle an unsigned 5 bit immediate at 15.  */
1635             case 'R':
1636               num = pa_get_absolute_expression (&the_insn, &s);
1637               s = expr_end;
1638               CHECK_FIELD (num, 31, 0, 0);
1639               INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
1640
1641             /* Handle a 2 bit space identifier at 17.  */
1642             case 's':
1643               num = pa_parse_number (&s, 0);
1644               CHECK_FIELD (num, 3, 0, 1);
1645               INSERT_FIELD_AND_CONTINUE (opcode, num, 14);
1646
1647             /* Handle a 3 bit space identifier at 18.  */
1648             case 'S':
1649               num = pa_parse_number (&s, 0);
1650               CHECK_FIELD (num, 7, 0, 1);
1651               dis_assemble_3 (num, &num);
1652               INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
1653
1654             /* Handle a completer for an indexing load or store.  */
1655             case 'c':
1656               {
1657                 int uu = 0;
1658                 int m = 0;
1659                 int i = 0;
1660                 while (*s == ',' && i < 2)
1661                   {
1662                     s++;
1663                     if (strncasecmp (s, "sm", 2) == 0)
1664                       {
1665                         uu = 1;
1666                         m = 1;
1667                         s++;
1668                         i++;
1669                       }
1670                     else if (strncasecmp (s, "m", 1) == 0)
1671                       m = 1;
1672                     else if (strncasecmp (s, "s", 1) == 0)
1673                       uu = 1;
1674                     else
1675                       as_bad (_("Invalid Indexed Load Completer."));
1676                     s++;
1677                     i++;
1678                   }
1679                 if (i > 2)
1680                   as_bad (_("Invalid Indexed Load Completer Syntax."));
1681                 opcode |= m << 5;
1682                 INSERT_FIELD_AND_CONTINUE (opcode, uu, 13);
1683               }
1684
1685             /* Handle a short load/store completer.  */
1686             case 'C':
1687               {
1688                 int a = 0;
1689                 int m = 0;
1690                 if (*s == ',')
1691                   {
1692                     s++;
1693                     if (strncasecmp (s, "ma", 2) == 0)
1694                       {
1695                         a = 0;
1696                         m = 1;
1697                       }
1698                     else if (strncasecmp (s, "mb", 2) == 0)
1699                       {
1700                         a = 1;
1701                         m = 1;
1702                       }
1703                     else
1704                       as_bad (_("Invalid Short Load/Store Completer."));
1705                     s += 2;
1706                   }
1707
1708                 if (*args == 'C')
1709                   {
1710                     opcode |= m << 5;
1711                     INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
1712                   }
1713               }
1714
1715             /* Handle a stbys completer.  */
1716             case 'Y':
1717               {
1718                 int a = 0;
1719                 int m = 0;
1720                 int i = 0;
1721                 while (*s == ',' && i < 2)
1722                   {
1723                     s++;
1724                     if (strncasecmp (s, "m", 1) == 0)
1725                       m = 1;
1726                     else if (strncasecmp (s, "b", 1) == 0)
1727                       a = 0;
1728                     else if (strncasecmp (s, "e", 1) == 0)
1729                       a = 1;
1730                     else
1731                       as_bad (_("Invalid Store Bytes Short Completer"));
1732                     s++;
1733                     i++;
1734                   }
1735                 if (i > 2)
1736                   as_bad (_("Invalid Store Bytes Short Completer"));
1737                 opcode |= m << 5;
1738                 INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
1739               }
1740
1741             /* Handle all conditions.  */
1742             case '?':
1743               {
1744                 args++;
1745                 switch (*args)
1746                   {
1747                   /* Handle FP compare conditions.  */
1748                   case 'f':
1749                     cond = pa_parse_fp_cmp_cond (&s);
1750                     INSERT_FIELD_AND_CONTINUE (opcode, cond, 0);
1751
1752                   /* Handle an add condition.  */
1753                   case 'A':
1754                   case 'a':
1755                     cmpltr = 0;
1756                     flag = 0;
1757                     if (*s == ',')
1758                       {
1759                         s++;
1760
1761                         /* 64 bit conditions.  */
1762                         if (*args == 'A')
1763                           {
1764                             if (*s == '*')
1765                               s++;
1766                             else
1767                               break;
1768                           }
1769                         name = s;
1770
1771                         while (*s != ',' && *s != ' ' && *s != '\t')
1772                           s += 1;
1773                         c = *s;
1774                         *s = 0x00;
1775                         if (strcmp (name, "=") == 0)
1776                           cmpltr = 1;
1777                         else if (strcmp (name, "<") == 0)
1778                           cmpltr = 2;
1779                         else if (strcmp (name, "<=") == 0)
1780                           cmpltr = 3;
1781                         else if (strcasecmp (name, "nuv") == 0)
1782                           cmpltr = 4;
1783                         else if (strcasecmp (name, "znv") == 0)
1784                           cmpltr = 5;
1785                         else if (strcasecmp (name, "sv") == 0)
1786                           cmpltr = 6;
1787                         else if (strcasecmp (name, "od") == 0)
1788                           cmpltr = 7;
1789                         else if (strcasecmp (name, "tr") == 0)
1790                           {
1791                             cmpltr = 0;
1792                             flag = 1;
1793                           }
1794                         else if (strcmp (name, "<>") == 0)
1795                           {
1796                             cmpltr = 1;
1797                             flag = 1;
1798                           }
1799                         else if (strcmp (name, ">=") == 0)
1800                           {
1801                             cmpltr = 2;
1802                             flag = 1;
1803                           }
1804                         else if (strcmp (name, ">") == 0)
1805                           {
1806                             cmpltr = 3;
1807                             flag = 1;
1808                           }
1809                         else if (strcasecmp (name, "uv") == 0)
1810                           {
1811                             cmpltr = 4;
1812                             flag = 1;
1813                           }
1814                         else if (strcasecmp (name, "vnz") == 0)
1815                           {
1816                             cmpltr = 5;
1817                             flag = 1;
1818                           }
1819                         else if (strcasecmp (name, "nsv") == 0)
1820                           {
1821                             cmpltr = 6;
1822                             flag = 1;
1823                           }
1824                         else if (strcasecmp (name, "ev") == 0)
1825                           {
1826                             cmpltr = 7;
1827                             flag = 1;
1828                           }
1829                         /* ",*" is a valid condition.  */
1830                         else if (*args == 'a')
1831                           as_bad (_("Invalid Add Condition: %s"), name);
1832                         *s = c;
1833                       }
1834                     opcode |= cmpltr << 13;
1835                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
1836
1837                   /* Handle non-negated add and branch condition.  */
1838                   case 'd':
1839                     cmpltr = pa_parse_nonneg_add_cmpltr (&s, 1);
1840                     if (cmpltr < 0)
1841                       {
1842                         as_bad (_("Invalid Compare/Subtract Condition: %c"), *s);
1843                         cmpltr = 0;
1844                       }
1845                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
1846
1847                   /* Handle negated add and branch condition.  */
1848                   case 'D':
1849                     abort ();
1850
1851                   /* Handle wide-mode non-negated add and branch condition.  */
1852                   case 'w':
1853                     abort ();
1854
1855                   /* Handle wide-mode negated add and branch condition.  */
1856                   case 'W':
1857                     abort();
1858
1859                   /* Handle a negated or non-negated add and branch
1860                      condition.  */
1861                   case '@':
1862                     save_s = s;
1863                     cmpltr = pa_parse_nonneg_add_cmpltr (&s, 1);
1864                     if (cmpltr < 0)
1865                       {
1866                         s = save_s;
1867                         cmpltr = pa_parse_neg_add_cmpltr (&s, 1);
1868                         if (cmpltr < 0)
1869                           {
1870                             as_bad (_("Invalid Compare/Subtract Condition"));
1871                             cmpltr = 0;
1872                           }
1873                         else
1874                           {
1875                             /* Negated condition requires an opcode change. */
1876                             opcode |= 1 << 27;
1877                           }
1878                       }
1879                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
1880
1881                   /* Handle branch on bit conditions.  */
1882                   case 'B':
1883                   case 'b':
1884                     cmpltr = 0;
1885                     if (*s == ',')
1886                       {
1887                         s++;
1888
1889                         if (*args == 'B')
1890                           {
1891                             if (*s == '*')
1892                               s++;
1893                             else
1894                               break;
1895                           }
1896
1897                         if (strncmp (s, "<", 1) == 0)
1898                           {
1899                             cmpltr = 0;
1900                             s++;
1901                           }
1902                         else if (strncmp (s, ">=", 2) == 0)
1903                           {
1904                             cmpltr = 1;
1905                             s += 2;
1906                           }
1907                         else
1908                           as_bad (_("Invalid Bit Branch Condition: %c"), *s);
1909                       }
1910                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 15);
1911
1912                   /* Handle a compare/subtract condition.  */
1913                   case 'S':
1914                   case 's':
1915                     cmpltr = 0;
1916                     flag = 0;
1917                     if (*s == ',')
1918                       {
1919                         s++;
1920
1921                         /* 64 bit conditions.  */
1922                         if (*args == 'S')
1923                           {
1924                             if (*s == '*')
1925                               s++;
1926                             else
1927                               break;
1928                           }
1929                         name = s;
1930
1931                         while (*s != ',' && *s != ' ' && *s != '\t')
1932                           s += 1;
1933                         c = *s;
1934                         *s = 0x00;
1935                         if (strcmp (name, "=") == 0)
1936                           cmpltr = 1;
1937                         else if (strcmp (name, "<") == 0)
1938                           cmpltr = 2;
1939                         else if (strcmp (name, "<=") == 0)
1940                           cmpltr = 3;
1941                         else if (strcasecmp (name, "<<") == 0)
1942                           cmpltr = 4;
1943                         else if (strcasecmp (name, "<<=") == 0)
1944                           cmpltr = 5;
1945                         else if (strcasecmp (name, "sv") == 0)
1946                           cmpltr = 6;
1947                         else if (strcasecmp (name, "od") == 0)
1948                           cmpltr = 7;
1949                         else if (strcasecmp (name, "tr") == 0)
1950                           {
1951                             cmpltr = 0;
1952                             flag = 1;
1953                           }
1954                         else if (strcmp (name, "<>") == 0)
1955                           {
1956                             cmpltr = 1;
1957                             flag = 1;
1958                           }
1959                         else if (strcmp (name, ">=") == 0)
1960                           {
1961                             cmpltr = 2;
1962                             flag = 1;
1963                           }
1964                         else if (strcmp (name, ">") == 0)
1965                           {
1966                             cmpltr = 3;
1967                             flag = 1;
1968                           }
1969                         else if (strcasecmp (name, ">>=") == 0)
1970                           {
1971                             cmpltr = 4;
1972                             flag = 1;
1973                           }
1974                         else if (strcasecmp (name, ">>") == 0)
1975                           {
1976                             cmpltr = 5;
1977                             flag = 1;
1978                           }
1979                         else if (strcasecmp (name, "nsv") == 0)
1980                           {
1981                             cmpltr = 6;
1982                             flag = 1;
1983                           }
1984                         else if (strcasecmp (name, "ev") == 0)
1985                           {
1986                             cmpltr = 7;
1987                             flag = 1;
1988                           }
1989                         /* ",*" is a valid condition.  */
1990                         else if (*args != 'S')
1991                           as_bad (_("Invalid Compare/Subtract Condition: %s"),
1992                                   name);
1993                         *s = c;
1994                       }
1995                     opcode |= cmpltr << 13;
1996                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
1997
1998                   /* Handle a non-negated compare condition.  */
1999                   case 't':
2000                     cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 1);
2001                     if (cmpltr < 0)
2002                       {
2003                         as_bad (_("Invalid Compare/Subtract Condition: %c"), *s);
2004                         cmpltr = 0;
2005                       }
2006                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
2007
2008                   /* Handle a negated compare condition.  */
2009                   case 'T':
2010                     abort ();
2011
2012                   /* Handle a 64 bit non-negated compare condition.  */
2013                   case 'r':
2014                     abort ();
2015
2016                   /* Handle a 64 bit negated compare condition.  */
2017                   case 'R':
2018                     abort ();
2019
2020                   /* Handle a 64 bit cmpib condition.  */
2021                   case 'Q':
2022                     abort ();
2023
2024                   /* Handle a negated or non-negated compare/subtract
2025                      condition.  */
2026                   case 'n':
2027                     save_s = s;
2028                     cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s, 1);
2029                     if (cmpltr < 0)
2030                       {
2031                         s = save_s;
2032                         cmpltr = pa_parse_neg_cmpsub_cmpltr (&s, 1);
2033                         if (cmpltr < 0)
2034                           {
2035                             as_bad (_("Invalid Compare/Subtract Condition."));
2036                             cmpltr = 0;
2037                           }
2038                         else
2039                           {
2040                             /* Negated condition requires an opcode change. */
2041                             opcode |= 1 << 27;
2042                           }
2043                       }
2044
2045                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
2046
2047                     /* Handle a logical instruction condition.  */
2048                   case 'L':
2049                   case 'l':
2050                     cmpltr = 0;
2051                     flag = 0;
2052                     if (*s == ',')
2053                       {
2054                         s++;
2055
2056                         /* 64 bit conditions.  */
2057                         if (*args == 'L')
2058                           {
2059                             if (*s == '*')
2060                               s++;
2061                             else
2062                               break;
2063                           }
2064                         name = s;
2065
2066                         while (*s != ',' && *s != ' ' && *s != '\t')
2067                           s += 1;
2068                         c = *s;
2069                         *s = 0x00;
2070
2071
2072                         if (strcmp (name, "=") == 0)
2073                           cmpltr = 1;
2074                         else if (strcmp (name, "<") == 0)
2075                           cmpltr = 2;
2076                         else if (strcmp (name, "<=") == 0)
2077                           cmpltr = 3;
2078                         else if (strcasecmp (name, "od") == 0)
2079                           cmpltr = 7;
2080                         else if (strcasecmp (name, "tr") == 0)
2081                           {
2082                             cmpltr = 0;
2083                             flag = 1;
2084                           }
2085                         else if (strcmp (name, "<>") == 0)
2086                           {
2087                             cmpltr = 1;
2088                             flag = 1;
2089                           }
2090                         else if (strcmp (name, ">=") == 0)
2091                           {
2092                             cmpltr = 2;
2093                             flag = 1;
2094                           }
2095                         else if (strcmp (name, ">") == 0)
2096                           {
2097                             cmpltr = 3;
2098                             flag = 1;
2099                           }
2100                         else if (strcasecmp (name, "ev") == 0)
2101                           {
2102                             cmpltr = 7;
2103                             flag = 1;
2104                           }
2105                         /* ",*" is a valid condition.  */
2106                         else if (*args != 'L')
2107                           as_bad (_("Invalid Logical Instruction Condition."));
2108                         *s = c;
2109                       }
2110                     opcode |= cmpltr << 13;
2111                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
2112
2113                   /* Handle a shift/extract/deposit condition.  */
2114                   case 'X':
2115                   case 'x':
2116                   case 'y':
2117                     cmpltr = 0;
2118                     if (*s == ',')
2119                       {
2120                         save_s = s++;
2121
2122                         /* 64 bit conditions.  */
2123                         if (*args == 'X')
2124                           {
2125                             if (*s == '*')
2126                               s++;
2127                             else
2128                               break;
2129                           }
2130                         name = s;
2131
2132                         while (*s != ',' && *s != ' ' && *s != '\t')
2133                           s += 1;
2134                         c = *s;
2135                         *s = 0x00;
2136                         if (strcmp (name, "=") == 0)
2137                           cmpltr = 1;
2138                         else if (strcmp (name, "<") == 0)
2139                           cmpltr = 2;
2140                         else if (strcasecmp (name, "od") == 0)
2141                           cmpltr = 3;
2142                         else if (strcasecmp (name, "tr") == 0)
2143                           cmpltr = 4;
2144                         else if (strcmp (name, "<>") == 0)
2145                           cmpltr = 5;
2146                         else if (strcmp (name, ">=") == 0)
2147                           cmpltr = 6;
2148                         else if (strcasecmp (name, "ev") == 0)
2149                           cmpltr = 7;
2150                         /* Handle movb,n.  Put things back the way they were.
2151                            This includes moving s back to where it started.  */
2152                         else if (strcasecmp (name, "n") == 0 && *args == 'y')
2153                           {
2154                             *s = c;
2155                             s = save_s;
2156                             continue;
2157                           }
2158                         /* ",*" is a valid condition.  */
2159                         else if (*args != 'X')
2160                           as_bad (_("Invalid Shift/Extract/Deposit Condition."));
2161                         *s = c;
2162                       }
2163                     INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
2164
2165                   /* Handle a unit instruction condition.  */
2166                   case 'U':
2167                   case 'u':
2168                     cmpltr = 0;
2169                     flag = 0;
2170                     if (*s == ',')
2171                       {
2172                         s++;
2173
2174                         /* 64 bit conditions.  */
2175                         if (*args == 'U')
2176                           {
2177                             if (*s == '*')
2178                               s++;
2179                             else
2180                               break;
2181                           }
2182
2183                         if (strncasecmp (s, "sbz", 3) == 0)
2184                           {
2185                             cmpltr = 2;
2186                             s += 3;
2187                           }
2188                         else if (strncasecmp (s, "shz", 3) == 0)
2189                           {
2190                             cmpltr = 3;
2191                             s += 3;
2192                           }
2193                         else if (strncasecmp (s, "sdc", 3) == 0)
2194                           {
2195                             cmpltr = 4;
2196                             s += 3;
2197                           }
2198                         else if (strncasecmp (s, "sbc", 3) == 0)
2199                           {
2200                             cmpltr = 6;
2201                             s += 3;
2202                           }
2203                         else if (strncasecmp (s, "shc", 3) == 0)
2204                           {
2205                             cmpltr = 7;
2206                             s += 3;
2207                           }
2208                         else if (strncasecmp (s, "tr", 2) == 0)
2209                           {
2210                             cmpltr = 0;
2211                             flag = 1;
2212                             s += 2;
2213                           }
2214                         else if (strncasecmp (s, "nbz", 3) == 0)
2215                           {
2216                             cmpltr = 2;
2217                             flag = 1;
2218                             s += 3;
2219                           }
2220                         else if (strncasecmp (s, "nhz", 3) == 0)
2221                           {
2222                             cmpltr = 3;
2223                             flag = 1;
2224                             s += 3;
2225                           }
2226                         else if (strncasecmp (s, "ndc", 3) == 0)
2227                           {
2228                             cmpltr = 4;
2229                             flag = 1;
2230                             s += 3;
2231                           }
2232                         else if (strncasecmp (s, "nbc", 3) == 0)
2233                           {
2234                             cmpltr = 6;
2235                             flag = 1;
2236                             s += 3;
2237                           }
2238                         else if (strncasecmp (s, "nhc", 3) == 0)
2239                           {
2240                             cmpltr = 7;
2241                             flag = 1;
2242                             s += 3;
2243                           }
2244                         /* ",*" is a valid condition.  */
2245                         else if (*args != 'U')
2246                           as_bad (_("Invalid Unit Instruction Condition."));
2247                       }
2248                     opcode |= cmpltr << 13;
2249                     INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
2250
2251                   default:
2252                     abort ();
2253                   }
2254                 break;
2255               }
2256
2257             /* Handle a system control completer.  */
2258             case 'Z':
2259               if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
2260                 {
2261                   flag = 1;
2262                   s += 2;
2263                 }
2264               else
2265                 flag = 0;
2266
2267               INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
2268
2269             /* Handle a nullification completer for branch instructions.  */
2270             case 'n':
2271               nullif = pa_parse_nullif (&s);
2272               INSERT_FIELD_AND_CONTINUE (opcode, nullif, 1);
2273
2274             /* Handle a nullification completer for copr and spop insns.  */
2275             case 'N':
2276               nullif = pa_parse_nullif (&s);
2277               INSERT_FIELD_AND_CONTINUE (opcode, nullif, 5);
2278
2279
2280             /* Handle a 11 bit immediate at 31.  */
2281             case 'i':
2282               the_insn.field_selector = pa_chk_field_selector (&s);
2283               get_expression (s);
2284               s = expr_end;
2285               if (the_insn.exp.X_op == O_constant)
2286                 {
2287                   num = evaluate_absolute (&the_insn);
2288                   CHECK_FIELD (num, 1023, -1024, 0);
2289                   low_sign_unext (num, 11, &num);
2290                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2291                 }
2292               else
2293                 {
2294                   if (is_DP_relative (the_insn.exp))
2295                     the_insn.reloc = R_HPPA_GOTOFF;
2296                   else if (is_PC_relative (the_insn.exp))
2297                     the_insn.reloc = R_HPPA_PCREL_CALL;
2298                   else
2299                     the_insn.reloc = R_HPPA;
2300                   the_insn.format = 11;
2301                   continue;
2302                 }
2303
2304
2305             /* Handle a 14 bit immediate at 31.  */
2306             case 'j':
2307               the_insn.field_selector = pa_chk_field_selector (&s);
2308               get_expression (s);
2309               s = expr_end;
2310               if (the_insn.exp.X_op == O_constant)
2311                 {
2312                   num = evaluate_absolute (&the_insn);
2313                   CHECK_FIELD (num, 8191, -8192, 0);
2314                   low_sign_unext (num, 14, &num);
2315                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2316                 }
2317               else
2318                 {
2319                   if (is_DP_relative (the_insn.exp))
2320                     the_insn.reloc = R_HPPA_GOTOFF;
2321                   else if (is_PC_relative (the_insn.exp))
2322                     the_insn.reloc = R_HPPA_PCREL_CALL;
2323                   else
2324                     the_insn.reloc = R_HPPA;
2325                   the_insn.format = 14;
2326                   continue;
2327                 }
2328
2329             /* Handle a 21 bit immediate at 31.  */
2330             case 'k':
2331               the_insn.field_selector = pa_chk_field_selector (&s);
2332               get_expression (s);
2333               s = expr_end;
2334               if (the_insn.exp.X_op == O_constant)
2335                 {
2336                   num = evaluate_absolute (&the_insn);
2337                   CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
2338                   dis_assemble_21 (num, &num);
2339                   INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2340                 }
2341               else
2342                 {
2343                   if (is_DP_relative (the_insn.exp))
2344                     the_insn.reloc = R_HPPA_GOTOFF;
2345                   else if (is_PC_relative (the_insn.exp))
2346                     the_insn.reloc = R_HPPA_PCREL_CALL;
2347                   else
2348                     the_insn.reloc = R_HPPA;
2349                   the_insn.format = 21;
2350                   continue;
2351                 }
2352
2353             /* Handle a 12 bit branch displacement.  */
2354             case 'w':
2355               the_insn.field_selector = pa_chk_field_selector (&s);
2356               get_expression (s);
2357               s = expr_end;
2358               the_insn.pcrel = 1;
2359               if (!strcmp (S_GET_NAME (the_insn.exp.X_add_symbol), "L$0\001"))
2360                 {
2361                   unsigned int w1, w, result;
2362
2363                   num = evaluate_absolute (&the_insn);
2364                   if (num % 4)
2365                     {
2366                       as_bad (_("Branch to unaligned address"));
2367                       break;
2368                     }
2369                   CHECK_FIELD (num, 8199, -8184, 0);
2370                   sign_unext ((num - 8) >> 2, 12, &result);
2371                   dis_assemble_12 (result, &w1, &w);
2372                   INSERT_FIELD_AND_CONTINUE (opcode, ((w1 << 2) | w), 0);
2373                 }
2374               else
2375                 {
2376                   the_insn.reloc = R_HPPA_PCREL_CALL;
2377                   the_insn.format = 12;
2378                   the_insn.arg_reloc = last_call_desc.arg_reloc;
2379                   memset (&last_call_desc, 0, sizeof (struct call_desc));
2380                   s = expr_end;
2381                   continue;
2382                 }
2383
2384             /* Handle a 17 bit branch displacement.  */
2385             case 'W':
2386               the_insn.field_selector = pa_chk_field_selector (&s);
2387               get_expression (s);
2388               s = expr_end;
2389               the_insn.pcrel = 1;
2390               if (!the_insn.exp.X_add_symbol
2391                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
2392                               "L$0\001"))
2393                 {
2394                   unsigned int w2, w1, w, result;
2395
2396                   num = evaluate_absolute (&the_insn);
2397                   if (num % 4)
2398                     {
2399                       as_bad (_("Branch to unaligned address"));
2400                       break;
2401                     }
2402                   CHECK_FIELD (num, 262143, -262144, 0);
2403
2404                   if (the_insn.exp.X_add_symbol)
2405                     num -= 8;
2406
2407                   sign_unext (num >> 2, 17, &result);
2408                   dis_assemble_17 (result, &w1, &w2, &w);
2409                   INSERT_FIELD_AND_CONTINUE (opcode,
2410                                            ((w2 << 2) | (w1 << 16) | w), 0);
2411                 }
2412               else
2413                 {
2414                   the_insn.reloc = R_HPPA_PCREL_CALL;
2415                   the_insn.format = 17;
2416                   the_insn.arg_reloc = last_call_desc.arg_reloc;
2417                   memset (&last_call_desc, 0, sizeof (struct call_desc));
2418                   continue;
2419                 }
2420
2421             /* Handle an absolute 17 bit branch target.  */
2422             case 'z':
2423               the_insn.field_selector = pa_chk_field_selector (&s);
2424               get_expression (s);
2425               s = expr_end;
2426               the_insn.pcrel = 0;
2427               if (!the_insn.exp.X_add_symbol
2428                   || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
2429                               "L$0\001"))
2430                 {
2431                   unsigned int w2, w1, w, result;
2432
2433                   num = evaluate_absolute (&the_insn);
2434                   if (num % 4)
2435                     {
2436                       as_bad (_("Branch to unaligned address"));
2437                       break;
2438                     }
2439                   CHECK_FIELD (num, 262143, -262144, 0);
2440
2441                   if (the_insn.exp.X_add_symbol)
2442                     num -= 8;
2443
2444                   sign_unext (num >> 2, 17, &result);
2445                   dis_assemble_17 (result, &w1, &w2, &w);
2446                   INSERT_FIELD_AND_CONTINUE (opcode,
2447                                            ((w2 << 2) | (w1 << 16) | w), 0);
2448                 }
2449               else
2450                 {
2451                   the_insn.reloc = R_HPPA_ABS_CALL;
2452                   the_insn.format = 17;
2453                   the_insn.arg_reloc = last_call_desc.arg_reloc;
2454                   memset (&last_call_desc, 0, sizeof (struct call_desc));
2455                   continue;
2456                 }
2457
2458             /* Handle a 2 bit shift count at 25.  */
2459             case '.':
2460               num = pa_get_absolute_expression (&the_insn, &s);
2461               s = expr_end;
2462               CHECK_FIELD (num, 3, 1, 0);
2463               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
2464
2465             /* Handle a 5 bit shift count at 26.  */
2466             case 'p':
2467               num = pa_get_absolute_expression (&the_insn, &s);
2468               s = expr_end;
2469               CHECK_FIELD (num, 31, 0, 0);
2470               INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
2471
2472             /* Handle a 6 bit shift count at 20,22:26.  */
2473             case '~':
2474               num = pa_get_absolute_expression (&the_insn, &s);
2475               s = expr_end;
2476               CHECK_FIELD (num, 63, 0, 0);
2477               num = 63 - num;
2478               opcode |= (num & 0x20) << 6;
2479               INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
2480
2481             /* Handle a 5 bit bit position at 26.  */
2482             case 'P':
2483               num = pa_get_absolute_expression (&the_insn, &s);
2484               s = expr_end;
2485               CHECK_FIELD (num, 31, 0, 0);
2486               INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
2487
2488             /* Handle a 5 bit immediate at 10.  */
2489             case 'Q':
2490
2491               num = pa_get_absolute_expression (&the_insn, &s);
2492               if (the_insn.exp.X_op != O_constant)
2493                 break;
2494               s = expr_end;
2495               CHECK_FIELD (num, 31, 0, 0);
2496               INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
2497
2498             /* Handle a 9 bit immediate at 28.  */
2499             case '$':
2500               num = pa_get_absolute_expression (&the_insn, &s);
2501               s = expr_end;
2502               CHECK_FIELD (num, 511, 1, 0);
2503               INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
2504
2505             /* Handle a 13 bit immediate at 18.  */
2506             case 'A':
2507               num = pa_get_absolute_expression (&the_insn, &s);
2508               s = expr_end;
2509               CHECK_FIELD (num, 8191, 0, 0);
2510               INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
2511
2512             /* Handle a 26 bit immediate at 31.  */
2513             case 'D':
2514               num = pa_get_absolute_expression (&the_insn, &s);
2515               s = expr_end;
2516               CHECK_FIELD (num, 671108864, 0, 0);
2517               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2518
2519             /* Handle a 3 bit SFU identifier at 25.  */
2520             case 'f':
2521               if (*s++ != ',')
2522                 as_bad (_("Invalid SFU identifier"));
2523               num = pa_get_absolute_expression (&the_insn, &s);
2524               s = expr_end;
2525               CHECK_FIELD (num, 7, 0, 0);
2526               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
2527
2528             /* Handle a 20 bit SOP field for spop0.  */
2529             case 'O':
2530               num = pa_get_absolute_expression (&the_insn, &s);
2531               s = expr_end;
2532               CHECK_FIELD (num, 1048575, 0, 0);
2533               num = (num & 0x1f) | ((num & 0x000fffe0) << 6);
2534               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2535
2536             /* Handle a 15bit SOP field for spop1.  */
2537             case 'o':
2538               num = pa_get_absolute_expression (&the_insn, &s);
2539               s = expr_end;
2540               CHECK_FIELD (num, 32767, 0, 0);
2541               INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
2542
2543             /* Handle a 10bit SOP field for spop3.  */
2544             case '0':
2545               num = pa_get_absolute_expression (&the_insn, &s);
2546               s = expr_end;
2547               CHECK_FIELD (num, 1023, 0, 0);
2548               num = (num & 0x1f) | ((num & 0x000003e0) << 6);
2549               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2550
2551             /* Handle a 15 bit SOP field for spop2.  */
2552             case '1':
2553               num = pa_get_absolute_expression (&the_insn, &s);
2554               s = expr_end;
2555               CHECK_FIELD (num, 32767, 0, 0);
2556               num = (num & 0x1f) | ((num & 0x00007fe0) << 6);
2557               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2558
2559             /* Handle a 3-bit co-processor ID field.  */
2560             case 'u':
2561               if (*s++ != ',')
2562                 as_bad (_("Invalid COPR identifier"));
2563               num = pa_get_absolute_expression (&the_insn, &s);
2564               s = expr_end;
2565               CHECK_FIELD (num, 7, 0, 0);
2566               INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
2567
2568             /* Handle a 22bit SOP field for copr.  */
2569             case '2':
2570               num = pa_get_absolute_expression (&the_insn, &s);
2571               s = expr_end;
2572               CHECK_FIELD (num, 4194303, 0, 0);
2573               num = (num & 0x1f) | ((num & 0x003fffe0) << 4);
2574               INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
2575
2576
2577             /* Handle a source FP operand format completer.  */
2578             case 'F':
2579               flag = pa_parse_fp_format (&s);
2580               the_insn.fpof1 = flag;
2581               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
2582
2583             /* Handle a destination FP operand format completer.  */
2584             case 'G':
2585               /* pa_parse_format needs the ',' prefix.  */
2586               s--;
2587               flag = pa_parse_fp_format (&s);
2588               the_insn.fpof2 = flag;
2589               INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
2590
2591             /* Handle a source FP operand format completer at 20.  */
2592             case 'I':
2593               flag = pa_parse_fp_format (&s);
2594               the_insn.fpof1 = flag;
2595               INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
2596
2597             /* Handle L/R register halves like 't'.  */
2598             case 'v':
2599               {
2600                 struct pa_11_fp_reg_struct result;
2601
2602                 pa_parse_number (&s, &result);
2603                 CHECK_FIELD (result.number_part, 31, 0, 0);
2604                 opcode |= result.number_part;
2605
2606                 /* 0x30 opcodes are FP arithmetic operation opcodes
2607                    and need to be turned into 0x38 opcodes.  This
2608                    is not necessary for loads/stores.  */
2609                 if (need_pa11_opcode (&the_insn, &result)
2610                     && ((opcode & 0xfc000000) == 0x30000000))
2611                   opcode |= 1 << 27;
2612
2613                 INSERT_FIELD_AND_CONTINUE (opcode, result.l_r_select & 1, 6);
2614               }
2615
2616             /* Handle L/R register halves like 'b'.  */
2617             case 'E':
2618               {
2619                 struct pa_11_fp_reg_struct result;
2620
2621                 pa_parse_number (&s, &result);
2622                 CHECK_FIELD (result.number_part, 31, 0, 0);
2623                 opcode |= result.number_part << 21;
2624                 if (need_pa11_opcode (&the_insn, &result))
2625                   {
2626                     opcode |= (result.l_r_select & 1) << 7;
2627                     opcode |= 1 << 27;
2628                   }
2629                 continue;
2630               }
2631
2632             /* Float operand 1 similar to 'b' but with l/r registers.  */
2633             case 'J':
2634               {
2635                 struct pa_11_fp_reg_struct result;
2636
2637                 pa_parse_number (&s, &result);
2638                 CHECK_FIELD (result.number_part, 31, 0, 0);
2639                 opcode |= result.number_part << 21;
2640                 opcode |= (result.l_r_select & 1) << 7;
2641                 continue;
2642               }
2643
2644             /* Handle L/R register halves like 'b'.  */
2645             case '3':
2646               {
2647                 struct pa_11_fp_reg_struct result;
2648                 int regnum;
2649
2650                 pa_parse_number (&s, &result);
2651                 CHECK_FIELD (result.number_part, 31, 0, 0);
2652                 opcode |= (result.number_part & 0x1c) << 11;
2653                 opcode |= (result.number_part & 0x3) << 9;
2654                 opcode |= (result.l_r_select & 1) << 8;
2655                 continue;
2656               }
2657
2658             /* Handle L/R register halves like 'x'.  */
2659             case 'e':
2660               {
2661                 struct pa_11_fp_reg_struct result;
2662
2663                 pa_parse_number (&s, &result);
2664                 CHECK_FIELD (result.number_part, 31, 0, 0);
2665                 opcode |= (result.number_part & 0x1f) << 16;
2666                 if (need_pa11_opcode (&the_insn, &result))
2667                   {
2668                     opcode |= (result.l_r_select & 1) << 1;
2669                   }
2670                 continue;
2671               }
2672
2673             /* Handle L/R register halves like 'x'.  */
2674             case 'X':
2675               {
2676                 struct pa_11_fp_reg_struct result;
2677
2678                 pa_parse_number (&s, &result);
2679                 CHECK_FIELD (result.number_part, 31, 0, 0);
2680                 opcode |= (result.number_part & 0x1f) << 16;
2681                 if (need_pa11_opcode (&the_insn, &result))
2682                   {
2683                     opcode |= (result.l_r_select & 1) << 12;
2684                     opcode |= 1 << 27;
2685                   }
2686                 continue;
2687               }
2688
2689             /* Float operand 2, like 'x' but with l/r register halves.  */
2690             case 'K':
2691               {
2692                 struct pa_11_fp_reg_struct result;
2693
2694                 pa_parse_number (&s, &result);
2695                 CHECK_FIELD (result.number_part, 31, 0, 0);
2696                 opcode |= (result.number_part & 0x1f) << 16;
2697                 opcode |= (result.l_r_select & 1) << 12;
2698                 continue;
2699               }
2700
2701             /* Handle a 5 bit register field at 10.  */
2702             case '4':
2703               {
2704                 struct pa_11_fp_reg_struct result;
2705
2706                 pa_parse_number (&s, &result);
2707                 CHECK_FIELD (result.number_part, 31, 0, 0);
2708                 if (the_insn.fpof1 == SGL)
2709                   {
2710                     if (result.number_part < 16)
2711                       {
2712                         as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
2713                         break;
2714                       }
2715
2716                     result.number_part &= 0xF;
2717                     result.number_part |= (result.l_r_select & 1) << 4;
2718                   }
2719                 INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 21);
2720               }
2721
2722             /* Handle a 5 bit register field at 15.  */
2723             case '6':
2724               {
2725                 struct pa_11_fp_reg_struct result;
2726
2727                 pa_parse_number (&s, &result);
2728                 CHECK_FIELD (result.number_part, 31, 0, 0);
2729                 if (the_insn.fpof1 == SGL)
2730                   {
2731                     if (result.number_part < 16)
2732                       {
2733                         as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
2734                         break;
2735                       }
2736                     result.number_part &= 0xF;
2737                     result.number_part |= (result.l_r_select & 1) << 4;
2738                   }
2739                 INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 16);
2740               }
2741
2742             /* Handle a 5 bit register field at 31.  */
2743             case '7':
2744               {
2745                 struct pa_11_fp_reg_struct result;
2746
2747                 pa_parse_number (&s, &result);
2748                 CHECK_FIELD (result.number_part, 31, 0, 0);
2749                 if (the_insn.fpof1 == SGL)
2750                   {
2751                     if (result.number_part < 16)
2752                       {
2753                         as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
2754                         break;
2755                       }
2756                     result.number_part &= 0xF;
2757                     result.number_part |= (result.l_r_select & 1) << 4;
2758                   }
2759                 INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 0);
2760               }
2761
2762             /* Handle a 5 bit register field at 20.  */
2763             case '8':
2764               {
2765                 struct pa_11_fp_reg_struct result;
2766
2767                 pa_parse_number (&s, &result);
2768                 CHECK_FIELD (result.number_part, 31, 0, 0);
2769                 if (the_insn.fpof1 == SGL)
2770                   {
2771                     if (result.number_part < 16)
2772                       {
2773                         as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
2774                         break;
2775                       }
2776                     result.number_part &= 0xF;
2777                     result.number_part |= (result.l_r_select & 1) << 4;
2778                   }
2779                 INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 11);
2780               }
2781
2782             /* Handle a 5 bit register field at 25.  */
2783             case '9':
2784               {
2785                 struct pa_11_fp_reg_struct result;
2786
2787                 pa_parse_number (&s, &result);
2788                 CHECK_FIELD (result.number_part, 31, 0, 0);
2789                 if (the_insn.fpof1 == SGL)
2790                   {
2791                     if (result.number_part < 16)
2792                       {
2793                         as_bad  (_("Invalid register for single precision fmpyadd or fmpysub"));
2794                         break;
2795                       }
2796                     result.number_part &= 0xF;
2797                     result.number_part |= (result.l_r_select & 1) << 4;
2798                   }
2799                 INSERT_FIELD_AND_CONTINUE (opcode, result.number_part, 6);
2800               }
2801
2802             /* Handle a floating point operand format at 26.
2803                Only allows single and double precision.  */
2804             case 'H':
2805               flag = pa_parse_fp_format (&s);
2806               switch (flag)
2807                 {
2808                 case SGL:
2809                   opcode |= 0x20;
2810                 case DBL:
2811                   the_insn.fpof1 = flag;
2812                   continue;
2813
2814                 case QUAD:
2815                 case ILLEGAL_FMT:
2816                 default:
2817                   as_bad (_("Invalid Floating Point Operand Format."));
2818                 }
2819               break;
2820
2821             default:
2822               abort ();
2823             }
2824           break;
2825         }
2826
2827  failed:
2828       /* Check if the args matched.  */
2829       if (match == FALSE)
2830         {
2831           if (&insn[1] - pa_opcodes < (int) NUMOPCODES
2832               && !strcmp (insn->name, insn[1].name))
2833             {
2834               ++insn;
2835               s = argstart;
2836               continue;
2837             }
2838           else
2839             {
2840               as_bad (_("Invalid operands %s"), error_message);
2841               return;
2842             }
2843         }
2844       break;
2845     }
2846
2847   the_insn.opcode = opcode;
2848 }
2849
2850 /* Turn a string in input_line_pointer into a floating point constant of type
2851    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
2852    emitted is stored in *sizeP .  An error message or NULL is returned.  */
2853
2854 #define MAX_LITTLENUMS 6
2855
2856 char *
2857 md_atof (type, litP, sizeP)
2858      char type;
2859      char *litP;
2860      int *sizeP;
2861 {
2862   int prec;
2863   LITTLENUM_TYPE words[MAX_LITTLENUMS];
2864   LITTLENUM_TYPE *wordP;
2865   char *t;
2866
2867   switch (type)
2868     {
2869
2870     case 'f':
2871     case 'F':
2872     case 's':
2873     case 'S':
2874       prec = 2;
2875       break;
2876
2877     case 'd':
2878     case 'D':
2879     case 'r':
2880     case 'R':
2881       prec = 4;
2882       break;
2883
2884     case 'x':
2885     case 'X':
2886       prec = 6;
2887       break;
2888
2889     case 'p':
2890     case 'P':
2891       prec = 6;
2892       break;
2893
2894     default:
2895       *sizeP = 0;
2896       return _("Bad call to MD_ATOF()");
2897     }
2898   t = atof_ieee (input_line_pointer, type, words);
2899   if (t)
2900     input_line_pointer = t;
2901   *sizeP = prec * sizeof (LITTLENUM_TYPE);
2902   for (wordP = words; prec--;)
2903     {
2904       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
2905       litP += sizeof (LITTLENUM_TYPE);
2906     }
2907   return NULL;
2908 }
2909
2910 /* Write out big-endian.  */
2911
2912 void
2913 md_number_to_chars (buf, val, n)
2914      char *buf;
2915      valueT val;
2916      int n;
2917 {
2918   number_to_chars_bigendian (buf, val, n);
2919 }
2920
2921 /* Translate internal representation of relocation info to BFD target
2922    format.  */
2923
2924 arelent **
2925 tc_gen_reloc (section, fixp)
2926      asection *section;
2927      fixS *fixp;
2928 {
2929   arelent *reloc;
2930   struct hppa_fix_struct *hppa_fixp;
2931   bfd_reloc_code_real_type code;
2932   static arelent *no_relocs = NULL;
2933   arelent **relocs;
2934   bfd_reloc_code_real_type **codes;
2935   int n_relocs;
2936   int i;
2937
2938   hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
2939   if (fixp->fx_addsy == 0)
2940     return &no_relocs;
2941   assert (hppa_fixp != 0);
2942   assert (section != 0);
2943
2944   reloc = (arelent *) xmalloc (sizeof (arelent));
2945
2946   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2947   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2948   codes = (bfd_reloc_code_real_type **) hppa_gen_reloc_type (stdoutput,
2949                                fixp->fx_r_type,
2950                                hppa_fixp->fx_r_format,
2951                                hppa_fixp->fx_r_field,
2952                                fixp->fx_subsy != NULL,
2953                                symbol_get_bfdsym (fixp->fx_addsy));
2954
2955   if (codes == NULL)
2956     abort ();
2957
2958   for (n_relocs = 0; codes[n_relocs]; n_relocs++)
2959     ;
2960
2961   relocs = (arelent **) xmalloc (sizeof (arelent *) * n_relocs + 1);
2962   reloc = (arelent *) xmalloc (sizeof (arelent) * n_relocs);
2963   for (i = 0; i < n_relocs; i++)
2964     relocs[i] = &reloc[i];
2965
2966   relocs[n_relocs] = NULL;
2967
2968 #ifdef OBJ_ELF
2969   switch (fixp->fx_r_type)
2970     {
2971     default:
2972       assert (n_relocs == 1);
2973
2974       code = *codes[0];
2975
2976       reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2977       *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2978       reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2979       reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2980       reloc->addend = 0;        /* default */
2981
2982       assert (reloc->howto && code == reloc->howto->type);
2983
2984       /* Now, do any processing that is dependent on the relocation type.  */
2985       switch (code)
2986         {
2987         case R_PARISC_DLTREL21L:
2988         case R_PARISC_DLTREL14R:
2989         case R_PARISC_DLTREL14F:
2990         case R_PARISC_PLABEL32:
2991         case R_PARISC_PLABEL21L:
2992         case R_PARISC_PLABEL14R:
2993           /* For plabel relocations, the addend of the
2994              relocation should be either 0 (no static link) or 2
2995              (static link required).
2996
2997              FIXME: We always assume no static link!
2998
2999              We also slam a zero addend into the DLT relative relocs;
3000              it doesn't make a lot of sense to use any addend since
3001              it gets you a different (eg unknown) DLT entry.  */
3002           reloc->addend = 0;
3003           break;
3004
3005         case R_PARISC_PCREL21L:
3006         case R_PARISC_PCREL17R:
3007         case R_PARISC_PCREL17F:
3008         case R_PARISC_PCREL17C:
3009         case R_PARISC_PCREL14R:
3010         case R_PARISC_PCREL14F:
3011           /* The constant is stored in the instruction.  */
3012           reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
3013           break;
3014         default:
3015           reloc->addend = fixp->fx_offset;
3016           break;
3017         }
3018       break;
3019     }
3020 #else /* OBJ_SOM */
3021
3022   /* Walk over reach relocation returned by the BFD backend.  */
3023   for (i = 0; i < n_relocs; i++)
3024     {
3025       code = *codes[i];
3026
3027       relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3028       *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
3029       relocs[i]->howto = bfd_reloc_type_lookup (stdoutput, code);
3030       relocs[i]->address = fixp->fx_frag->fr_address + fixp->fx_where;
3031
3032       switch (code)
3033         {
3034         case R_COMP2:
3035           /* The only time we ever use a R_COMP2 fixup is for the difference
3036              of two symbols.  With that in mind we fill in all four
3037              relocs now and break out of the loop.  */
3038           assert (i == 1);
3039           relocs[0]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
3040           relocs[0]->howto = bfd_reloc_type_lookup (stdoutput, *codes[0]);
3041           relocs[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
3042           relocs[0]->addend = 0;
3043           relocs[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3044           *relocs[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
3045           relocs[1]->howto = bfd_reloc_type_lookup (stdoutput, *codes[1]);
3046           relocs[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
3047           relocs[1]->addend = 0;
3048           relocs[2]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3049           *relocs[2]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
3050           relocs[2]->howto = bfd_reloc_type_lookup (stdoutput, *codes[2]);
3051           relocs[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
3052           relocs[2]->addend = 0;
3053           relocs[3]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
3054           relocs[3]->howto = bfd_reloc_type_lookup (stdoutput, *codes[3]);
3055           relocs[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
3056           relocs[3]->addend = 0;
3057           relocs[4]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
3058           relocs[4]->howto = bfd_reloc_type_lookup (stdoutput, *codes[4]);
3059           relocs[4]->address = fixp->fx_frag->fr_address + fixp->fx_where;
3060           relocs[4]->addend = 0;
3061           goto done;
3062         case R_PCREL_CALL:
3063         case R_ABS_CALL:
3064           relocs[i]->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
3065           break;
3066
3067         case R_DLT_REL:
3068         case R_DATA_PLABEL:
3069         case R_CODE_PLABEL:
3070           /* For plabel relocations, the addend of the
3071              relocation should be either 0 (no static link) or 2
3072              (static link required).
3073
3074              FIXME: We always assume no static link!
3075
3076              We also slam a zero addend into the DLT relative relocs;
3077              it doesn't make a lot of sense to use any addend since
3078              it gets you a different (eg unknown) DLT entry.  */
3079           relocs[i]->addend = 0;
3080           break;
3081
3082         case R_N_MODE:
3083         case R_S_MODE:
3084         case R_D_MODE:
3085         case R_R_MODE:
3086         case R_FSEL:
3087         case R_LSEL:
3088         case R_RSEL:
3089         case R_BEGIN_BRTAB:
3090         case R_END_BRTAB:
3091         case R_BEGIN_TRY:
3092         case R_N0SEL:
3093         case R_N1SEL:
3094           /* There is no symbol or addend associated with these fixups.  */
3095           relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3096           *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
3097           relocs[i]->addend = 0;
3098           break;
3099
3100         case R_END_TRY:
3101         case R_ENTRY:
3102         case R_EXIT:
3103           /* There is no symbol associated with these fixups.  */
3104           relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3105           *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
3106           relocs[i]->addend = fixp->fx_offset;
3107           break;
3108
3109         default:
3110           relocs[i]->addend = fixp->fx_offset;
3111         }
3112     }
3113
3114  done:
3115 #endif
3116
3117   return relocs;
3118 }
3119
3120 /* Process any machine dependent frag types.  */
3121
3122 void
3123 md_convert_frag (abfd, sec, fragP)
3124      register bfd *abfd;
3125      register asection *sec;
3126      register fragS *fragP;
3127 {
3128   unsigned int address;
3129
3130   if (fragP->fr_type == rs_machine_dependent)
3131     {
3132       switch ((int) fragP->fr_subtype)
3133         {
3134         case 0:
3135           fragP->fr_type = rs_fill;
3136           know (fragP->fr_var == 1);
3137           know (fragP->fr_next);
3138           address = fragP->fr_address + fragP->fr_fix;
3139           if (address % fragP->fr_offset)
3140             {
3141               fragP->fr_offset =
3142                 fragP->fr_next->fr_address
3143                 - fragP->fr_address
3144                 - fragP->fr_fix;
3145             }
3146           else
3147             fragP->fr_offset = 0;
3148           break;
3149         }
3150     }
3151 }
3152
3153 /* Round up a section size to the appropriate boundary. */
3154
3155 valueT
3156 md_section_align (segment, size)
3157      asection *segment;
3158      valueT size;
3159 {
3160   int align = bfd_get_section_alignment (stdoutput, segment);
3161   int align2 = (1 << align) - 1;
3162
3163   return (size + align2) & ~align2;
3164 }
3165
3166 /* Return the approximate size of a frag before relaxation has occurred.  */
3167 int
3168 md_estimate_size_before_relax (fragP, segment)
3169      register fragS *fragP;
3170      asection *segment;
3171 {
3172   int size;
3173
3174   size = 0;
3175
3176   while ((fragP->fr_fix + size) % fragP->fr_offset)
3177     size++;
3178
3179   return size;
3180 }
3181 \f
3182 CONST char *md_shortopts = "";
3183 struct option md_longopts[] = {
3184   {NULL, no_argument, NULL, 0}
3185 };
3186 size_t md_longopts_size = sizeof(md_longopts);
3187
3188 int
3189 md_parse_option (c, arg)
3190      int c;
3191      char *arg;
3192 {
3193   return 0;
3194 }
3195
3196 void
3197 md_show_usage (stream)
3198      FILE *stream;
3199 {
3200 }
3201 \f
3202 /* We have no need to default values of symbols.  */
3203
3204 symbolS *
3205 md_undefined_symbol (name)
3206      char *name;
3207 {
3208   return 0;
3209 }
3210
3211 /* Apply a fixup to an instruction.  */
3212
3213 int
3214 md_apply_fix (fixP, valp)
3215      fixS *fixP;
3216      valueT *valp;
3217 {
3218   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
3219   struct hppa_fix_struct *hppa_fixP;
3220   long new_val, result = 0;
3221   unsigned int w1, w2, w, resulti;
3222
3223   hppa_fixP = (struct hppa_fix_struct *) fixP->tc_fix_data;
3224   /* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
3225      never be "applied" (they are just markers).  Likewise for
3226      R_HPPA_BEGIN_BRTAB and R_HPPA_END_BRTAB.  */
3227 #ifdef OBJ_SOM
3228   if (fixP->fx_r_type == R_HPPA_ENTRY
3229       || fixP->fx_r_type == R_HPPA_EXIT
3230       || fixP->fx_r_type == R_HPPA_BEGIN_BRTAB
3231       || fixP->fx_r_type == R_HPPA_END_BRTAB
3232       || fixP->fx_r_type == R_HPPA_BEGIN_TRY)
3233     return 1;
3234
3235   /* Disgusting.  We must set fx_offset ourselves -- R_HPPA_END_TRY
3236      fixups are considered not adjustable, which in turn causes
3237      adjust_reloc_syms to not set fx_offset.  Ugh.  */
3238   if (fixP->fx_r_type == R_HPPA_END_TRY)
3239     {
3240       fixP->fx_offset = *valp;
3241       return 1;
3242     }
3243 #endif
3244
3245   /* There should have been an HPPA specific fixup associated
3246      with the GAS fixup.  */
3247   if (hppa_fixP)
3248     {
3249       unsigned long buf_wd = bfd_get_32 (stdoutput, buf);
3250       unsigned char fmt = bfd_hppa_insn2fmt (buf_wd);
3251
3252       /* If there is a symbol associated with this fixup, then it's something
3253          which will need a SOM relocation (except for some PC-relative relocs).
3254          In such cases we should treat the "val" or "addend" as zero since it
3255          will be added in as needed from fx_offset in tc_gen_reloc.  */
3256       if ((fixP->fx_addsy != NULL
3257            || fixP->fx_r_type == R_HPPA_NONE)
3258 #ifdef OBJ_SOM
3259           && fmt != 32
3260 #endif
3261           )
3262         new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
3263 #ifdef OBJ_SOM
3264       /* These field selectors imply that we do not want an addend.  */
3265       else if (hppa_fixP->fx_r_field == e_psel
3266                || hppa_fixP->fx_r_field == e_rpsel
3267                || hppa_fixP->fx_r_field == e_lpsel
3268                || hppa_fixP->fx_r_field == e_tsel
3269                || hppa_fixP->fx_r_field == e_rtsel
3270                || hppa_fixP->fx_r_field == e_ltsel)
3271         new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
3272       /* This is truely disgusting.  The machine independent code blindly
3273          adds in the value of the symbol being relocated against.  Damn!  */
3274       else if (fmt == 32
3275                && fixP->fx_addsy != NULL
3276                && S_GET_SEGMENT (fixP->fx_addsy) != bfd_com_section_ptr)
3277         new_val = hppa_field_adjust (*valp - S_GET_VALUE (fixP->fx_addsy),
3278                                      0, hppa_fixP->fx_r_field);
3279 #endif
3280       else
3281         new_val = hppa_field_adjust (*valp, 0, hppa_fixP->fx_r_field);
3282
3283       /* Handle pc-relative exceptions from above.  */
3284 #define arg_reloc_stub_needed(CALLER, CALLEE) \
3285   ((CALLEE) && (CALLER) && ((CALLEE) != (CALLER)))
3286       if ((fmt == 12 || fmt == 17 || fmt == 22)
3287           && fixP->fx_addsy
3288           && fixP->fx_pcrel
3289 #ifdef OBJ_SOM
3290           && !arg_reloc_stub_needed ((long) ((obj_symbol_type *)
3291                 symbol_get_bfdsym (fixP->fx_addsy))->tc_data.ap.hppa_arg_reloc,
3292                 hppa_fixP->fx_arg_reloc)
3293 #endif
3294           && (((int)(*valp) > -262144 && (int)(*valp) < 262143) && fmt != 22)
3295           && S_GET_SEGMENT (fixP->fx_addsy) == hppa_fixP->segment
3296           && !(fixP->fx_subsy
3297                && S_GET_SEGMENT (fixP->fx_subsy) != hppa_fixP->segment))
3298
3299         new_val = hppa_field_adjust (*valp, 0, hppa_fixP->fx_r_field);
3300 #undef arg_reloc_stub_needed
3301
3302       switch (fmt)
3303         {
3304         /* Handle all opcodes with the 'j' operand type.  */
3305         case 14:
3306           CHECK_FIELD (new_val, 8191, -8192, 0);
3307
3308           /* Mask off 14 bits to be changed.  */
3309           bfd_put_32 (stdoutput,
3310                       bfd_get_32 (stdoutput, buf) & 0xffffc000,
3311                       buf);
3312           low_sign_unext (new_val, 14, &resulti);
3313           result = resulti;
3314           break;
3315
3316         /* Handle all opcodes with the 'k' operand type.  */
3317         case 21:
3318           CHECK_FIELD (new_val, 2097152, 0, 0);
3319
3320           /* Mask off 21 bits to be changed.  */
3321           bfd_put_32 (stdoutput,
3322                       bfd_get_32 (stdoutput, buf) & 0xffe00000,
3323                       buf);
3324           dis_assemble_21 (new_val, &resulti);
3325           result = resulti;
3326           break;
3327
3328         /* Handle all the opcodes with the 'i' operand type.  */
3329         case 11:
3330           CHECK_FIELD (new_val, 1023, -1023, 0);
3331
3332           /* Mask off 11 bits to be changed.  */
3333           bfd_put_32 (stdoutput,
3334                       bfd_get_32 (stdoutput, buf) & 0xffff800,
3335                       buf);
3336           low_sign_unext (new_val, 11, &resulti);
3337           result = resulti;
3338           break;
3339
3340         /* Handle all the opcodes with the 'w' operand type.  */
3341         case 12:
3342           CHECK_FIELD (new_val, 8199, -8184, 0);
3343
3344           /* Mask off 11 bits to be changed.  */
3345           sign_unext ((new_val - 8) >> 2, 12, &resulti);
3346           bfd_put_32 (stdoutput,
3347                       bfd_get_32 (stdoutput, buf) & 0xffffe002,
3348                       buf);
3349
3350           dis_assemble_12 (resulti, &w1, &w);
3351           result = ((w1 << 2) | w);
3352           break;
3353
3354         /* Handle some of the opcodes with the 'W' operand type.  */
3355         case 17:
3356           {
3357             int distance = *valp;
3358
3359             CHECK_FIELD (new_val, 262143, -262144, 0);
3360
3361             /* If this is an absolute branch (ie no link) with an out of
3362                range target, then we want to complain.  */
3363             if (fixP->fx_r_type == R_HPPA_PCREL_CALL
3364                 && (distance > 262143 || distance < -262144)
3365                 && (bfd_get_32 (stdoutput, buf) & 0xffe00000) == 0xe8000000)
3366               CHECK_FIELD (distance, 262143, -262144, 0);
3367
3368             /* Mask off 17 bits to be changed.  */
3369             bfd_put_32 (stdoutput,
3370                         bfd_get_32 (stdoutput, buf) & 0xffe0e002,
3371                         buf);
3372             sign_unext ((new_val - 8) >> 2, 17, &resulti);
3373             dis_assemble_17 (resulti, &w1, &w2, &w);
3374             result = ((w2 << 2) | (w1 << 16) | w);
3375             break;
3376           }
3377
3378         case 32:
3379           result = 0;
3380           bfd_put_32 (stdoutput, new_val, buf);
3381           break;
3382
3383         default:
3384           as_bad (_("Unknown relocation encountered in md_apply_fix."));
3385           return 0;
3386         }
3387
3388       /* Insert the relocation.  */
3389       bfd_put_32 (stdoutput, bfd_get_32 (stdoutput, buf) | result, buf);
3390       return 1;
3391     }
3392   else
3393     {
3394       printf (_("no hppa_fixup entry for this fixup (fixP = 0x%x, type = 0x%x)\n"),
3395               (unsigned int) fixP, fixP->fx_r_type);
3396       return 0;
3397     }
3398 }
3399
3400 /* Exactly what point is a PC-relative offset relative TO?
3401    On the PA, they're relative to the address of the offset.  */
3402
3403 long
3404 md_pcrel_from (fixP)
3405      fixS *fixP;
3406 {
3407   return fixP->fx_where + fixP->fx_frag->fr_address;
3408 }
3409
3410 /* Return nonzero if the input line pointer is at the end of
3411    a statement.  */
3412
3413 static int
3414 is_end_of_statement ()
3415 {
3416   return ((*input_line_pointer == '\n')
3417           || (*input_line_pointer == ';')
3418           || (*input_line_pointer == '!'));
3419 }
3420
3421 /* Read a number from S.  The number might come in one of many forms,
3422    the most common will be a hex or decimal constant, but it could be
3423    a pre-defined register (Yuk!), or an absolute symbol.
3424
3425    Return a number or -1 for failure.
3426
3427    When parsing PA-89 FP register numbers RESULT will be
3428    the address of a structure to return information about
3429    L/R half of FP registers, store results there as appropriate.
3430
3431    pa_parse_number can not handle negative constants and will fail
3432    horribly if it is passed such a constant.  */
3433
3434 static int
3435 pa_parse_number (s, result)
3436      char **s;
3437      struct pa_11_fp_reg_struct *result;
3438 {
3439   int num;
3440   char *name;
3441   char c;
3442   symbolS *sym;
3443   int status;
3444   char *p = *s;
3445
3446   /* Skip whitespace before the number.  */
3447   while (*p == ' ' || *p == '\t')
3448     p = p + 1;
3449
3450   /* Store info in RESULT if requested by caller.  */
3451   if (result)
3452     {
3453       result->number_part = -1;
3454       result->l_r_select = -1;
3455     }
3456   num = -1;
3457
3458   if (isdigit (*p))
3459     {
3460       /* Looks like a number.  */
3461       num = 0;
3462
3463       if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
3464         {
3465           /* The number is specified in hex.  */
3466           p += 2;
3467           while (isdigit (*p) || ((*p >= 'a') && (*p <= 'f'))
3468                  || ((*p >= 'A') && (*p <= 'F')))
3469             {
3470               if (isdigit (*p))
3471                 num = num * 16 + *p - '0';
3472               else if (*p >= 'a' && *p <= 'f')
3473                 num = num * 16 + *p - 'a' + 10;
3474               else
3475                 num = num * 16 + *p - 'A' + 10;
3476               ++p;
3477             }
3478         }
3479       else
3480         {
3481           /* The number is specified in decimal.  */
3482           while (isdigit (*p))
3483             {
3484               num = num * 10 + *p - '0';
3485               ++p;
3486             }
3487         }
3488
3489       /* Store info in RESULT if requested by the caller.  */
3490       if (result)
3491         {
3492           result->number_part = num;
3493
3494           if (IS_R_SELECT (p))
3495             {
3496               result->l_r_select = 1;
3497               ++p;
3498             }
3499           else if (IS_L_SELECT (p))
3500             {
3501               result->l_r_select = 0;
3502               ++p;
3503             }
3504           else
3505             result->l_r_select = 0;
3506         }
3507     }
3508   else if (*p == '%')
3509     {
3510       /* The number might be a predefined register.  */
3511       num = 0;
3512       name = p;
3513       p++;
3514       c = *p;
3515       /* Tege hack: Special case for general registers as the general
3516          code makes a binary search with case translation, and is VERY
3517          slow. */
3518       if (c == 'r')
3519         {
3520           p++;
3521           if (*p == 'e' && *(p + 1) == 't'
3522               && (*(p + 2) == '0' || *(p + 2) == '1'))
3523             {
3524               p += 2;
3525               num = *p - '0' + 28;
3526               p++;
3527             }
3528           else if (*p == 'p')
3529             {
3530               num = 2;
3531               p++;
3532             }
3533           else if (!isdigit (*p))
3534             {
3535               if (print_errors)
3536                 as_bad (_("Undefined register: '%s'."), name);
3537               num = -1;
3538             }
3539           else
3540             {
3541               do
3542                 num = num * 10 + *p++ - '0';
3543               while (isdigit (*p));
3544             }
3545         }
3546       else
3547         {
3548           /* Do a normal register search.  */
3549           while (is_part_of_name (c))
3550             {
3551               p = p + 1;
3552               c = *p;
3553             }
3554           *p = 0;
3555           status = reg_name_search (name);
3556           if (status >= 0)
3557             num = status;
3558           else
3559             {
3560               if (print_errors)
3561                 as_bad (_("Undefined register: '%s'."), name);
3562               num = -1;
3563             }
3564           *p = c;
3565         }
3566
3567       /* Store info in RESULT if requested by caller.  */
3568       if (result)
3569         {
3570           result->number_part = num;
3571           if (IS_R_SELECT (p - 1))
3572             result->l_r_select = 1;
3573           else if (IS_L_SELECT (p - 1))
3574             result->l_r_select = 0;
3575           else
3576             result->l_r_select = 0;
3577         }
3578     }
3579   else
3580     {
3581       /* And finally, it could be a symbol in the absolute section which
3582          is effectively a constant.  */
3583       num = 0;
3584       name = p;
3585       c = *p;
3586       while (is_part_of_name (c))
3587         {
3588           p = p + 1;
3589           c = *p;
3590         }
3591       *p = 0;
3592       if ((sym = symbol_find (name)) != NULL)
3593         {
3594           if (S_GET_SEGMENT (sym) == &bfd_abs_section)
3595             num = S_GET_VALUE (sym);
3596           else
3597             {
3598               if (print_errors)
3599                 as_bad (_("Non-absolute symbol: '%s'."), name);
3600               num = -1;
3601             }
3602         }
3603       else
3604         {
3605           /* There is where we'd come for an undefined symbol
3606              or for an empty string.  For an empty string we
3607              will return zero.  That's a concession made for
3608              compatability with the braindamaged HP assemblers.  */
3609           if (*name == 0)
3610             num = 0;
3611           else
3612             {
3613               if (print_errors)
3614                 as_bad (_("Undefined absolute constant: '%s'."), name);
3615               num = -1;
3616             }
3617         }
3618       *p = c;
3619
3620       /* Store info in RESULT if requested by caller.  */
3621       if (result)
3622         {
3623           result->number_part = num;
3624           if (IS_R_SELECT (p - 1))
3625             result->l_r_select = 1;
3626           else if (IS_L_SELECT (p - 1))
3627             result->l_r_select = 0;
3628           else
3629             result->l_r_select = 0;
3630         }
3631     }
3632
3633   *s = p;
3634   return num;
3635 }
3636
3637 #define REG_NAME_CNT    (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
3638
3639 /* Given NAME, find the register number associated with that name, return
3640    the integer value associated with the given name or -1 on failure.  */
3641
3642 static int
3643 reg_name_search (name)
3644      char *name;
3645 {
3646   int middle, low, high;
3647   int cmp;
3648
3649   low = 0;
3650   high = REG_NAME_CNT - 1;
3651
3652   do
3653     {
3654       middle = (low + high) / 2;
3655       cmp = strcasecmp (name, pre_defined_registers[middle].name);
3656       if (cmp < 0)
3657         high = middle - 1;
3658       else if (cmp > 0)
3659         low = middle + 1;
3660       else
3661         return pre_defined_registers[middle].value;
3662     }
3663   while (low <= high);
3664
3665   return -1;
3666 }
3667
3668
3669 /* Return nonzero if the given INSN and L/R information will require
3670    a new PA-1.1 opcode.  */
3671
3672 static int
3673 need_pa11_opcode (insn, result)
3674      struct pa_it *insn;
3675      struct pa_11_fp_reg_struct *result;
3676 {
3677   if (result->l_r_select == 1 && !(insn->fpof1 == DBL && insn->fpof2 == DBL))
3678     {
3679       /* If this instruction is specific to a particular architecture,
3680          then set a new architecture.  */
3681       if (bfd_get_mach (stdoutput) < pa11)
3682         {
3683           if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, pa11))
3684             as_warn (_("could not update architecture and machine"));
3685         }
3686       return TRUE;
3687     }
3688   else
3689     return FALSE;
3690 }
3691
3692 /* Parse a condition for a fcmp instruction.  Return the numerical
3693    code associated with the condition.  */
3694
3695 static int
3696 pa_parse_fp_cmp_cond (s)
3697      char **s;
3698 {
3699   int cond, i;
3700
3701   cond = 0;
3702
3703   for (i = 0; i < 32; i++)
3704     {
3705       if (strncasecmp (*s, fp_cond_map[i].string,
3706                        strlen (fp_cond_map[i].string)) == 0)
3707         {
3708           cond = fp_cond_map[i].cond;
3709           *s += strlen (fp_cond_map[i].string);
3710           /* If not a complete match, back up the input string and
3711              report an error.  */
3712           if (**s != ' ' && **s != '\t')
3713             {
3714               *s -= strlen (fp_cond_map[i].string);
3715               break;
3716             }
3717           while (**s == ' ' || **s == '\t')
3718             *s = *s + 1;
3719           return cond;
3720         }
3721     }
3722
3723   as_bad (_("Invalid FP Compare Condition: %s"), *s);
3724
3725   /* Advance over the bogus completer.  */
3726   while (**s != ',' && **s != ' ' && **s != '\t')
3727     *s += 1;
3728
3729   return 0;
3730 }
3731
3732
3733 /* Parse an FP operand format completer returning the completer
3734    type.  */
3735
3736 static fp_operand_format
3737 pa_parse_fp_format (s)
3738      char **s;
3739 {
3740   int format;
3741
3742   format = SGL;
3743   if (**s == ',')
3744     {
3745       *s += 1;
3746       if (strncasecmp (*s, "sgl", 3) == 0)
3747         {
3748           format = SGL;
3749           *s += 4;
3750         }
3751       else if (strncasecmp (*s, "dbl", 3) == 0)
3752         {
3753           format = DBL;
3754           *s += 4;
3755         }
3756       else if (strncasecmp (*s, "quad", 4) == 0)
3757         {
3758           format = QUAD;
3759           *s += 5;
3760         }
3761       else
3762         {
3763           format = ILLEGAL_FMT;
3764           as_bad (_("Invalid FP Operand Format: %3s"), *s);
3765         }
3766     }
3767
3768   return format;
3769 }
3770
3771 /* Convert from a selector string into a selector type.  */
3772
3773 static int
3774 pa_chk_field_selector (str)
3775      char **str;
3776 {
3777   int middle, low, high;
3778   int cmp;
3779   char name[4];
3780
3781   /* Read past any whitespace.  */
3782   /* FIXME: should we read past newlines and formfeeds??? */
3783   while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
3784     *str = *str + 1;
3785
3786   if ((*str)[1] == '\'' || (*str)[1] == '%')
3787     name[0] = tolower ((*str)[0]),
3788     name[1] = 0;
3789   else if ((*str)[2] == '\'' || (*str)[2] == '%')
3790     name[0] = tolower ((*str)[0]),
3791     name[1] = tolower ((*str)[1]),
3792     name[2] = 0;
3793   else if ((*str)[3] == '\'' || (*str)[3] == '%')
3794     name[0] = tolower ((*str)[0]),
3795     name[1] = tolower ((*str)[1]),
3796     name[2] = tolower ((*str)[2]),
3797     name[3] = 0;
3798   else
3799     return e_fsel;
3800
3801   low = 0;
3802   high = sizeof (selector_table) / sizeof (struct selector_entry) - 1;
3803
3804   do
3805     {
3806       middle = (low + high) / 2;
3807       cmp = strcmp (name, selector_table[middle].prefix);
3808       if (cmp < 0)
3809         high = middle - 1;
3810       else if (cmp > 0)
3811         low = middle + 1;
3812       else
3813         {
3814           *str += strlen (name) + 1;
3815 #ifndef OBJ_SOM
3816           if (selector_table[middle].field_selector == e_nsel)
3817             return e_fsel;
3818 #endif
3819           return selector_table[middle].field_selector;
3820         }
3821     }
3822   while (low <= high);
3823
3824   return e_fsel;
3825 }
3826
3827 /* Mark (via expr_end) the end of an expression (I think).  FIXME.  */
3828
3829 static int
3830 get_expression (str)
3831      char *str;
3832 {
3833   char *save_in;
3834   asection *seg;
3835
3836   save_in = input_line_pointer;
3837   input_line_pointer = str;
3838   seg = expression (&the_insn.exp);
3839   if (!(seg == absolute_section
3840         || seg == undefined_section
3841         || SEG_NORMAL (seg)))
3842     {
3843       as_warn (_("Bad segment in expression."));
3844       expr_end = input_line_pointer;
3845       input_line_pointer = save_in;
3846       return 1;
3847     }
3848   expr_end = input_line_pointer;
3849   input_line_pointer = save_in;
3850   return 0;
3851 }
3852
3853 /* Mark (via expr_end) the end of an absolute expression.  FIXME. */
3854 static int
3855 pa_get_absolute_expression (insn, strp)
3856      struct pa_it *insn;
3857      char **strp;
3858 {
3859   char *save_in;
3860
3861   insn->field_selector = pa_chk_field_selector (strp);
3862   save_in = input_line_pointer;
3863   input_line_pointer = *strp;
3864   expression (&insn->exp);
3865   /* This is not perfect, but is a huge improvement over doing nothing.
3866
3867      The PA assembly syntax is ambigious in a variety of ways.  Consider
3868      this string "4 %r5"  Is that the number 4 followed by the register
3869      r5, or is that 4 MOD 5?
3870
3871      If we get a modulo expresion When looking for an absolute, we try
3872      again cutting off the input string at the first whitespace character.  */
3873   if (insn->exp.X_op == O_modulus)
3874     {
3875       char *s, c;
3876       int retval;
3877
3878       input_line_pointer = *strp;
3879       s = *strp;
3880       while (*s != ',' && *s != ' ' && *s != '\t')
3881         s++;
3882
3883       c = *s;
3884       *s = 0;
3885
3886       retval = pa_get_absolute_expression (insn, strp);
3887
3888       input_line_pointer = save_in;
3889       *s = c;
3890       return evaluate_absolute (insn);
3891     }
3892   if (insn->exp.X_op != O_constant)
3893     {
3894       as_bad (_("Bad segment (should be absolute)."));
3895       expr_end = input_line_pointer;
3896       input_line_pointer = save_in;
3897       return 0;
3898     }
3899   expr_end = input_line_pointer;
3900   input_line_pointer = save_in;
3901   return evaluate_absolute (insn);
3902 }
3903
3904 /* Evaluate an absolute expression EXP which may be modified by
3905    the selector FIELD_SELECTOR.  Return the value of the expression.  */
3906 static int
3907 evaluate_absolute (insn)
3908      struct pa_it *insn;
3909 {
3910   int value;
3911   expressionS exp;
3912   int field_selector = insn->field_selector;
3913
3914   exp = insn->exp;
3915   value = exp.X_add_number;
3916
3917   switch (field_selector)
3918     {
3919     /* No change.  */
3920     case e_fsel:
3921       break;
3922
3923     /* If bit 21 is on then add 0x800 and arithmetic shift right 11 bits.  */
3924     case e_lssel:
3925       if (value & 0x00000400)
3926         value += 0x800;
3927       value = (value & 0xfffff800) >> 11;
3928       break;
3929
3930     /* Sign extend from bit 21.  */
3931     case e_rssel:
3932       if (value & 0x00000400)
3933         value |= 0xfffff800;
3934       else
3935         value &= 0x7ff;
3936       break;
3937
3938     /* Arithmetic shift right 11 bits.  */
3939     case e_lsel:
3940       value = (value & 0xfffff800) >> 11;
3941       break;
3942
3943     /* Set bits 0-20 to zero.  */
3944     case e_rsel:
3945       value = value & 0x7ff;
3946       break;
3947
3948     /* Add 0x800 and arithmetic shift right 11 bits.  */
3949     case e_ldsel:
3950       value += 0x800;
3951       value = (value & 0xfffff800) >> 11;
3952       break;
3953
3954     /* Set bitgs 0-21 to one.  */
3955     case e_rdsel:
3956       value |= 0xfffff800;
3957       break;
3958
3959 #define RSEL_ROUND(c)  (((c) + 0x1000) & ~0x1fff)
3960     case e_rrsel:
3961       value = (RSEL_ROUND (value) & 0x7ff) + (value - RSEL_ROUND (value));
3962       break;
3963
3964     case e_lrsel:
3965       value = (RSEL_ROUND (value) >> 11) & 0x1fffff;
3966       break;
3967 #undef RSEL_ROUND
3968
3969     default:
3970       BAD_CASE (field_selector);
3971       break;
3972     }
3973   return value;
3974 }
3975
3976 /* Given an argument location specification return the associated
3977    argument location number.  */
3978
3979 static unsigned int
3980 pa_build_arg_reloc (type_name)
3981      char *type_name;
3982 {
3983
3984   if (strncasecmp (type_name, "no", 2) == 0)
3985     return 0;
3986   if (strncasecmp (type_name, "gr", 2) == 0)
3987     return 1;
3988   else if (strncasecmp (type_name, "fr", 2) == 0)
3989     return 2;
3990   else if (strncasecmp (type_name, "fu", 2) == 0)
3991     return 3;
3992   else
3993     as_bad (_("Invalid argument location: %s\n"), type_name);
3994
3995   return 0;
3996 }
3997
3998 /* Encode and return an argument relocation specification for
3999    the given register in the location specified by arg_reloc.  */
4000
4001 static unsigned int
4002 pa_align_arg_reloc (reg, arg_reloc)
4003      unsigned int reg;
4004      unsigned int arg_reloc;
4005 {
4006   unsigned int new_reloc;
4007
4008   new_reloc = arg_reloc;
4009   switch (reg)
4010     {
4011     case 0:
4012       new_reloc <<= 8;
4013       break;
4014     case 1:
4015       new_reloc <<= 6;
4016       break;
4017     case 2:
4018       new_reloc <<= 4;
4019       break;
4020     case 3:
4021       new_reloc <<= 2;
4022       break;
4023     default:
4024       as_bad (_("Invalid argument description: %d"), reg);
4025     }
4026
4027   return new_reloc;
4028 }
4029
4030 /* Parse a PA nullification completer (,n).  Return nonzero if the
4031    completer was found; return zero if no completer was found.  */
4032
4033 static int
4034 pa_parse_nullif (s)
4035      char **s;
4036 {
4037   int nullif;
4038
4039   nullif = 0;
4040   if (**s == ',')
4041     {
4042       *s = *s + 1;
4043       if (strncasecmp (*s, "n", 1) == 0)
4044         nullif = 1;
4045       else
4046         {
4047           as_bad (_("Invalid Nullification: (%c)"), **s);
4048           nullif = 0;
4049         }
4050       *s = *s + 1;
4051     }
4052
4053   return nullif;
4054 }
4055
4056 /* Parse a non-negated compare/subtract completer returning the
4057    number (for encoding in instrutions) of the given completer.
4058
4059    ISBRANCH specifies whether or not this is parsing a condition
4060    completer for a branch (vs a nullification completer for a
4061    computational instruction.  */
4062
4063 static int
4064 pa_parse_nonneg_cmpsub_cmpltr (s, isbranch)
4065      char **s;
4066      int isbranch;
4067 {
4068   int cmpltr;
4069   char *name = *s + 1;
4070   char c;
4071   char *save_s = *s;
4072   int nullify = 0;
4073
4074   cmpltr = 0;
4075   if (**s == ',')
4076     {
4077       *s += 1;
4078       while (**s != ',' && **s != ' ' && **s != '\t')
4079         *s += 1;
4080       c = **s;
4081       **s = 0x00;
4082
4083
4084       if (strcmp (name, "=") == 0)
4085         {
4086           cmpltr = 1;
4087         }
4088       else if (strcmp (name, "<") == 0)
4089         {
4090           cmpltr = 2;
4091         }
4092       else if (strcmp (name, "<=") == 0)
4093         {
4094           cmpltr = 3;
4095         }
4096       else if (strcmp (name, "<<") == 0)
4097         {
4098           cmpltr = 4;
4099         }
4100       else if (strcmp (name, "<<=") == 0)
4101         {
4102           cmpltr = 5;
4103         }
4104       else if (strcasecmp (name, "sv") == 0)
4105         {
4106           cmpltr = 6;
4107         }
4108       else if (strcasecmp (name, "od") == 0)
4109         {
4110           cmpltr = 7;
4111         }
4112       /* If we have something like addb,n then there is no condition
4113          completer.  */
4114       else if (strcasecmp (name, "n") == 0 && isbranch)
4115         {
4116           cmpltr = 0;
4117           nullify = 1;
4118         }
4119       else
4120         {
4121           cmpltr = -1;
4122         }
4123       **s = c;
4124     }
4125
4126   /* Reset pointers if this was really a ,n for a branch instruction.  */
4127   if (nullify)
4128     *s = save_s;
4129
4130
4131   return cmpltr;
4132 }
4133
4134 /* Parse a negated compare/subtract completer returning the
4135    number (for encoding in instrutions) of the given completer.
4136
4137    ISBRANCH specifies whether or not this is parsing a condition
4138    completer for a branch (vs a nullification completer for a
4139    computational instruction.  */
4140
4141 static int
4142 pa_parse_neg_cmpsub_cmpltr (s, isbranch)
4143      char **s;
4144      int isbranch;
4145 {
4146   int cmpltr;
4147   char *name = *s + 1;
4148   char c;
4149   char *save_s = *s;
4150   int nullify = 0;
4151
4152   cmpltr = 0;
4153   if (**s == ',')
4154     {
4155       *s += 1;
4156       while (**s != ',' && **s != ' ' && **s != '\t')
4157         *s += 1;
4158       c = **s;
4159       **s = 0x00;
4160
4161
4162       if (strcasecmp (name, "tr") == 0)
4163         {
4164           cmpltr = 0;
4165         }
4166       else if (strcmp (name, "<>") == 0)
4167         {
4168           cmpltr = 1;
4169         }
4170       else if (strcmp (name, ">=") == 0)
4171         {
4172           cmpltr = 2;
4173         }
4174       else if (strcmp (name, ">") == 0)
4175         {
4176           cmpltr = 3;
4177         }
4178       else if (strcmp (name, ">>=") == 0)
4179         {
4180           cmpltr = 4;
4181         }
4182       else if (strcmp (name, ">>") == 0)
4183         {
4184           cmpltr = 5;
4185         }
4186       else if (strcasecmp (name, "nsv") == 0)
4187         {
4188           cmpltr = 6;
4189         }
4190       else if (strcasecmp (name, "ev") == 0)
4191         {
4192           cmpltr = 7;
4193         }
4194       /* If we have something like addb,n then there is no condition
4195          completer.  */
4196       else if (strcasecmp (name, "n") == 0 && isbranch)
4197         {
4198           cmpltr = 0;
4199           nullify = 1;
4200         }
4201       else
4202         {
4203           cmpltr = -1;
4204         }
4205       **s = c;
4206     }
4207
4208   /* Reset pointers if this was really a ,n for a branch instruction.  */
4209   if (nullify)
4210     *s = save_s;
4211
4212
4213   return cmpltr;
4214 }
4215
4216
4217 /* Parse a non-negated addition completer returning the number
4218    (for encoding in instrutions) of the given completer.
4219
4220    ISBRANCH specifies whether or not this is parsing a condition
4221    completer for a branch (vs a nullification completer for a
4222    computational instruction.  */
4223
4224 static int
4225 pa_parse_nonneg_add_cmpltr (s, isbranch)
4226      char **s;
4227      int isbranch;
4228 {
4229   int cmpltr;
4230   char *name = *s + 1;
4231   char c;
4232   char *save_s = *s;
4233
4234   cmpltr = 0;
4235   if (**s == ',')
4236     {
4237       *s += 1;
4238       while (**s != ',' && **s != ' ' && **s != '\t')
4239         *s += 1;
4240       c = **s;
4241       **s = 0x00;
4242       if (strcmp (name, "=") == 0)
4243         {
4244           cmpltr = 1;
4245         }
4246       else if (strcmp (name, "<") == 0)
4247         {
4248           cmpltr = 2;
4249         }
4250       else if (strcmp (name, "<=") == 0)
4251         {
4252           cmpltr = 3;
4253         }
4254       else if (strcasecmp (name, "nuv") == 0)
4255         {
4256           cmpltr = 4;
4257         }
4258       else if (strcasecmp (name, "znv") == 0)
4259         {
4260           cmpltr = 5;
4261         }
4262       else if (strcasecmp (name, "sv") == 0)
4263         {
4264           cmpltr = 6;
4265         }
4266       else if (strcasecmp (name, "od") == 0)
4267         {
4268           cmpltr = 7;
4269         }
4270       /* If we have something like addb,n then there is no condition
4271          completer.  */
4272       else if (strcasecmp (name, "n") == 0 && isbranch)
4273         {
4274           cmpltr = 0;
4275         }
4276       else
4277         {
4278           cmpltr = -1;
4279         }
4280       **s = c;
4281     }
4282
4283   /* Reset pointers if this was really a ,n for a branch instruction.  */
4284   if (cmpltr == 0 && *name == 'n' && isbranch)
4285     *s = save_s;
4286
4287   return cmpltr;
4288 }
4289
4290 /* Parse a negated addition completer returning the number
4291    (for encoding in instrutions) of the given completer.
4292
4293    ISBRANCH specifies whether or not this is parsing a condition
4294    completer for a branch (vs a nullification completer for a
4295    computational instruction).  */
4296
4297 static int
4298 pa_parse_neg_add_cmpltr (s, isbranch)
4299      char **s;
4300      int isbranch;
4301 {
4302   int cmpltr;
4303   char *name = *s + 1;
4304   char c;
4305   char *save_s = *s;
4306
4307   cmpltr = 0;
4308   if (**s == ',')
4309     {
4310       *s += 1;
4311       while (**s != ',' && **s != ' ' && **s != '\t')
4312         *s += 1;
4313       c = **s;
4314       **s = 0x00;
4315       if (strcasecmp (name, "tr") == 0)
4316         {
4317           cmpltr = 0;
4318         }
4319       else if (strcmp (name, "<>") == 0)
4320         {
4321           cmpltr = 1;
4322         }
4323       else if (strcmp (name, ">=") == 0)
4324         {
4325           cmpltr = 2;
4326         }
4327       else if (strcmp (name, ">") == 0)
4328         {
4329           cmpltr = 3;
4330         }
4331       else if (strcasecmp (name, "uv") == 0)
4332         {
4333           cmpltr = 4;
4334         }
4335       else if (strcasecmp (name, "vnz") == 0)
4336         {
4337           cmpltr = 5;
4338         }
4339       else if (strcasecmp (name, "nsv") == 0)
4340         {
4341           cmpltr = 6;
4342         }
4343       else if (strcasecmp (name, "ev") == 0)
4344         {
4345           cmpltr = 7;
4346         }
4347       /* If we have something like addb,n then there is no condition
4348          completer.  */
4349       else if (strcasecmp (name, "n") == 0 && isbranch)
4350         {
4351           cmpltr = 0;
4352         }
4353       else
4354         {
4355           cmpltr = -1;
4356         }
4357       **s = c;
4358     }
4359
4360   /* Reset pointers if this was really a ,n for a branch instruction.  */
4361   if (cmpltr == 0 && *name == 'n' && isbranch)
4362     *s = save_s;
4363
4364   return cmpltr;
4365 }
4366
4367 #ifdef OBJ_SOM
4368 /* Handle an alignment directive.  Special so that we can update the
4369    alignment of the subspace if necessary.  */
4370 static void
4371 pa_align (bytes)
4372 {
4373   /* We must have a valid space and subspace.  */
4374   pa_check_current_space_and_subspace ();
4375
4376   /* Let the generic gas code do most of the work.  */
4377   s_align_bytes (bytes);
4378
4379   /* If bytes is a power of 2, then update the current subspace's
4380      alignment if necessary.  */
4381   if (log2 (bytes) != -1)
4382     record_alignment (current_subspace->ssd_seg, log2 (bytes));
4383 }
4384 #endif
4385
4386 /* Handle a .BLOCK type pseudo-op.  */
4387
4388 static void
4389 pa_block (z)
4390      int z;
4391 {
4392   char *p;
4393   long int temp_fill;
4394   unsigned int temp_size;
4395   unsigned int i;
4396
4397 #ifdef OBJ_SOM
4398   /* We must have a valid space and subspace.  */
4399   pa_check_current_space_and_subspace ();
4400 #endif
4401
4402   temp_size = get_absolute_expression ();
4403
4404   /* Always fill with zeros, that's what the HP assembler does.  */
4405   temp_fill = 0;
4406
4407   p = frag_var (rs_fill, (int) temp_size, (int) temp_size,
4408                 (relax_substateT) 0, (symbolS *) 0, (offsetT) 1, NULL);
4409   memset (p, 0, temp_size);
4410
4411   /* Convert 2 bytes at a time.  */
4412
4413   for (i = 0; i < temp_size; i += 2)
4414     {
4415       md_number_to_chars (p + i,
4416                           (valueT) temp_fill,
4417                           (int) ((temp_size - i) > 2 ? 2 : (temp_size - i)));
4418     }
4419
4420   pa_undefine_label ();
4421   demand_empty_rest_of_line ();
4422 }
4423
4424 /* Handle a .begin_brtab and .end_brtab pseudo-op.  */
4425
4426 static void
4427 pa_brtab (begin)
4428      int begin;
4429 {
4430
4431 #ifdef OBJ_SOM
4432   /* The BRTAB relocations are only availble in SOM (to denote
4433      the beginning and end of branch tables).  */
4434   char *where = frag_more (0);
4435
4436   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
4437                 NULL, (offsetT) 0, NULL,
4438                 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
4439                 e_fsel, 0, 0, NULL);
4440 #endif
4441
4442   demand_empty_rest_of_line ();
4443 }
4444
4445 /* Handle a .begin_try and .end_try pseudo-op.  */
4446
4447 static void
4448 pa_try (begin)
4449      int begin;
4450 {
4451 #ifdef OBJ_SOM
4452   expressionS exp;
4453   char *where = frag_more (0);
4454
4455   if (! begin)
4456     expression (&exp);
4457
4458   /* The TRY relocations are only availble in SOM (to denote
4459      the beginning and end of exception handling regions).  */
4460
4461   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
4462                 NULL, (offsetT) 0, begin ? NULL : &exp,
4463                 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
4464                 e_fsel, 0, 0, NULL);
4465 #endif
4466
4467   demand_empty_rest_of_line ();
4468 }
4469
4470 /* Handle a .CALL pseudo-op.  This involves storing away information
4471    about where arguments are to be found so the linker can detect
4472    (and correct) argument location mismatches between caller and callee.  */
4473
4474 static void
4475 pa_call (unused)
4476      int unused;
4477 {
4478 #ifdef OBJ_SOM
4479   /* We must have a valid space and subspace.  */
4480   pa_check_current_space_and_subspace ();
4481 #endif
4482
4483   pa_call_args (&last_call_desc);
4484   demand_empty_rest_of_line ();
4485 }
4486
4487 /* Do the dirty work of building a call descriptor which describes
4488    where the caller placed arguments to a function call.  */
4489
4490 static void
4491 pa_call_args (call_desc)
4492      struct call_desc *call_desc;
4493 {
4494   char *name, c, *p;
4495   unsigned int temp, arg_reloc;
4496
4497   while (!is_end_of_statement ())
4498     {
4499       name = input_line_pointer;
4500       c = get_symbol_end ();
4501       /* Process a source argument.  */
4502       if ((strncasecmp (name, "argw", 4) == 0))
4503         {
4504           temp = atoi (name + 4);
4505           p = input_line_pointer;
4506           *p = c;
4507           input_line_pointer++;
4508           name = input_line_pointer;
4509           c = get_symbol_end ();
4510           arg_reloc = pa_build_arg_reloc (name);
4511           call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
4512         }
4513       /* Process a return value.  */
4514       else if ((strncasecmp (name, "rtnval", 6) == 0))
4515         {
4516           p = input_line_pointer;
4517           *p = c;
4518           input_line_pointer++;
4519           name = input_line_pointer;
4520           c = get_symbol_end ();
4521           arg_reloc = pa_build_arg_reloc (name);
4522           call_desc->arg_reloc |= (arg_reloc & 0x3);
4523         }
4524       else
4525         {
4526           as_bad (_("Invalid .CALL argument: %s"), name);
4527         }
4528       p = input_line_pointer;
4529       *p = c;
4530       if (!is_end_of_statement ())
4531         input_line_pointer++;
4532     }
4533 }
4534
4535 /* Return TRUE if FRAG1 and FRAG2 are the same.  */
4536
4537 static int
4538 is_same_frag (frag1, frag2)
4539      fragS *frag1;
4540      fragS *frag2;
4541 {
4542
4543   if (frag1 == NULL)
4544     return (FALSE);
4545   else if (frag2 == NULL)
4546     return (FALSE);
4547   else if (frag1 == frag2)
4548     return (TRUE);
4549   else if (frag2->fr_type == rs_fill && frag2->fr_fix == 0)
4550     return (is_same_frag (frag1, frag2->fr_next));
4551   else
4552     return (FALSE);
4553 }
4554
4555 #ifdef OBJ_ELF
4556 /* Build an entry in the UNWIND subspace from the given function
4557    attributes in CALL_INFO.  This is not needed for SOM as using
4558    R_ENTRY and R_EXIT relocations allow the linker to handle building
4559    of the unwind spaces.  */
4560
4561 static void
4562 pa_build_unwind_subspace (call_info)
4563      struct call_info *call_info;
4564 {
4565   char *unwind;
4566   asection *seg, *save_seg;
4567   asymbol *sym;
4568   subsegT subseg, save_subseg;
4569   int i, reloc;
4570   char c, *p;
4571
4572   if (bfd_get_arch_info (stdoutput)->bits_per_address == 32)
4573     reloc = R_PARISC_DIR32;
4574   else
4575     reloc = R_PARISC_SEGREL32;
4576
4577   /* Get into the right seg/subseg.  This may involve creating
4578      the seg the first time through.  Make sure to have the
4579      old seg/subseg so that we can reset things when we are done.  */
4580   seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
4581   if (seg == ASEC_NULL)
4582     {
4583       seg = bfd_make_section_old_way (stdoutput, UNWIND_SECTION_NAME);
4584       bfd_set_section_flags (stdoutput, seg,
4585                              SEC_READONLY | SEC_HAS_CONTENTS
4586                              | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
4587       bfd_set_section_alignment (stdoutput, seg, 2);
4588     }
4589
4590   save_seg = now_seg;
4591   save_subseg = now_subseg;
4592   subseg_set (seg, 0);
4593
4594
4595   /* Get some space to hold relocation information for the unwind
4596      descriptor.  */
4597   p = frag_more (4);
4598   md_number_to_chars (p, 0, 4);
4599
4600   /* Relocation info. for start offset of the function.  */
4601   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
4602                 call_info->start_symbol, (offsetT) 0,
4603                 (expressionS *) NULL, 0, reloc,
4604                 e_fsel, 32, 0, NULL);
4605
4606   p = frag_more (4);
4607   md_number_to_chars (p, 0, 4);
4608
4609   /* Relocation info. for end offset of the function.
4610
4611      Because we allow reductions of 32bit relocations for ELF, this will be
4612      reduced to section_sym + offset which avoids putting the temporary
4613      symbol into the symbol table.  It (should) end up giving the same
4614      value as call_info->start_symbol + function size once the linker is
4615      finished with its work.  */
4616
4617   fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
4618                 call_info->end_symbol, (offsetT) 0,
4619                 (expressionS *) NULL, 0, reloc,
4620                 e_fsel, 32, 0, NULL);
4621
4622   /* Dump it. */
4623   unwind = (char *) &call_info->ci_unwind;
4624   for (i = 8; i < sizeof (struct unwind_table); i++)
4625     {
4626       c = *(unwind + i);
4627       {
4628         FRAG_APPEND_1_CHAR (c);
4629       }
4630     }
4631
4632   /* Return back to the original segment/subsegment.  */
4633   subseg_set (save_seg, save_subseg);
4634 }
4635 #endif
4636
4637 /* Process a .CALLINFO pseudo-op.  This information is used later
4638    to build unwind descriptors and maybe one day to support
4639    .ENTER and .LEAVE.  */
4640
4641 static void
4642 pa_callinfo (unused)
4643      int unused;
4644 {
4645   char *name, c, *p;
4646   int temp;
4647
4648 #ifdef OBJ_SOM
4649   /* We must have a valid space and subspace.  */
4650   pa_check_current_space_and_subspace ();
4651 #endif
4652
4653   /* .CALLINFO must appear within a procedure definition.  */
4654   if (!within_procedure)
4655     as_bad (_(".callinfo is not within a procedure definition"));
4656
4657   /* Mark the fact that we found the .CALLINFO for the
4658      current procedure.  */
4659   callinfo_found = TRUE;
4660
4661   /* Iterate over the .CALLINFO arguments.  */
4662   while (!is_end_of_statement ())
4663     {
4664       name = input_line_pointer;
4665       c = get_symbol_end ();
4666       /* Frame size specification.  */
4667       if ((strncasecmp (name, "frame", 5) == 0))
4668         {
4669           p = input_line_pointer;
4670           *p = c;
4671           input_line_pointer++;
4672           temp = get_absolute_expression ();
4673           if ((temp & 0x3) != 0)
4674             {
4675               as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
4676               temp = 0;
4677             }
4678
4679           /* callinfo is in bytes and unwind_desc is in 8 byte units.  */
4680           last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
4681
4682         }
4683       /* Entry register (GR, GR and SR) specifications.  */
4684       else if ((strncasecmp (name, "entry_gr", 8) == 0))
4685         {
4686           p = input_line_pointer;
4687           *p = c;
4688           input_line_pointer++;
4689           temp = get_absolute_expression ();
4690           /* The HP assembler accepts 19 as the high bound for ENTRY_GR
4691              even though %r19 is caller saved.  I think this is a bug in
4692              the HP assembler, and we are not going to emulate it.  */
4693           if (temp < 3 || temp > 18)
4694             as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
4695           last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
4696         }
4697       else if ((strncasecmp (name, "entry_fr", 8) == 0))
4698         {
4699           p = input_line_pointer;
4700           *p = c;
4701           input_line_pointer++;
4702           temp = get_absolute_expression ();
4703           /* Similarly the HP assembler takes 31 as the high bound even
4704              though %fr21 is the last callee saved floating point register.  */
4705           if (temp < 12 || temp > 21)
4706             as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
4707           last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
4708         }
4709       else if ((strncasecmp (name, "entry_sr", 8) == 0))
4710         {
4711           p = input_line_pointer;
4712           *p = c;
4713           input_line_pointer++;
4714           temp = get_absolute_expression ();
4715           if (temp != 3)
4716             as_bad (_("Value for ENTRY_SR must be 3\n"));
4717         }
4718       /* Note whether or not this function performs any calls.  */
4719       else if ((strncasecmp (name, "calls", 5) == 0) ||
4720                (strncasecmp (name, "caller", 6) == 0))
4721         {
4722           p = input_line_pointer;
4723           *p = c;
4724         }
4725       else if ((strncasecmp (name, "no_calls", 8) == 0))
4726         {
4727           p = input_line_pointer;
4728           *p = c;
4729         }
4730       /* Should RP be saved into the stack.  */
4731       else if ((strncasecmp (name, "save_rp", 7) == 0))
4732         {
4733           p = input_line_pointer;
4734           *p = c;
4735           last_call_info->ci_unwind.descriptor.save_rp = 1;
4736         }
4737       /* Likewise for SP.  */
4738       else if ((strncasecmp (name, "save_sp", 7) == 0))
4739         {
4740           p = input_line_pointer;
4741           *p = c;
4742           last_call_info->ci_unwind.descriptor.save_sp = 1;
4743         }
4744       /* Is this an unwindable procedure.  If so mark it so
4745          in the unwind descriptor.  */
4746       else if ((strncasecmp (name, "no_unwind", 9) == 0))
4747         {
4748           p = input_line_pointer;
4749           *p = c;
4750           last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
4751         }
4752       /* Is this an interrupt routine.  If so mark it in the
4753          unwind descriptor.  */
4754       else if ((strncasecmp (name, "hpux_int", 7) == 0))
4755         {
4756           p = input_line_pointer;
4757           *p = c;
4758           last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
4759         }
4760       /* Is this a millicode routine.  "millicode" isn't in my
4761          assembler manual, but my copy is old.  The HP assembler
4762          accepts it, and there's a place in the unwind descriptor
4763          to drop the information, so we'll accept it too.  */
4764       else if ((strncasecmp (name, "millicode", 9) == 0))
4765         {
4766           p = input_line_pointer;
4767           *p = c;
4768           last_call_info->ci_unwind.descriptor.millicode = 1;
4769         }
4770       else
4771         {
4772           as_bad (_("Invalid .CALLINFO argument: %s"), name);
4773           *input_line_pointer = c;
4774         }
4775       if (!is_end_of_statement ())
4776         input_line_pointer++;
4777     }
4778
4779   demand_empty_rest_of_line ();
4780 }
4781
4782 /* Switch into the code subspace.  */
4783
4784 static void
4785 pa_code (unused)
4786      int unused;
4787 {
4788 #ifdef OBJ_SOM
4789   current_space = is_defined_space ("$TEXT$");
4790   current_subspace
4791     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
4792 #endif
4793   s_text (0);
4794   pa_undefine_label ();
4795 }
4796
4797 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
4798    the .comm pseudo-op has the following symtax:
4799
4800    <label> .comm <length>
4801
4802    where <label> is optional and is a symbol whose address will be the start of
4803    a block of memory <length> bytes long. <length> must be an absolute
4804    expression.  <length> bytes will be allocated in the current space
4805    and subspace.
4806
4807    Also note the label may not even be on the same line as the .comm.
4808
4809    This difference in syntax means the colon function will be called
4810    on the symbol before we arrive in pa_comm.  colon will set a number
4811    of attributes of the symbol that need to be fixed here.  In particular
4812    the value, section pointer, fragment pointer, flags, etc.  What
4813    a pain.
4814
4815    This also makes error detection all but impossible.  */
4816
4817 static void
4818 pa_comm (unused)
4819      int unused;
4820 {
4821   unsigned int size;
4822   symbolS *symbol;
4823   label_symbol_struct *label_symbol = pa_get_label ();
4824
4825   if (label_symbol)
4826     symbol = label_symbol->lss_label;
4827   else
4828     symbol = NULL;
4829
4830   SKIP_WHITESPACE ();
4831   size = get_absolute_expression ();
4832
4833   if (symbol)
4834     {
4835       S_SET_VALUE (symbol, size);
4836       S_SET_SEGMENT (symbol, bfd_und_section_ptr);
4837       S_SET_EXTERNAL (symbol);
4838
4839       /* colon() has already set the frag to the current location in the
4840          current subspace; we need to reset the fragment to the zero address
4841          fragment.  We also need to reset the segment pointer.  */
4842       symbol_set_frag (symbol, &zero_address_frag);
4843     }
4844   demand_empty_rest_of_line ();
4845 }
4846
4847 /* Process a .END pseudo-op.  */
4848
4849 static void
4850 pa_end (unused)
4851      int unused;
4852 {
4853   demand_empty_rest_of_line ();
4854 }
4855
4856 /* Process a .ENTER pseudo-op.  This is not supported.  */
4857 static void
4858 pa_enter (unused)
4859      int unused;
4860 {
4861 #ifdef OBJ_SOM
4862   /* We must have a valid space and subspace.  */
4863   pa_check_current_space_and_subspace ();
4864 #endif
4865
4866   as_bad (_("The .ENTER pseudo-op is not supported"));
4867   demand_empty_rest_of_line ();
4868 }
4869
4870 /* Process a .ENTRY pseudo-op.  .ENTRY marks the beginning of the
4871    procesure.  */
4872 static void
4873 pa_entry (unused)
4874      int unused;
4875 {
4876 #ifdef OBJ_SOM
4877   /* We must have a valid space and subspace.  */
4878   pa_check_current_space_and_subspace ();
4879 #endif
4880
4881   if (!within_procedure)
4882     as_bad (_("Misplaced .entry. Ignored."));
4883   else
4884     {
4885       if (!callinfo_found)
4886         as_bad (_("Missing .callinfo."));
4887     }
4888   demand_empty_rest_of_line ();
4889   within_entry_exit = TRUE;
4890
4891 #ifdef OBJ_SOM
4892   /* SOM defers building of unwind descriptors until the link phase.
4893      The assembler is responsible for creating an R_ENTRY relocation
4894      to mark the beginning of a region and hold the unwind bits, and
4895      for creating an R_EXIT relocation to mark the end of the region.
4896
4897      FIXME.  ELF should be using the same conventions!  The problem
4898      is an unwind requires too much relocation space.  Hmmm.  Maybe
4899      if we split the unwind bits up between the relocations which
4900      denote the entry and exit points.  */
4901   if (last_call_info->start_symbol != NULL)
4902     {
4903       char *where = frag_more (0);
4904
4905       fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
4906                     NULL, (offsetT) 0, NULL,
4907                     0, R_HPPA_ENTRY, e_fsel, 0, 0,
4908                     (int *) &last_call_info->ci_unwind.descriptor);
4909     }
4910 #endif
4911 }
4912
4913 /* Handle a .EQU pseudo-op.  */
4914
4915 static void
4916 pa_equ (reg)
4917      int reg;
4918 {
4919   label_symbol_struct *label_symbol = pa_get_label ();
4920   symbolS *symbol;
4921
4922   if (label_symbol)
4923     {
4924       symbol = label_symbol->lss_label;
4925       if (reg)
4926         S_SET_VALUE (symbol, pa_parse_number (&input_line_pointer, 0));
4927       else
4928         S_SET_VALUE (symbol, (unsigned int) get_absolute_expression ());
4929       S_SET_SEGMENT (symbol, bfd_abs_section_ptr);
4930     }
4931   else
4932     {
4933       if (reg)
4934         as_bad (_(".REG must use a label"));
4935       else
4936         as_bad (_(".EQU must use a label"));
4937     }
4938
4939   pa_undefine_label ();
4940   demand_empty_rest_of_line ();
4941 }
4942
4943 /* Helper function.  Does processing for the end of a function.  This
4944    usually involves creating some relocations or building special
4945    symbols to mark the end of the function.  */
4946
4947 static void
4948 process_exit ()
4949 {
4950   char *where;
4951
4952   where = frag_more (0);
4953
4954 #ifdef OBJ_ELF
4955   /* Mark the end of the function, stuff away the location of the frag
4956      for the end of the function, and finally call pa_build_unwind_subspace
4957      to add an entry in the unwind table.  */
4958   hppa_elf_mark_end_of_function ();
4959   pa_build_unwind_subspace (last_call_info);
4960 #else
4961   /* SOM defers building of unwind descriptors until the link phase.
4962      The assembler is responsible for creating an R_ENTRY relocation
4963      to mark the beginning of a region and hold the unwind bits, and
4964      for creating an R_EXIT relocation to mark the end of the region.
4965
4966      FIXME.  ELF should be using the same conventions!  The problem
4967      is an unwind requires too much relocation space.  Hmmm.  Maybe
4968      if we split the unwind bits up between the relocations which
4969      denote the entry and exit points.  */
4970   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
4971                 NULL, (offsetT) 0,
4972                 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
4973                 (int *) &last_call_info->ci_unwind.descriptor + 1);
4974 #endif
4975 }
4976
4977 /* Process a .EXIT pseudo-op.  */
4978
4979 static void
4980 pa_exit (unused)
4981      int unused;
4982 {
4983 #ifdef OBJ_SOM
4984   /* We must have a valid space and subspace.  */
4985   pa_check_current_space_and_subspace ();
4986 #endif
4987
4988   if (!within_procedure)
4989     as_bad (_(".EXIT must appear within a procedure"));
4990   else
4991     {
4992       if (!callinfo_found)
4993         as_bad (_("Missing .callinfo"));
4994       else
4995         {
4996           if (!within_entry_exit)
4997             as_bad (_("No .ENTRY for this .EXIT"));
4998           else
4999             {
5000               within_entry_exit = FALSE;
5001               process_exit ();
5002             }
5003         }
5004     }
5005   demand_empty_rest_of_line ();
5006 }
5007
5008 /* Process a .EXPORT directive.  This makes functions external
5009    and provides information such as argument relocation entries
5010    to callers.  */
5011
5012 static void
5013 pa_export (unused)
5014      int unused;
5015 {
5016   char *name, c, *p;
5017   symbolS *symbol;
5018
5019   name = input_line_pointer;
5020   c = get_symbol_end ();
5021   /* Make sure the given symbol exists.  */
5022   if ((symbol = symbol_find_or_make (name)) == NULL)
5023     {
5024       as_bad (_("Cannot define export symbol: %s\n"), name);
5025       p = input_line_pointer;
5026       *p = c;
5027       input_line_pointer++;
5028     }
5029   else
5030     {
5031       /* OK.  Set the external bits and process argument relocations.  */
5032       S_SET_EXTERNAL (symbol);
5033       p = input_line_pointer;
5034       *p = c;
5035       if (!is_end_of_statement ())
5036         {
5037           input_line_pointer++;
5038           pa_type_args (symbol, 1);
5039         }
5040     }
5041
5042   demand_empty_rest_of_line ();
5043 }
5044
5045 /* Helper function to process arguments to a .EXPORT pseudo-op.  */
5046
5047 static void
5048 pa_type_args (symbolP, is_export)
5049      symbolS *symbolP;
5050      int is_export;
5051 {
5052   char *name, c, *p;
5053   unsigned int temp, arg_reloc;
5054   pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
5055   obj_symbol_type *symbol = (obj_symbol_type *) symbol_get_bfdsym (symbolP);
5056
5057   if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
5058
5059     {
5060       input_line_pointer += 8;
5061       symbol_get_bfdsym (symbolP)->flags &= ~BSF_FUNCTION;
5062       S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
5063       type = SYMBOL_TYPE_ABSOLUTE;
5064     }
5065   else if (strncasecmp (input_line_pointer, "code", 4) == 0)
5066     {
5067       input_line_pointer += 4;
5068       /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
5069          instead one should be IMPORTing/EXPORTing ENTRY types.
5070
5071          Complain if one tries to EXPORT a CODE type since that's never
5072          done.  Both GCC and HP C still try to IMPORT CODE types, so
5073          silently fix them to be ENTRY types.  */
5074       if (S_IS_FUNCTION (symbolP))
5075         {
5076           if (is_export)
5077             as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
5078                        S_GET_NAME (symbolP));
5079
5080           symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5081           type = SYMBOL_TYPE_ENTRY;
5082         }
5083       else
5084         {
5085           symbol_get_bfdsym (symbolP)->flags &= ~BSF_FUNCTION;
5086           type = SYMBOL_TYPE_CODE;
5087         }
5088     }
5089   else if (strncasecmp (input_line_pointer, "data", 4) == 0)
5090     {
5091       input_line_pointer += 4;
5092       symbol_get_bfdsym (symbolP)->flags &= ~BSF_FUNCTION;
5093       type = SYMBOL_TYPE_DATA;
5094     }
5095   else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
5096     {
5097       input_line_pointer += 5;
5098       symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5099       type = SYMBOL_TYPE_ENTRY;
5100     }
5101   else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
5102     {
5103       input_line_pointer += 9;
5104       symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5105       type = SYMBOL_TYPE_MILLICODE;
5106     }
5107   else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
5108     {
5109       input_line_pointer += 6;
5110       symbol_get_bfdsym (symbolP)->flags &= ~BSF_FUNCTION;
5111       type = SYMBOL_TYPE_PLABEL;
5112     }
5113   else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
5114     {
5115       input_line_pointer += 8;
5116       symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5117       type = SYMBOL_TYPE_PRI_PROG;
5118     }
5119   else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
5120     {
5121       input_line_pointer += 8;
5122       symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5123       type = SYMBOL_TYPE_SEC_PROG;
5124     }
5125
5126   /* SOM requires much more information about symbol types
5127      than BFD understands.  This is how we get this information
5128      to the SOM BFD backend.  */
5129 #ifdef obj_set_symbol_type
5130   obj_set_symbol_type (symbol_get_bfdsym (symbolP), (int) type);
5131 #endif
5132
5133   /* Now that the type of the exported symbol has been handled,
5134      handle any argument relocation information.  */
5135   while (!is_end_of_statement ())
5136     {
5137       if (*input_line_pointer == ',')
5138         input_line_pointer++;
5139       name = input_line_pointer;
5140       c = get_symbol_end ();
5141       /* Argument sources.  */
5142       if ((strncasecmp (name, "argw", 4) == 0))
5143         {
5144           p = input_line_pointer;
5145           *p = c;
5146           input_line_pointer++;
5147           temp = atoi (name + 4);
5148           name = input_line_pointer;
5149           c = get_symbol_end ();
5150           arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
5151 #ifdef OBJ_SOM
5152           symbol->tc_data.ap.hppa_arg_reloc |= arg_reloc;
5153 #endif
5154           *input_line_pointer = c;
5155         }
5156       /* The return value.  */
5157       else if ((strncasecmp (name, "rtnval", 6)) == 0)
5158         {
5159           p = input_line_pointer;
5160           *p = c;
5161           input_line_pointer++;
5162           name = input_line_pointer;
5163           c = get_symbol_end ();
5164           arg_reloc = pa_build_arg_reloc (name);
5165 #ifdef OBJ_SOM
5166           symbol->tc_data.ap.hppa_arg_reloc |= arg_reloc;
5167 #endif
5168           *input_line_pointer = c;
5169         }
5170       /* Privelege level.  */
5171       else if ((strncasecmp (name, "priv_lev", 8)) == 0)
5172         {
5173           p = input_line_pointer;
5174           *p = c;
5175           input_line_pointer++;
5176           temp = atoi (input_line_pointer);
5177 #ifdef OBJ_SOM
5178           symbol->tc_data.ap.hppa_priv_level = temp;
5179 #endif
5180           c = get_symbol_end ();
5181           *input_line_pointer = c;
5182         }
5183       else
5184         {
5185           as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
5186           p = input_line_pointer;
5187           *p = c;
5188         }
5189       if (!is_end_of_statement ())
5190         input_line_pointer++;
5191     }
5192 }
5193
5194 /* Handle an .IMPORT pseudo-op.  Any symbol referenced in a given
5195    assembly file must either be defined in the assembly file, or
5196    explicitly IMPORTED from another.  */
5197
5198 static void
5199 pa_import (unused)
5200      int unused;
5201 {
5202   char *name, c, *p;
5203   symbolS *symbol;
5204
5205   name = input_line_pointer;
5206   c = get_symbol_end ();
5207
5208   symbol = symbol_find (name);
5209   /* Ugh.  We might be importing a symbol defined earlier in the file,
5210      in which case all the code below will really screw things up
5211      (set the wrong segment, symbol flags & type, etc).  */
5212   if (symbol == NULL || !S_IS_DEFINED (symbol))
5213     {
5214       symbol = symbol_find_or_make (name);
5215       p = input_line_pointer;
5216       *p = c;
5217
5218       if (!is_end_of_statement ())
5219         {
5220           input_line_pointer++;
5221           pa_type_args (symbol, 0);
5222         }
5223       else
5224         {
5225           /* Sigh.  To be compatable with the HP assembler and to help
5226              poorly written assembly code, we assign a type based on
5227              the the current segment.  Note only BSF_FUNCTION really
5228              matters, we do not need to set the full SYMBOL_TYPE_* info.  */
5229           if (now_seg == text_section)
5230             symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
5231
5232           /* If the section is undefined, then the symbol is undefined
5233              Since this is an import, leave the section undefined.  */
5234           S_SET_SEGMENT (symbol, bfd_und_section_ptr);
5235         }
5236     }
5237   else
5238     {
5239       /* The symbol was already defined.  Just eat everything up to
5240          the end of the current statement.  */
5241       while (!is_end_of_statement ())
5242         input_line_pointer++;
5243     }
5244
5245   demand_empty_rest_of_line ();
5246 }
5247
5248 /* Handle a .LABEL pseudo-op.  */
5249
5250 static void
5251 pa_label (unused)
5252      int unused;
5253 {
5254   char *name, c, *p;
5255
5256   name = input_line_pointer;
5257   c = get_symbol_end ();
5258
5259   if (strlen (name) > 0)
5260     {
5261       colon (name);
5262       p = input_line_pointer;
5263       *p = c;
5264     }
5265   else
5266     {
5267       as_warn (_("Missing label name on .LABEL"));
5268     }
5269
5270   if (!is_end_of_statement ())
5271     {
5272       as_warn (_("extra .LABEL arguments ignored."));
5273       ignore_rest_of_line ();
5274     }
5275   demand_empty_rest_of_line ();
5276 }
5277
5278 /* Handle a .LEAVE pseudo-op.  This is not supported yet.  */
5279
5280 static void
5281 pa_leave (unused)
5282      int unused;
5283 {
5284 #ifdef OBJ_SOM
5285   /* We must have a valid space and subspace.  */
5286   pa_check_current_space_and_subspace ();
5287 #endif
5288
5289   as_bad (_("The .LEAVE pseudo-op is not supported"));
5290   demand_empty_rest_of_line ();
5291 }
5292
5293 /* Handle a .LEVEL pseudo-op.  */
5294
5295 static void
5296 pa_level (unused)
5297      int unused;
5298 {
5299   char *level;
5300
5301   level = input_line_pointer;
5302   if (strncmp (level, "1.0", 3) == 0)
5303     {
5304       input_line_pointer += 3;
5305       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
5306         as_warn (_("could not set architecture and machine"));
5307     }
5308   else if (strncmp (level, "1.1", 3) == 0)
5309     {
5310       input_line_pointer += 3;
5311       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
5312         as_warn (_("could not set architecture and machine"));
5313     }
5314   else if (strncmp (level, "2.0w", 4) == 0)
5315     {
5316       input_line_pointer += 4;
5317       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
5318         as_warn (_("could not set architecture and machine"));
5319     }
5320   else if (strncmp (level, "2.0", 3) == 0)
5321     {
5322       input_line_pointer += 3;
5323       if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
5324         as_warn (_("could not set architecture and machine"));
5325     }
5326   else
5327     {
5328       as_bad (_("Unrecognized .LEVEL argument\n"));
5329       ignore_rest_of_line ();
5330     }
5331   demand_empty_rest_of_line ();
5332 }
5333
5334 /* Handle a .ORIGIN pseudo-op.  */
5335
5336 static void
5337 pa_origin (unused)
5338      int unused;
5339 {
5340 #ifdef OBJ_SOM
5341   /* We must have a valid space and subspace.  */
5342   pa_check_current_space_and_subspace ();
5343 #endif
5344
5345   s_org (0);
5346   pa_undefine_label ();
5347 }
5348
5349 /* Handle a .PARAM pseudo-op.  This is much like a .EXPORT, except it
5350    is for static functions.  FIXME.  Should share more code with .EXPORT.  */
5351
5352 static void
5353 pa_param (unused)
5354      int unused;
5355 {
5356   char *name, c, *p;
5357   symbolS *symbol;
5358
5359   name = input_line_pointer;
5360   c = get_symbol_end ();
5361
5362   if ((symbol = symbol_find_or_make (name)) == NULL)
5363     {
5364       as_bad (_("Cannot define static symbol: %s\n"), name);
5365       p = input_line_pointer;
5366       *p = c;
5367       input_line_pointer++;
5368     }
5369   else
5370     {
5371       S_CLEAR_EXTERNAL (symbol);
5372       p = input_line_pointer;
5373       *p = c;
5374       if (!is_end_of_statement ())
5375         {
5376           input_line_pointer++;
5377           pa_type_args (symbol, 0);
5378         }
5379     }
5380
5381   demand_empty_rest_of_line ();
5382 }
5383
5384 /* Handle a .PROC pseudo-op.  It is used to mark the beginning
5385    of a procedure from a syntatical point of view.  */
5386
5387 static void
5388 pa_proc (unused)
5389      int unused;
5390 {
5391   struct call_info *call_info;
5392
5393 #ifdef OBJ_SOM
5394   /* We must have a valid space and subspace.  */
5395   pa_check_current_space_and_subspace ();
5396 #endif
5397
5398   if (within_procedure)
5399     as_fatal (_("Nested procedures"));
5400
5401   /* Reset global variables for new procedure.  */
5402   callinfo_found = FALSE;
5403   within_procedure = TRUE;
5404
5405   /* Create another call_info structure.  */
5406   call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
5407
5408   if (!call_info)
5409     as_fatal (_("Cannot allocate unwind descriptor\n"));
5410
5411   memset (call_info, 0, sizeof (struct call_info));
5412
5413   call_info->ci_next = NULL;
5414
5415   if (call_info_root == NULL)
5416     {
5417       call_info_root = call_info;
5418       last_call_info = call_info;
5419     }
5420   else
5421     {
5422       last_call_info->ci_next = call_info;
5423       last_call_info = call_info;
5424     }
5425
5426   /* set up defaults on call_info structure */
5427
5428   call_info->ci_unwind.descriptor.cannot_unwind = 0;
5429   call_info->ci_unwind.descriptor.region_desc = 1;
5430   call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
5431
5432   /* If we got a .PROC pseudo-op, we know that the function is defined
5433      locally.  Make sure it gets into the symbol table.  */
5434   {
5435     label_symbol_struct *label_symbol = pa_get_label ();
5436
5437     if (label_symbol)
5438       {
5439         if (label_symbol->lss_label)
5440           {
5441             last_call_info->start_symbol = label_symbol->lss_label;
5442             symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
5443           }
5444         else
5445           as_bad (_("Missing function name for .PROC (corrupted label chain)"));
5446       }
5447     else
5448       last_call_info->start_symbol = NULL;
5449   }
5450
5451   demand_empty_rest_of_line ();
5452 }
5453
5454 /* Process the syntatical end of a procedure.  Make sure all the
5455    appropriate pseudo-ops were found within the procedure.  */
5456
5457 static void
5458 pa_procend (unused)
5459      int unused;
5460 {
5461
5462 #ifdef OBJ_SOM
5463   /* We must have a valid space and subspace.  */
5464   pa_check_current_space_and_subspace ();
5465 #endif
5466
5467   /* If we are within a procedure definition, make sure we've
5468      defined a label for the procedure; handle case where the
5469      label was defined after the .PROC directive.
5470
5471      Note there's not need to diddle with the segment or fragment
5472      for the label symbol in this case.  We have already switched
5473      into the new $CODE$ subspace at this point.  */
5474   if (within_procedure && last_call_info->start_symbol == NULL)
5475     {
5476       label_symbol_struct *label_symbol = pa_get_label ();
5477
5478       if (label_symbol)
5479         {
5480           if (label_symbol->lss_label)
5481             {
5482               last_call_info->start_symbol = label_symbol->lss_label;
5483               symbol_get_bfdsym (label_symbol->lss_label)->flags
5484                 |= BSF_FUNCTION;
5485 #ifdef OBJ_SOM
5486               /* Also handle allocation of a fixup to hold the unwind
5487                  information when the label appears after the proc/procend.  */
5488               if (within_entry_exit)
5489                 {
5490                   char *where = frag_more (0);
5491
5492                   fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5493                                 NULL, (offsetT) 0, NULL,
5494                                 0, R_HPPA_ENTRY, e_fsel, 0, 0,
5495                                 (int *) &last_call_info->ci_unwind.descriptor);
5496                 }
5497 #endif
5498             }
5499           else
5500             as_bad (_("Missing function name for .PROC (corrupted label chain)"));
5501         }
5502       else
5503         as_bad (_("Missing function name for .PROC"));
5504     }
5505
5506   if (!within_procedure)
5507     as_bad (_("misplaced .procend"));
5508
5509   if (!callinfo_found)
5510     as_bad (_("Missing .callinfo for this procedure"));
5511
5512   if (within_entry_exit)
5513     as_bad (_("Missing .EXIT for a .ENTRY"));
5514
5515 #ifdef OBJ_ELF
5516   /* ELF needs to mark the end of each function so that it can compute
5517      the size of the function (apparently its needed in the symbol table).  */
5518   hppa_elf_mark_end_of_function ();
5519 #endif
5520
5521   within_procedure = FALSE;
5522   demand_empty_rest_of_line ();
5523   pa_undefine_label ();
5524 }
5525
5526 /* If VALUE is an exact power of two between zero and 2^31, then
5527    return log2 (VALUE).  Else return -1.  */
5528
5529 static int
5530 log2 (value)
5531      int value;
5532 {
5533   int shift = 0;
5534
5535   while ((1 << shift) != value && shift < 32)
5536     shift++;
5537
5538   if (shift >= 32)
5539     return -1;
5540   else
5541     return shift;
5542 }
5543
5544
5545 #ifdef OBJ_SOM
5546 /* Check to make sure we have a valid space and subspace.  */
5547
5548 static void
5549 pa_check_current_space_and_subspace ()
5550 {
5551   if (current_space == NULL)
5552     as_fatal (_("Not in a space.\n"));
5553
5554   if (current_subspace == NULL)
5555     as_fatal (_("Not in a subspace.\n"));
5556 }
5557
5558 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
5559    then create a new space entry to hold the information specified
5560    by the parameters to the .SPACE directive.  */
5561
5562 static sd_chain_struct *
5563 pa_parse_space_stmt (space_name, create_flag)
5564      char *space_name;
5565      int create_flag;
5566 {
5567   char *name, *ptemp, c;
5568   char loadable, defined, private, sort;
5569   int spnum, temp;
5570   asection *seg = NULL;
5571   sd_chain_struct *space;
5572
5573   /* load default values */
5574   spnum = 0;
5575   sort = 0;
5576   loadable = TRUE;
5577   defined = TRUE;
5578   private = FALSE;
5579   if (strcmp (space_name, "$TEXT$") == 0)
5580     {
5581       seg = pa_def_spaces[0].segment;
5582       defined = pa_def_spaces[0].defined;
5583       private = pa_def_spaces[0].private;
5584       sort = pa_def_spaces[0].sort;
5585       spnum = pa_def_spaces[0].spnum;
5586     }
5587   else if (strcmp (space_name, "$PRIVATE$") == 0)
5588     {
5589       seg = pa_def_spaces[1].segment;
5590       defined = pa_def_spaces[1].defined;
5591       private = pa_def_spaces[1].private;
5592       sort = pa_def_spaces[1].sort;
5593       spnum = pa_def_spaces[1].spnum;
5594     }
5595
5596   if (!is_end_of_statement ())
5597     {
5598       print_errors = FALSE;
5599       ptemp = input_line_pointer + 1;
5600       /* First see if the space was specified as a number rather than
5601          as a name.  According to the PA assembly manual the rest of
5602          the line should be ignored.  */
5603       temp = pa_parse_number (&ptemp, 0);
5604       if (temp >= 0)
5605         {
5606           spnum = temp;
5607           input_line_pointer = ptemp;
5608         }
5609       else
5610         {
5611           while (!is_end_of_statement ())
5612             {
5613               input_line_pointer++;
5614               name = input_line_pointer;
5615               c = get_symbol_end ();
5616               if ((strncasecmp (name, "spnum", 5) == 0))
5617                 {
5618                   *input_line_pointer = c;
5619                   input_line_pointer++;
5620                   spnum = get_absolute_expression ();
5621                 }
5622               else if ((strncasecmp (name, "sort", 4) == 0))
5623                 {
5624                   *input_line_pointer = c;
5625                   input_line_pointer++;
5626                   sort = get_absolute_expression ();
5627                 }
5628               else if ((strncasecmp (name, "unloadable", 10) == 0))
5629                 {
5630                   *input_line_pointer = c;
5631                   loadable = FALSE;
5632                 }
5633               else if ((strncasecmp (name, "notdefined", 10) == 0))
5634                 {
5635                   *input_line_pointer = c;
5636                   defined = FALSE;
5637                 }
5638               else if ((strncasecmp (name, "private", 7) == 0))
5639                 {
5640                   *input_line_pointer = c;
5641                   private = TRUE;
5642                 }
5643               else
5644                 {
5645                   as_bad (_("Invalid .SPACE argument"));
5646                   *input_line_pointer = c;
5647                   if (!is_end_of_statement ())
5648                     input_line_pointer++;
5649                 }
5650             }
5651         }
5652       print_errors = TRUE;
5653     }
5654
5655   if (create_flag && seg == NULL)
5656     seg = subseg_new (space_name, 0);
5657
5658   /* If create_flag is nonzero, then create the new space with
5659      the attributes computed above.  Else set the values in
5660      an already existing space -- this can only happen for
5661      the first occurence of a built-in space.  */
5662   if (create_flag)
5663     space = create_new_space (space_name, spnum, loadable, defined,
5664                               private, sort, seg, 1);
5665   else
5666     {
5667       space = is_defined_space (space_name);
5668       SPACE_SPNUM (space) = spnum;
5669       SPACE_DEFINED (space) = defined & 1;
5670       SPACE_USER_DEFINED (space) = 1;
5671     }
5672
5673 #ifdef obj_set_section_attributes
5674   obj_set_section_attributes (seg, defined, private, sort, spnum);
5675 #endif
5676
5677   return space;
5678 }
5679
5680 /* Handle a .SPACE pseudo-op; this switches the current space to the
5681    given space, creating the new space if necessary.  */
5682
5683 static void
5684 pa_space (unused)
5685      int unused;
5686 {
5687   char *name, c, *space_name, *save_s;
5688   int temp;
5689   sd_chain_struct *sd_chain;
5690
5691   if (within_procedure)
5692     {
5693       as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
5694       ignore_rest_of_line ();
5695     }
5696   else
5697     {
5698       /* Check for some of the predefined spaces.   FIXME: most of the code
5699          below is repeated several times, can we extract the common parts
5700          and place them into a subroutine or something similar?  */
5701       /* FIXME Is this (and the next IF stmt) really right?
5702          What if INPUT_LINE_POINTER points to "$TEXT$FOO"?  */
5703       if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
5704         {
5705           input_line_pointer += 6;
5706           sd_chain = is_defined_space ("$TEXT$");
5707           if (sd_chain == NULL)
5708             sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
5709           else if (SPACE_USER_DEFINED (sd_chain) == 0)
5710             sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
5711
5712           current_space = sd_chain;
5713           subseg_set (text_section, sd_chain->sd_last_subseg);
5714           current_subspace
5715             = pa_subsegment_to_subspace (text_section,
5716                                          sd_chain->sd_last_subseg);
5717           demand_empty_rest_of_line ();
5718           return;
5719         }
5720       if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
5721         {
5722           input_line_pointer += 9;
5723           sd_chain = is_defined_space ("$PRIVATE$");
5724           if (sd_chain == NULL)
5725             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
5726           else if (SPACE_USER_DEFINED (sd_chain) == 0)
5727             sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
5728
5729           current_space = sd_chain;
5730           subseg_set (data_section, sd_chain->sd_last_subseg);
5731           current_subspace
5732             = pa_subsegment_to_subspace (data_section,
5733                                          sd_chain->sd_last_subseg);
5734           demand_empty_rest_of_line ();
5735           return;
5736         }
5737       if (!strncasecmp (input_line_pointer,
5738                         GDB_DEBUG_SPACE_NAME,
5739                         strlen (GDB_DEBUG_SPACE_NAME)))
5740         {
5741           input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
5742           sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
5743           if (sd_chain == NULL)
5744             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
5745           else if (SPACE_USER_DEFINED (sd_chain) == 0)
5746             sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
5747
5748           current_space = sd_chain;
5749
5750           {
5751             asection *gdb_section
5752             = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
5753
5754             subseg_set (gdb_section, sd_chain->sd_last_subseg);
5755             current_subspace
5756               = pa_subsegment_to_subspace (gdb_section,
5757                                            sd_chain->sd_last_subseg);
5758           }
5759           demand_empty_rest_of_line ();
5760           return;
5761         }
5762
5763       /* It could be a space specified by number.  */
5764       print_errors = 0;
5765       save_s = input_line_pointer;
5766       if ((temp = pa_parse_number (&input_line_pointer, 0)) >= 0)
5767         {
5768           if ((sd_chain = pa_find_space_by_number (temp)))
5769             {
5770               current_space = sd_chain;
5771
5772               subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
5773               current_subspace
5774                 = pa_subsegment_to_subspace (sd_chain->sd_seg,
5775                                              sd_chain->sd_last_subseg);
5776               demand_empty_rest_of_line ();
5777               return;
5778             }
5779         }
5780
5781       /* Not a number, attempt to create a new space.  */
5782       print_errors = 1;
5783       input_line_pointer = save_s;
5784       name = input_line_pointer;
5785       c = get_symbol_end ();
5786       space_name = xmalloc (strlen (name) + 1);
5787       strcpy (space_name, name);
5788       *input_line_pointer = c;
5789
5790       sd_chain = pa_parse_space_stmt (space_name, 1);
5791       current_space = sd_chain;
5792
5793       subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
5794       current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
5795                                                   sd_chain->sd_last_subseg);
5796       demand_empty_rest_of_line ();
5797     }
5798 }
5799
5800 /* Switch to a new space.  (I think).  FIXME.  */
5801
5802 static void
5803 pa_spnum (unused)
5804      int unused;
5805 {
5806   char *name;
5807   char c;
5808   char *p;
5809   sd_chain_struct *space;
5810
5811   name = input_line_pointer;
5812   c = get_symbol_end ();
5813   space = is_defined_space (name);
5814   if (space)
5815     {
5816       p = frag_more (4);
5817       md_number_to_chars (p, SPACE_SPNUM (space), 4);
5818     }
5819   else
5820     as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
5821
5822   *input_line_pointer = c;
5823   demand_empty_rest_of_line ();
5824 }
5825
5826 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
5827    given subspace, creating the new subspace if necessary.
5828
5829    FIXME.  Should mirror pa_space more closely, in particular how
5830    they're broken up into subroutines.  */
5831
5832 static void
5833 pa_subspace (create_new)
5834      int create_new;
5835 {
5836   char *name, *ss_name, c;
5837   char loadable, code_only, common, dup_common, zero, sort;
5838   int i, access, space_index, alignment, quadrant, applicable, flags;
5839   sd_chain_struct *space;
5840   ssd_chain_struct *ssd;
5841   asection *section;
5842
5843   if (current_space == NULL)
5844     as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
5845
5846   if (within_procedure)
5847     {
5848       as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
5849       ignore_rest_of_line ();
5850     }
5851   else
5852     {
5853       name = input_line_pointer;
5854       c = get_symbol_end ();
5855       ss_name = xmalloc (strlen (name) + 1);
5856       strcpy (ss_name, name);
5857       *input_line_pointer = c;
5858
5859       /* Load default values.  */
5860       sort = 0;
5861       access = 0x7f;
5862       loadable = 1;
5863       common = 0;
5864       dup_common = 0;
5865       code_only = 0;
5866       zero = 0;
5867       space_index = ~0;
5868       alignment = 1;
5869       quadrant = 0;
5870
5871       space = current_space;
5872       if (create_new)
5873         ssd = NULL;
5874       else
5875         ssd = is_defined_subspace (ss_name);
5876       /* Allow user to override the builtin attributes of subspaces.  But
5877          only allow the attributes to be changed once!  */
5878       if (ssd && SUBSPACE_DEFINED (ssd))
5879         {
5880           subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
5881           current_subspace = ssd;
5882           if (!is_end_of_statement ())
5883             as_warn (_("Parameters of an existing subspace can\'t be modified"));
5884           demand_empty_rest_of_line ();
5885           return;
5886         }
5887       else
5888         {
5889           /* A new subspace.  Load default values if it matches one of
5890              the builtin subspaces.  */
5891           i = 0;
5892           while (pa_def_subspaces[i].name)
5893             {
5894               if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
5895                 {
5896                   loadable = pa_def_subspaces[i].loadable;
5897                   common = pa_def_subspaces[i].common;
5898                   dup_common = pa_def_subspaces[i].dup_common;
5899                   code_only = pa_def_subspaces[i].code_only;
5900                   zero = pa_def_subspaces[i].zero;
5901                   space_index = pa_def_subspaces[i].space_index;
5902                   alignment = pa_def_subspaces[i].alignment;
5903                   quadrant = pa_def_subspaces[i].quadrant;
5904                   access = pa_def_subspaces[i].access;
5905                   sort = pa_def_subspaces[i].sort;
5906                   break;
5907                 }
5908               i++;
5909             }
5910         }
5911
5912       /* We should be working with a new subspace now.  Fill in
5913          any information as specified by the user.  */
5914       if (!is_end_of_statement ())
5915         {
5916           input_line_pointer++;
5917           while (!is_end_of_statement ())
5918             {
5919               name = input_line_pointer;
5920               c = get_symbol_end ();
5921               if ((strncasecmp (name, "quad", 4) == 0))
5922                 {
5923                   *input_line_pointer = c;
5924                   input_line_pointer++;
5925                   quadrant = get_absolute_expression ();
5926                 }
5927               else if ((strncasecmp (name, "align", 5) == 0))
5928                 {
5929                   *input_line_pointer = c;
5930                   input_line_pointer++;
5931                   alignment = get_absolute_expression ();
5932                   if (log2 (alignment) == -1)
5933                     {
5934                       as_bad (_("Alignment must be a power of 2"));
5935                       alignment = 1;
5936                     }
5937                 }
5938               else if ((strncasecmp (name, "access", 6) == 0))
5939                 {
5940                   *input_line_pointer = c;
5941                   input_line_pointer++;
5942                   access = get_absolute_expression ();
5943                 }
5944               else if ((strncasecmp (name, "sort", 4) == 0))
5945                 {
5946                   *input_line_pointer = c;
5947                   input_line_pointer++;
5948                   sort = get_absolute_expression ();
5949                 }
5950               else if ((strncasecmp (name, "code_only", 9) == 0))
5951                 {
5952                   *input_line_pointer = c;
5953                   code_only = 1;
5954                 }
5955               else if ((strncasecmp (name, "unloadable", 10) == 0))
5956                 {
5957                   *input_line_pointer = c;
5958                   loadable = 0;
5959                 }
5960               else if ((strncasecmp (name, "common", 6) == 0))
5961                 {
5962                   *input_line_pointer = c;
5963                   common = 1;
5964                 }
5965               else if ((strncasecmp (name, "dup_comm", 8) == 0))
5966                 {
5967                   *input_line_pointer = c;
5968                   dup_common = 1;
5969                 }
5970               else if ((strncasecmp (name, "zero", 4) == 0))
5971                 {
5972                   *input_line_pointer = c;
5973                   zero = 1;
5974                 }
5975               else if ((strncasecmp (name, "first", 5) == 0))
5976                 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
5977               else
5978                 as_bad (_("Invalid .SUBSPACE argument"));
5979               if (!is_end_of_statement ())
5980                 input_line_pointer++;
5981             }
5982         }
5983
5984       /* Compute a reasonable set of BFD flags based on the information
5985          in the .subspace directive.  */
5986       applicable = bfd_applicable_section_flags (stdoutput);
5987       flags = 0;
5988       if (loadable)
5989         flags |= (SEC_ALLOC | SEC_LOAD);
5990       if (code_only)
5991         flags |= SEC_CODE;
5992       if (common || dup_common)
5993         flags |= SEC_IS_COMMON;
5994
5995       flags |= SEC_RELOC | SEC_HAS_CONTENTS;
5996
5997       /* This is a zero-filled subspace (eg BSS).  */
5998       if (zero)
5999         flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
6000
6001       applicable &= flags;
6002
6003       /* If this is an existing subspace, then we want to use the
6004          segment already associated with the subspace.
6005
6006          FIXME NOW!  ELF BFD doesn't appear to be ready to deal with
6007          lots of sections.  It might be a problem in the PA ELF
6008          code, I do not know yet.  For now avoid creating anything
6009          but the "standard" sections for ELF.  */
6010       if (create_new)
6011         section = subseg_force_new (ss_name, 0);
6012       else if (ssd)
6013         section = ssd->ssd_seg;
6014       else
6015         section = subseg_new (ss_name, 0);
6016
6017       if (zero)
6018         seg_info (section)->bss = 1;
6019
6020       /* Now set the flags.  */
6021       bfd_set_section_flags (stdoutput, section, applicable);
6022
6023       /* Record any alignment request for this section.  */
6024       record_alignment (section, log2 (alignment));
6025
6026       /* Set the starting offset for this section.  */
6027       bfd_set_section_vma (stdoutput, section,
6028                            pa_subspace_start (space, quadrant));
6029
6030       /* Now that all the flags are set, update an existing subspace,
6031          or create a new one.  */
6032       if (ssd)
6033
6034         current_subspace = update_subspace (space, ss_name, loadable,
6035                                             code_only, common, dup_common,
6036                                             sort, zero, access, space_index,
6037                                             alignment, quadrant,
6038                                             section);
6039       else
6040         current_subspace = create_new_subspace (space, ss_name, loadable,
6041                                                 code_only, common,
6042                                                 dup_common, zero, sort,
6043                                                 access, space_index,
6044                                               alignment, quadrant, section);
6045
6046       demand_empty_rest_of_line ();
6047       current_subspace->ssd_seg = section;
6048       subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
6049     }
6050   SUBSPACE_DEFINED (current_subspace) = 1;
6051 }
6052
6053
6054 /* Create default space and subspace dictionaries.  */
6055
6056 static void
6057 pa_spaces_begin ()
6058 {
6059   int i;
6060
6061   space_dict_root = NULL;
6062   space_dict_last = NULL;
6063
6064   i = 0;
6065   while (pa_def_spaces[i].name)
6066     {
6067       char *name;
6068
6069       /* Pick the right name to use for the new section.  */
6070       name = pa_def_spaces[i].name;
6071
6072       pa_def_spaces[i].segment = subseg_new (name, 0);
6073       create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
6074                         pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
6075                         pa_def_spaces[i].private, pa_def_spaces[i].sort,
6076                         pa_def_spaces[i].segment, 0);
6077       i++;
6078     }
6079
6080   i = 0;
6081   while (pa_def_subspaces[i].name)
6082     {
6083       char *name;
6084       int applicable, subsegment;
6085       asection *segment = NULL;
6086       sd_chain_struct *space;
6087
6088       /* Pick the right name for the new section and pick the right
6089          subsegment number.  */
6090       name = pa_def_subspaces[i].name;
6091       subsegment = 0;
6092
6093       /* Create the new section.  */
6094       segment = subseg_new (name, subsegment);
6095
6096
6097       /* For SOM we want to replace the standard .text, .data, and .bss
6098          sections with our own.   We also want to set BFD flags for
6099          all the built-in subspaces.  */
6100       if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
6101         {
6102           text_section = segment;
6103           applicable = bfd_applicable_section_flags (stdoutput);
6104           bfd_set_section_flags (stdoutput, segment,
6105                                  applicable & (SEC_ALLOC | SEC_LOAD
6106                                                | SEC_RELOC | SEC_CODE
6107                                                | SEC_READONLY
6108                                                | SEC_HAS_CONTENTS));
6109         }
6110       else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
6111         {
6112           data_section = segment;
6113           applicable = bfd_applicable_section_flags (stdoutput);
6114           bfd_set_section_flags (stdoutput, segment,
6115                                  applicable & (SEC_ALLOC | SEC_LOAD
6116                                                | SEC_RELOC
6117                                                | SEC_HAS_CONTENTS));
6118
6119
6120         }
6121       else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
6122         {
6123           bss_section = segment;
6124           applicable = bfd_applicable_section_flags (stdoutput);
6125           bfd_set_section_flags (stdoutput, segment,
6126                                  applicable & SEC_ALLOC);
6127         }
6128       else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
6129         {
6130           applicable = bfd_applicable_section_flags (stdoutput);
6131           bfd_set_section_flags (stdoutput, segment,
6132                                  applicable & (SEC_ALLOC | SEC_LOAD
6133                                                | SEC_RELOC
6134                                                | SEC_READONLY
6135                                                | SEC_HAS_CONTENTS));
6136         }
6137       else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
6138         {
6139           applicable = bfd_applicable_section_flags (stdoutput);
6140           bfd_set_section_flags (stdoutput, segment,
6141                                  applicable & (SEC_ALLOC | SEC_LOAD
6142                                                | SEC_RELOC
6143                                                | SEC_READONLY
6144                                                | SEC_HAS_CONTENTS));
6145         }
6146       else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
6147         {
6148           applicable = bfd_applicable_section_flags (stdoutput);
6149           bfd_set_section_flags (stdoutput, segment,
6150                                  applicable & (SEC_ALLOC | SEC_LOAD
6151                                                | SEC_RELOC
6152                                                | SEC_READONLY
6153                                                | SEC_HAS_CONTENTS));
6154         }
6155
6156       /* Find the space associated with this subspace.  */
6157       space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
6158                                                  def_space_index].segment);
6159       if (space == NULL)
6160         {
6161           as_fatal (_("Internal error: Unable to find containing space for %s."),
6162                     pa_def_subspaces[i].name);
6163         }
6164
6165       create_new_subspace (space, name,
6166                            pa_def_subspaces[i].loadable,
6167                            pa_def_subspaces[i].code_only,
6168                            pa_def_subspaces[i].common,
6169                            pa_def_subspaces[i].dup_common,
6170                            pa_def_subspaces[i].zero,
6171                            pa_def_subspaces[i].sort,
6172                            pa_def_subspaces[i].access,
6173                            pa_def_subspaces[i].space_index,
6174                            pa_def_subspaces[i].alignment,
6175                            pa_def_subspaces[i].quadrant,
6176                            segment);
6177       i++;
6178     }
6179 }
6180
6181
6182
6183 /* Create a new space NAME, with the appropriate flags as defined
6184    by the given parameters.  */
6185
6186 static sd_chain_struct *
6187 create_new_space (name, spnum, loadable, defined, private,
6188                   sort, seg, user_defined)
6189      char *name;
6190      int spnum;
6191      int loadable;
6192      int defined;
6193      int private;
6194      int sort;
6195      asection *seg;
6196      int user_defined;
6197 {
6198   sd_chain_struct *chain_entry;
6199
6200   chain_entry = (sd_chain_struct *) xmalloc (sizeof (sd_chain_struct));
6201   if (!chain_entry)
6202     as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
6203               name);
6204
6205   SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
6206   strcpy (SPACE_NAME (chain_entry), name);
6207   SPACE_DEFINED (chain_entry) = defined;
6208   SPACE_USER_DEFINED (chain_entry) = user_defined;
6209   SPACE_SPNUM (chain_entry) = spnum;
6210
6211   chain_entry->sd_seg = seg;
6212   chain_entry->sd_last_subseg = -1;
6213   chain_entry->sd_subspaces = NULL;
6214   chain_entry->sd_next = NULL;
6215
6216   /* Find spot for the new space based on its sort key.  */
6217   if (!space_dict_last)
6218     space_dict_last = chain_entry;
6219
6220   if (space_dict_root == NULL)
6221     space_dict_root = chain_entry;
6222   else
6223     {
6224       sd_chain_struct *chain_pointer;
6225       sd_chain_struct *prev_chain_pointer;
6226
6227       chain_pointer = space_dict_root;
6228       prev_chain_pointer = NULL;
6229
6230       while (chain_pointer)
6231         {
6232           prev_chain_pointer = chain_pointer;
6233           chain_pointer = chain_pointer->sd_next;
6234         }
6235
6236       /* At this point we've found the correct place to add the new
6237          entry.  So add it and update the linked lists as appropriate.  */
6238       if (prev_chain_pointer)
6239         {
6240           chain_entry->sd_next = chain_pointer;
6241           prev_chain_pointer->sd_next = chain_entry;
6242         }
6243       else
6244         {
6245           space_dict_root = chain_entry;
6246           chain_entry->sd_next = chain_pointer;
6247         }
6248
6249       if (chain_entry->sd_next == NULL)
6250         space_dict_last = chain_entry;
6251     }
6252
6253   /* This is here to catch predefined spaces which do not get
6254      modified by the user's input.  Another call is found at
6255      the bottom of pa_parse_space_stmt to handle cases where
6256      the user modifies a predefined space.  */
6257 #ifdef obj_set_section_attributes
6258   obj_set_section_attributes (seg, defined, private, sort, spnum);
6259 #endif
6260
6261   return chain_entry;
6262 }
6263
6264 /* Create a new subspace NAME, with the appropriate flags as defined
6265    by the given parameters.
6266
6267    Add the new subspace to the subspace dictionary chain in numerical
6268    order as defined by the SORT entries.  */
6269
6270 static ssd_chain_struct *
6271 create_new_subspace (space, name, loadable, code_only, common,
6272                      dup_common, is_zero, sort, access, space_index,
6273                      alignment, quadrant, seg)
6274      sd_chain_struct *space;
6275      char *name;
6276      int loadable, code_only, common, dup_common, is_zero;
6277      int sort;
6278      int access;
6279      int space_index;
6280      int alignment;
6281      int quadrant;
6282      asection *seg;
6283 {
6284   ssd_chain_struct *chain_entry;
6285
6286   chain_entry = (ssd_chain_struct *) xmalloc (sizeof (ssd_chain_struct));
6287   if (!chain_entry)
6288     as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
6289
6290   SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
6291   strcpy (SUBSPACE_NAME (chain_entry), name);
6292
6293   /* Initialize subspace_defined.  When we hit a .subspace directive
6294      we'll set it to 1 which "locks-in" the subspace attributes.  */
6295   SUBSPACE_DEFINED (chain_entry) = 0;
6296
6297   chain_entry->ssd_subseg = 0;
6298   chain_entry->ssd_seg = seg;
6299   chain_entry->ssd_next = NULL;
6300
6301   /* Find spot for the new subspace based on its sort key.  */
6302   if (space->sd_subspaces == NULL)
6303     space->sd_subspaces = chain_entry;
6304   else
6305     {
6306       ssd_chain_struct *chain_pointer;
6307       ssd_chain_struct *prev_chain_pointer;
6308
6309       chain_pointer = space->sd_subspaces;
6310       prev_chain_pointer = NULL;
6311
6312       while (chain_pointer)
6313         {
6314           prev_chain_pointer = chain_pointer;
6315           chain_pointer = chain_pointer->ssd_next;
6316         }
6317
6318       /* Now we have somewhere to put the new entry.  Insert it and update
6319          the links.  */
6320       if (prev_chain_pointer)
6321         {
6322           chain_entry->ssd_next = chain_pointer;
6323           prev_chain_pointer->ssd_next = chain_entry;
6324         }
6325       else
6326         {
6327           space->sd_subspaces = chain_entry;
6328           chain_entry->ssd_next = chain_pointer;
6329         }
6330     }
6331
6332 #ifdef obj_set_subsection_attributes
6333   obj_set_subsection_attributes (seg, space->sd_seg, access,
6334                                  sort, quadrant);
6335 #endif
6336
6337   return chain_entry;
6338 }
6339
6340 /* Update the information for the given subspace based upon the
6341    various arguments.   Return the modified subspace chain entry.  */
6342
6343 static ssd_chain_struct *
6344 update_subspace (space, name, loadable, code_only, common, dup_common, sort,
6345                  zero, access, space_index, alignment, quadrant, section)
6346      sd_chain_struct *space;
6347      char *name;
6348      int loadable;
6349      int code_only;
6350      int common;
6351      int dup_common;
6352      int zero;
6353      int sort;
6354      int access;
6355      int space_index;
6356      int alignment;
6357      int quadrant;
6358      asection *section;
6359 {
6360   ssd_chain_struct *chain_entry;
6361
6362   chain_entry = is_defined_subspace (name);
6363
6364 #ifdef obj_set_subsection_attributes
6365   obj_set_subsection_attributes (section, space->sd_seg, access,
6366                                  sort, quadrant);
6367 #endif
6368
6369   return chain_entry;
6370 }
6371
6372 /* Return the space chain entry for the space with the name NAME or
6373    NULL if no such space exists.  */
6374
6375 static sd_chain_struct *
6376 is_defined_space (name)
6377      char *name;
6378 {
6379   sd_chain_struct *chain_pointer;
6380
6381   for (chain_pointer = space_dict_root;
6382        chain_pointer;
6383        chain_pointer = chain_pointer->sd_next)
6384     {
6385       if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
6386         return chain_pointer;
6387     }
6388
6389   /* No mapping from segment to space was found.  Return NULL.  */
6390   return NULL;
6391 }
6392
6393 /* Find and return the space associated with the given seg.  If no mapping
6394    from the given seg to a space is found, then return NULL.
6395
6396    Unlike subspaces, the number of spaces is not expected to grow much,
6397    so a linear exhaustive search is OK here.  */
6398
6399 static sd_chain_struct *
6400 pa_segment_to_space (seg)
6401      asection *seg;
6402 {
6403   sd_chain_struct *space_chain;
6404
6405   /* Walk through each space looking for the correct mapping.  */
6406   for (space_chain = space_dict_root;
6407        space_chain;
6408        space_chain = space_chain->sd_next)
6409     {
6410       if (space_chain->sd_seg == seg)
6411         return space_chain;
6412     }
6413
6414   /* Mapping was not found.  Return NULL.  */
6415   return NULL;
6416 }
6417
6418 /* Return the space chain entry for the subspace with the name NAME or
6419    NULL if no such subspace exists.
6420
6421    Uses a linear search through all the spaces and subspaces, this may
6422    not be appropriate if we ever being placing each function in its
6423    own subspace.  */
6424
6425 static ssd_chain_struct *
6426 is_defined_subspace (name)
6427      char *name;
6428 {
6429   sd_chain_struct *space_chain;
6430   ssd_chain_struct *subspace_chain;
6431
6432   /* Walk through each space.  */
6433   for (space_chain = space_dict_root;
6434        space_chain;
6435        space_chain = space_chain->sd_next)
6436     {
6437       /* Walk through each subspace looking for a name which matches.  */
6438       for (subspace_chain = space_chain->sd_subspaces;
6439            subspace_chain;
6440            subspace_chain = subspace_chain->ssd_next)
6441         if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
6442           return subspace_chain;
6443     }
6444
6445   /* Subspace wasn't found.  Return NULL.  */
6446   return NULL;
6447 }
6448
6449 /* Find and return the subspace associated with the given seg.  If no
6450    mapping from the given seg to a subspace is found, then return NULL.
6451
6452    If we ever put each procedure/function within its own subspace
6453    (to make life easier on the compiler and linker), then this will have
6454    to become more efficient.  */
6455
6456 static ssd_chain_struct *
6457 pa_subsegment_to_subspace (seg, subseg)
6458      asection *seg;
6459      subsegT subseg;
6460 {
6461   sd_chain_struct *space_chain;
6462   ssd_chain_struct *subspace_chain;
6463
6464   /* Walk through each space.  */
6465   for (space_chain = space_dict_root;
6466        space_chain;
6467        space_chain = space_chain->sd_next)
6468     {
6469       if (space_chain->sd_seg == seg)
6470         {
6471           /* Walk through each subspace within each space looking for
6472              the correct mapping.  */
6473           for (subspace_chain = space_chain->sd_subspaces;
6474                subspace_chain;
6475                subspace_chain = subspace_chain->ssd_next)
6476             if (subspace_chain->ssd_subseg == (int) subseg)
6477               return subspace_chain;
6478         }
6479     }
6480
6481   /* No mapping from subsegment to subspace found.  Return NULL.  */
6482   return NULL;
6483 }
6484
6485 /* Given a number, try and find a space with the name number.
6486
6487    Return a pointer to a space dictionary chain entry for the space
6488    that was found or NULL on failure.  */
6489
6490 static sd_chain_struct *
6491 pa_find_space_by_number (number)
6492      int number;
6493 {
6494   sd_chain_struct *space_chain;
6495
6496   for (space_chain = space_dict_root;
6497        space_chain;
6498        space_chain = space_chain->sd_next)
6499     {
6500       if (SPACE_SPNUM (space_chain) == (unsigned int) number)
6501         return space_chain;
6502     }
6503
6504   /* No appropriate space found.  Return NULL.  */
6505   return NULL;
6506 }
6507
6508 /* Return the starting address for the given subspace.  If the starting
6509    address is unknown then return zero.  */
6510
6511 static unsigned int
6512 pa_subspace_start (space, quadrant)
6513      sd_chain_struct *space;
6514      int quadrant;
6515 {
6516   /* FIXME.  Assumes everyone puts read/write data at 0x4000000, this
6517      is not correct for the PA OSF1 port.  */
6518   if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
6519     return 0x40000000;
6520   else if (space->sd_seg == data_section && quadrant == 1)
6521     return 0x40000000;
6522   else
6523     return 0;
6524   return 0;
6525 }
6526
6527 /* FIXME.  Needs documentation.  */
6528 static int
6529 pa_next_subseg (space)
6530      sd_chain_struct *space;
6531 {
6532
6533   space->sd_last_subseg++;
6534   return space->sd_last_subseg;
6535 }
6536 #endif
6537
6538 /* Helper function for pa_stringer.  Used to find the end of
6539    a string.  */
6540
6541 static unsigned int
6542 pa_stringer_aux (s)
6543      char *s;
6544 {
6545   unsigned int c = *s & CHAR_MASK;
6546
6547 #ifdef OBJ_SOM
6548   /* We must have a valid space and subspace.  */
6549   pa_check_current_space_and_subspace ();
6550 #endif
6551
6552   switch (c)
6553     {
6554     case '\"':
6555       c = NOT_A_CHAR;
6556       break;
6557     default:
6558       break;
6559     }
6560   return c;
6561 }
6562
6563 /* Handle a .STRING type pseudo-op.  */
6564
6565 static void
6566 pa_stringer (append_zero)
6567      int append_zero;
6568 {
6569   char *s, num_buf[4];
6570   unsigned int c;
6571   int i;
6572
6573   /* Preprocess the string to handle PA-specific escape sequences.
6574      For example, \xDD where DD is a hexidecimal number should be
6575      changed to \OOO where OOO is an octal number.  */
6576
6577   /* Skip the opening quote.  */
6578   s = input_line_pointer + 1;
6579
6580   while (is_a_char (c = pa_stringer_aux (s++)))
6581     {
6582       if (c == '\\')
6583         {
6584           c = *s;
6585           switch (c)
6586             {
6587               /* Handle \x<num>.  */
6588             case 'x':
6589               {
6590                 unsigned int number;
6591                 int num_digit;
6592                 char dg;
6593                 char *s_start = s;
6594
6595                 /* Get pas the 'x'.  */
6596                 s++;
6597                 for (num_digit = 0, number = 0, dg = *s;
6598                      num_digit < 2
6599                      && (isdigit (dg) || (dg >= 'a' && dg <= 'f')
6600                          || (dg >= 'A' && dg <= 'F'));
6601                      num_digit++)
6602                   {
6603                     if (isdigit (dg))
6604                       number = number * 16 + dg - '0';
6605                     else if (dg >= 'a' && dg <= 'f')
6606                       number = number * 16 + dg - 'a' + 10;
6607                     else
6608                       number = number * 16 + dg - 'A' + 10;
6609
6610                     s++;
6611                     dg = *s;
6612                   }
6613                 if (num_digit > 0)
6614                   {
6615                     switch (num_digit)
6616                       {
6617                       case 1:
6618                         sprintf (num_buf, "%02o", number);
6619                         break;
6620                       case 2:
6621                         sprintf (num_buf, "%03o", number);
6622                         break;
6623                       }
6624                     for (i = 0; i <= num_digit; i++)
6625                       s_start[i] = num_buf[i];
6626                   }
6627                 break;
6628               }
6629             /* This might be a "\"", skip over the escaped char.  */
6630             default:
6631               s++;
6632               break;
6633             }
6634         }
6635     }
6636   stringer (append_zero);
6637   pa_undefine_label ();
6638 }
6639
6640 /* Handle a .VERSION pseudo-op.  */
6641
6642 static void
6643 pa_version (unused)
6644      int unused;
6645 {
6646   obj_version (0);
6647   pa_undefine_label ();
6648 }
6649
6650 #ifdef OBJ_SOM
6651
6652 /* Handle a .COMPILER pseudo-op.  */
6653
6654 static void
6655 pa_compiler (unused)
6656      int unused;
6657 {
6658   obj_som_compiler (0);
6659   pa_undefine_label ();
6660 }
6661
6662 #endif
6663
6664 /* Handle a .COPYRIGHT pseudo-op.  */
6665
6666 static void
6667 pa_copyright (unused)
6668      int unused;
6669 {
6670   obj_copyright (0);
6671   pa_undefine_label ();
6672 }
6673
6674 /* Just like a normal cons, but when finished we have to undefine
6675    the latest space label.  */
6676
6677 static void
6678 pa_cons (nbytes)
6679      int nbytes;
6680 {
6681   cons (nbytes);
6682   pa_undefine_label ();
6683 }
6684
6685 /* Switch to the data space.  As usual delete our label.  */
6686
6687 static void
6688 pa_data (unused)
6689      int unused;
6690 {
6691 #ifdef OBJ_SOM
6692   current_space = is_defined_space ("$PRIVATE$");
6693   current_subspace
6694     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6695 #endif
6696   s_data (0);
6697   pa_undefine_label ();
6698 }
6699
6700 /* Like float_cons, but we need to undefine our label.  */
6701
6702 static void
6703 pa_float_cons (float_type)
6704      int float_type;
6705 {
6706   float_cons (float_type);
6707   pa_undefine_label ();
6708 }
6709
6710 /* Like s_fill, but delete our label when finished.  */
6711
6712 static void
6713 pa_fill (unused)
6714      int unused;
6715 {
6716 #ifdef OBJ_SOM
6717   /* We must have a valid space and subspace.  */
6718   pa_check_current_space_and_subspace ();
6719 #endif
6720
6721   s_fill (0);
6722   pa_undefine_label ();
6723 }
6724
6725 /* Like lcomm, but delete our label when finished.  */
6726
6727 static void
6728 pa_lcomm (needs_align)
6729      int needs_align;
6730 {
6731 #ifdef OBJ_SOM
6732   /* We must have a valid space and subspace.  */
6733   pa_check_current_space_and_subspace ();
6734 #endif
6735
6736   s_lcomm (needs_align);
6737   pa_undefine_label ();
6738 }
6739
6740 /* Like lsym, but delete our label when finished.  */
6741
6742 static void
6743 pa_lsym (unused)
6744      int unused;
6745 {
6746 #ifdef OBJ_SOM
6747   /* We must have a valid space and subspace.  */
6748   pa_check_current_space_and_subspace ();
6749 #endif
6750
6751   s_lsym (0);
6752   pa_undefine_label ();
6753 }
6754
6755 /* Switch to the text space.  Like s_text, but delete our
6756    label when finished.  */
6757 static void
6758 pa_text (unused)
6759      int unused;
6760 {
6761 #ifdef OBJ_SOM
6762   current_space = is_defined_space ("$TEXT$");
6763   current_subspace
6764     = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6765 #endif
6766
6767   s_text (0);
6768   pa_undefine_label ();
6769 }
6770
6771 /* On the PA relocations which involve function symbols must not be
6772    adjusted.  This so that the linker can know when/how to create argument
6773    relocation stubs for indirect calls and calls to static functions.
6774
6775    "T" field selectors create DLT relative fixups for accessing
6776    globals and statics in PIC code; each DLT relative fixup creates
6777    an entry in the DLT table.  The entries contain the address of
6778    the final target (eg accessing "foo" would create a DLT entry
6779    with the address of "foo").
6780
6781    Unfortunately, the HP linker doesn't take into account any addend
6782    when generating the DLT; so accessing $LIT$+8 puts the address of
6783    $LIT$ into the DLT rather than the address of $LIT$+8.
6784
6785    The end result is we can't perform relocation symbol reductions for
6786    any fixup which creates entries in the DLT (eg they use "T" field
6787    selectors).
6788
6789    Reject reductions involving symbols with external scope; such
6790    reductions make life a living hell for object file editors.
6791
6792    FIXME.  Also reject R_HPPA relocations which are 32bits wide in
6793    the code space.  The SOM BFD backend doesn't know how to pull the
6794    right bits out of an instruction.  */
6795
6796 int
6797 hppa_fix_adjustable (fixp)
6798      fixS *fixp;
6799 {
6800   struct hppa_fix_struct *hppa_fix;
6801
6802   hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
6803
6804 #ifdef OBJ_SOM
6805   /* Reject reductions of symbols in 32bit relocs.  */
6806   if (fixp->fx_r_type == R_HPPA && hppa_fix->fx_r_format == 32)
6807     return 0;
6808
6809   /* Reject reductions of symbols in sym1-sym2 expressions when
6810      the fixup will occur in a CODE subspace.
6811
6812      XXX FIXME: Long term we probably want to reject all of these;
6813      for example reducing in the debug section would lose if we ever
6814      supported using the optimizing hp linker.  */
6815   if (fixp->fx_addsy
6816       && fixp->fx_subsy
6817       && (hppa_fix->segment->flags & SEC_CODE))
6818     {
6819       /* Apparently sy_used_in_reloc never gets set for sub symbols.  */
6820       symbol_mark_used_in_reloc (fixp->fx_subsy);
6821       return 0;
6822     }
6823
6824   /* We can't adjust any relocs that use LR% and RR% field selectors.
6825      That confuses the HP linker.  */
6826   if (hppa_fix->fx_r_field == e_lrsel
6827       || hppa_fix->fx_r_field == e_rrsel
6828       || hppa_fix->fx_r_field == e_nlrsel)
6829     return 0;
6830 #endif
6831
6832   /* Reject reductions of symbols in DLT relative relocs,
6833      relocations with plabels.  */
6834   if (hppa_fix->fx_r_field == e_tsel
6835       || hppa_fix->fx_r_field == e_ltsel
6836       || hppa_fix->fx_r_field == e_rtsel
6837       || hppa_fix->fx_r_field == e_psel
6838       || hppa_fix->fx_r_field == e_rpsel
6839       || hppa_fix->fx_r_field == e_lpsel)
6840     return 0;
6841
6842   if (fixp->fx_addsy && S_IS_EXTERNAL (fixp->fx_addsy))
6843     return 0;
6844
6845   /* Reject absolute calls (jumps).  */
6846   if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
6847     return 0;
6848
6849   /* Reject reductions of function symbols.  */
6850   if (fixp->fx_addsy == 0 || ! S_IS_FUNCTION (fixp->fx_addsy))
6851     return 1;
6852
6853   return 0;
6854 }
6855
6856 /* Return nonzero if the fixup in FIXP will require a relocation,
6857    even it if appears that the fixup could be completely handled
6858    within GAS.  */
6859
6860 int
6861 hppa_force_relocation (fixp)
6862      fixS *fixp;
6863 {
6864   struct hppa_fix_struct *hppa_fixp;
6865   int distance;
6866
6867   hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
6868 #ifdef OBJ_SOM
6869   if (fixp->fx_r_type == R_HPPA_ENTRY || fixp->fx_r_type == R_HPPA_EXIT
6870       || fixp->fx_r_type == R_HPPA_BEGIN_BRTAB
6871       || fixp->fx_r_type == R_HPPA_END_BRTAB
6872       || fixp->fx_r_type == R_HPPA_BEGIN_TRY
6873       || fixp->fx_r_type == R_HPPA_END_TRY
6874       || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
6875           && (hppa_fixp->segment->flags & SEC_CODE) != 0))
6876     return 1;
6877 #endif
6878
6879 #define arg_reloc_stub_needed(CALLER, CALLEE) \
6880   ((CALLEE) && (CALLER) && ((CALLEE) != (CALLER)))
6881
6882 #ifdef OBJ_SOM
6883   /* It is necessary to force PC-relative calls/jumps to have a relocation
6884      entry if they're going to need either a argument relocation or long
6885      call stub.  FIXME.  Can't we need the same for absolute calls?  */
6886   if (fixp->fx_pcrel && fixp->fx_addsy
6887       && (arg_reloc_stub_needed ((long) ((obj_symbol_type *)
6888         symbol_get_bfdsym (fixp->fx_addsy))->tc_data.ap.hppa_arg_reloc,
6889         hppa_fixp->fx_arg_reloc)))
6890     return 1;
6891 #endif
6892   distance = (fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy)
6893               - md_pcrel_from (fixp));
6894   /* Now check and see if we're going to need a long-branch stub.  */
6895   if (fixp->fx_r_type == R_HPPA_PCREL_CALL
6896       && (distance > 262143 || distance < -262144))
6897     return 1;
6898
6899   if (fixp->fx_r_type == R_HPPA_ABS_CALL)
6900     return 1;
6901 #undef arg_reloc_stub_needed
6902
6903   /* No need (yet) to force another relocations to be emitted.  */
6904   return 0;
6905 }
6906
6907 /* Now for some ELF specific code.  FIXME.  */
6908 #ifdef OBJ_ELF
6909 /* Mark the end of a function so that it's possible to compute
6910    the size of the function in hppa_elf_final_processing.  */
6911
6912 static void
6913 hppa_elf_mark_end_of_function ()
6914 {
6915   /* ELF does not have EXIT relocations.  All we do is create a
6916      temporary symbol marking the end of the function.  */
6917   char *name = (char *)
6918     xmalloc (strlen ("L$\001end_") +
6919              strlen (S_GET_NAME (last_call_info->start_symbol)) + 1);
6920
6921   if (name)
6922     {
6923       symbolS *symbolP;
6924
6925       strcpy (name, "L$\001end_");
6926       strcat (name, S_GET_NAME (last_call_info->start_symbol));
6927
6928       /* If we have a .exit followed by a .procend, then the
6929          symbol will have already been defined.  */
6930       symbolP = symbol_find (name);
6931       if (symbolP)
6932         {
6933           /* The symbol has already been defined!  This can
6934              happen if we have a .exit followed by a .procend.
6935
6936              This is *not* an error.  All we want to do is free
6937              the memory we just allocated for the name and continue.  */
6938           xfree (name);
6939         }
6940       else
6941         {
6942           /* symbol value should be the offset of the
6943              last instruction of the function */
6944           symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
6945                                 frag_now);
6946
6947           assert (symbolP);
6948           S_CLEAR_EXTERNAL (symbolP);
6949           symbol_table_insert (symbolP);
6950         }
6951
6952       if (symbolP)
6953         last_call_info->end_symbol = symbolP;
6954       else
6955         as_bad (_("Symbol '%s' could not be created."), name);
6956
6957     }
6958   else
6959     as_bad (_("No memory for symbol name."));
6960
6961 }
6962
6963 /* For ELF, this function serves one purpose:  to setup the st_size
6964    field of STT_FUNC symbols.  To do this, we need to scan the
6965    call_info structure list, determining st_size in by taking the
6966    difference in the address of the beginning/end marker symbols.  */
6967
6968 void
6969 elf_hppa_final_processing ()
6970 {
6971   struct call_info *call_info_pointer;
6972
6973   for (call_info_pointer = call_info_root;
6974        call_info_pointer;
6975        call_info_pointer = call_info_pointer->ci_next)
6976     {
6977       elf_symbol_type *esym
6978         = ((elf_symbol_type *)
6979            symbol_get_bfdsym (call_info_pointer->start_symbol));
6980       esym->internal_elf_sym.st_size =
6981         S_GET_VALUE (call_info_pointer->end_symbol)
6982         - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
6983     }
6984 }
6985 #endif