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