gas/config/tc-hppa.c

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