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