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