gas/config/tc-hppa.c

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