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