1 /* tc-hppa.c -- Assemble for the PA
2 Copyright (C) 1989-2018 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* HP PA-RISC support was contributed by the Center for Software Science
22 at the University of Utah. */
25 #include "safe-ctype.h"
26 #include "struc-symbol.h"
28 #include "dw2gencfi.h"
30 #include "bfd/libhppa.h"
32 /* Be careful, this file includes data *declarations*. */
33 #include "opcode/hppa.h"
35 #if defined (OBJ_ELF) && defined (OBJ_SOM)
36 error only one of OBJ_ELF and OBJ_SOM can be defined
39 /* If we are using ELF, then we probably can support dwarf2 debug
40 records. Furthermore, if we are supporting dwarf2 debug records,
41 then we want to use the assembler support for compact line numbers. */
43 #include "dwarf2dbg.h"
45 /* A "convenient" place to put object file dependencies which do
46 not need to be seen outside of tc-hppa.c. */
48 /* Object file formats specify relocation types. */
49 typedef enum elf_hppa_reloc_type reloc_type;
51 /* Object file formats specify BFD symbol types. */
52 typedef elf_symbol_type obj_symbol_type;
53 #define symbol_arg_reloc_info(sym)\
54 (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.hppa_arg_reloc)
56 #if TARGET_ARCH_SIZE == 64
57 /* How to generate a relocation. */
58 #define hppa_gen_reloc_type _bfd_elf64_hppa_gen_reloc_type
59 #define elf_hppa_reloc_final_type elf64_hppa_reloc_final_type
61 #define hppa_gen_reloc_type _bfd_elf32_hppa_gen_reloc_type
62 #define elf_hppa_reloc_final_type elf32_hppa_reloc_final_type
65 /* ELF objects can have versions, but apparently do not have anywhere
66 to store a copyright string. */
67 #define obj_version obj_elf_version
68 #define obj_copyright obj_elf_version
70 #define UNWIND_SECTION_NAME ".PARISC.unwind"
74 /* Names of various debugging spaces/subspaces. */
75 #define GDB_DEBUG_SPACE_NAME "$GDB_DEBUG$"
76 #define GDB_STRINGS_SUBSPACE_NAME "$GDB_STRINGS$"
77 #define GDB_SYMBOLS_SUBSPACE_NAME "$GDB_SYMBOLS$"
78 #define UNWIND_SECTION_NAME "$UNWIND$"
80 /* Object file formats specify relocation types. */
81 typedef int reloc_type;
83 /* SOM objects can have both a version string and a copyright string. */
84 #define obj_version obj_som_version
85 #define obj_copyright obj_som_copyright
87 /* How to generate a relocation. */
88 #define hppa_gen_reloc_type hppa_som_gen_reloc_type
90 /* Object file formats specify BFD symbol types. */
91 typedef som_symbol_type obj_symbol_type;
92 #define symbol_arg_reloc_info(sym)\
93 (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.ap.hppa_arg_reloc)
95 /* This apparently isn't in older versions of hpux reloc.h. */
97 #define R_DLT_REL 0x78
109 #if TARGET_ARCH_SIZE == 64
110 #define DEFAULT_LEVEL 25
112 #define DEFAULT_LEVEL 10
115 /* Various structures and types used internally in tc-hppa.c. */
117 /* Unwind table and descriptor. FIXME: Sync this with GDB version. */
121 unsigned int cannot_unwind:1;
122 unsigned int millicode:1;
123 unsigned int millicode_save_rest:1;
124 unsigned int region_desc:2;
125 unsigned int save_sr:2;
126 unsigned int entry_fr:4;
127 unsigned int entry_gr:5;
128 unsigned int args_stored:1;
129 unsigned int call_fr:5;
130 unsigned int call_gr:5;
131 unsigned int save_sp:1;
132 unsigned int save_rp:1;
133 unsigned int save_rp_in_frame:1;
134 unsigned int extn_ptr_defined:1;
135 unsigned int cleanup_defined:1;
137 unsigned int hpe_interrupt_marker:1;
138 unsigned int hpux_interrupt_marker:1;
139 unsigned int reserved:3;
140 unsigned int frame_size:27;
143 /* We can't rely on compilers placing bitfields in any particular
144 place, so use these macros when dumping unwind descriptors to
146 #define UNWIND_LOW32(U) \
147 (((U)->cannot_unwind << 31) \
148 | ((U)->millicode << 30) \
149 | ((U)->millicode_save_rest << 29) \
150 | ((U)->region_desc << 27) \
151 | ((U)->save_sr << 25) \
152 | ((U)->entry_fr << 21) \
153 | ((U)->entry_gr << 16) \
154 | ((U)->args_stored << 15) \
155 | ((U)->call_fr << 10) \
156 | ((U)->call_gr << 5) \
157 | ((U)->save_sp << 4) \
158 | ((U)->save_rp << 3) \
159 | ((U)->save_rp_in_frame << 2) \
160 | ((U)->extn_ptr_defined << 1) \
161 | ((U)->cleanup_defined << 0))
163 #define UNWIND_HIGH32(U) \
164 (((U)->hpe_interrupt_marker << 31) \
165 | ((U)->hpux_interrupt_marker << 30) \
166 | ((U)->frame_size << 0))
170 /* Starting and ending offsets of the region described by
172 unsigned int start_offset;
173 unsigned int end_offset;
174 struct unwind_desc descriptor;
177 /* This structure is used by the .callinfo, .enter, .leave pseudo-ops to
178 control the entry and exit code they generate. It is also used in
179 creation of the correct stack unwind descriptors.
181 NOTE: GAS does not support .enter and .leave for the generation of
182 prologues and epilogues. FIXME.
184 The fields in structure roughly correspond to the arguments available on the
185 .callinfo pseudo-op. */
189 /* The unwind descriptor being built. */
190 struct unwind_table ci_unwind;
192 /* Name of this function. */
193 symbolS *start_symbol;
195 /* (temporary) symbol used to mark the end of this function. */
198 /* Next entry in the chain. */
199 struct call_info *ci_next;
202 /* Operand formats for FP instructions. Note not all FP instructions
203 allow all four formats to be used (for example fmpysub only allows
207 SGL, DBL, ILLEGAL_FMT, QUAD, W, UW, DW, UDW, QW, UQW
211 /* This fully describes the symbol types which may be attached to
212 an EXPORT or IMPORT directive. Only SOM uses this formation
213 (ELF has no need for it). */
217 SYMBOL_TYPE_ABSOLUTE,
221 SYMBOL_TYPE_MILLICODE,
223 SYMBOL_TYPE_PRI_PROG,
224 SYMBOL_TYPE_SEC_PROG,
228 /* This structure contains information needed to assemble
229 individual instructions. */
232 /* Holds the opcode after parsing by pa_ip. */
233 unsigned long opcode;
235 /* Holds an expression associated with the current instruction. */
238 /* Does this instruction use PC-relative addressing. */
241 /* Floating point formats for operand1 and operand2. */
242 fp_operand_format fpof1;
243 fp_operand_format fpof2;
245 /* Whether or not we saw a truncation request on an fcnv insn. */
248 /* Holds the field selector for this instruction
249 (for example L%, LR%, etc). */
252 /* Holds any argument relocation bits associated with this
253 instruction. (instruction should be some sort of call). */
254 unsigned int arg_reloc;
256 /* The format specification for this instruction. */
259 /* The relocation (if any) associated with this instruction. */
263 /* PA-89 floating point registers are arranged like this:
265 +--------------+--------------+
266 | 0 or 16L | 16 or 16R |
267 +--------------+--------------+
268 | 1 or 17L | 17 or 17R |
269 +--------------+--------------+
277 +--------------+--------------+
278 | 14 or 30L | 30 or 30R |
279 +--------------+--------------+
280 | 15 or 31L | 31 or 31R |
281 +--------------+--------------+ */
283 /* Additional information needed to build argument relocation stubs. */
286 /* The argument relocation specification. */
287 unsigned int arg_reloc;
289 /* Number of arguments. */
290 unsigned int arg_count;
294 /* This structure defines an entry in the subspace dictionary
297 struct subspace_dictionary_chain
299 /* Nonzero if this space has been defined by the user code. */
300 unsigned int ssd_defined;
302 /* Name of this subspace. */
305 /* GAS segment and subsegment associated with this subspace. */
309 /* Next space in the subspace dictionary chain. */
310 struct subspace_dictionary_chain *ssd_next;
313 typedef struct subspace_dictionary_chain ssd_chain_struct;
315 /* This structure defines an entry in the subspace dictionary
318 struct space_dictionary_chain
320 /* Nonzero if this space has been defined by the user code or
321 as a default space. */
322 unsigned int sd_defined;
324 /* Nonzero if this spaces has been defined by the user code. */
325 unsigned int sd_user_defined;
327 /* The space number (or index). */
328 unsigned int sd_spnum;
330 /* The name of this subspace. */
333 /* GAS segment to which this subspace corresponds. */
336 /* Current subsegment number being used. */
339 /* The chain of subspaces contained within this space. */
340 ssd_chain_struct *sd_subspaces;
342 /* The next entry in the space dictionary chain. */
343 struct space_dictionary_chain *sd_next;
346 typedef struct space_dictionary_chain sd_chain_struct;
348 /* This structure defines attributes of the default subspace
349 dictionary entries. */
351 struct default_subspace_dict
353 /* Name of the subspace. */
356 /* FIXME. Is this still needed? */
359 /* Nonzero if this subspace is loadable. */
362 /* Nonzero if this subspace contains only code. */
365 /* Nonzero if this is a comdat subspace. */
368 /* Nonzero if this is a common subspace. */
371 /* Nonzero if this is a common subspace which allows symbols
372 to be multiply defined. */
375 /* Nonzero if this subspace should be zero filled. */
378 /* Sort key for this subspace. */
381 /* Access control bits for this subspace. Can represent RWX access
382 as well as privilege level changes for gateways. */
385 /* Index of containing space. */
388 /* Alignment (in bytes) of this subspace. */
391 /* Quadrant within space where this subspace should be loaded. */
394 /* An index into the default spaces array. */
397 /* Subsegment associated with this subspace. */
401 /* This structure defines attributes of the default space
402 dictionary entries. */
404 struct default_space_dict
406 /* Name of the space. */
409 /* Space number. It is possible to identify spaces within
410 assembly code numerically! */
413 /* Nonzero if this space is loadable. */
416 /* Nonzero if this space is "defined". FIXME is still needed */
419 /* Nonzero if this space can not be shared. */
422 /* Sort key for this space. */
425 /* Segment associated with this space. */
430 /* Structure for previous label tracking. Needed so that alignments,
431 callinfo declarations, etc can be easily attached to a particular
433 typedef struct label_symbol_struct
435 struct symbol *lss_label;
437 sd_chain_struct *lss_space;
442 struct label_symbol_struct *lss_next;
446 /* Extra information needed to perform fixups (relocations) on the PA. */
447 struct hppa_fix_struct
449 /* The field selector. */
450 enum hppa_reloc_field_selector_type_alt fx_r_field;
455 /* Format of fixup. */
458 /* Argument relocation bits. */
459 unsigned int fx_arg_reloc;
461 /* The segment this fixup appears in. */
465 /* Structure to hold information about predefined registers. */
473 /* This structure defines the mapping from a FP condition string
474 to a condition number which can be recorded in an instruction. */
481 /* This structure defines a mapping from a field selector
482 string to a field selector type. */
483 struct selector_entry
489 /* Prototypes for functions local to tc-hppa.c. */
492 static void pa_check_current_space_and_subspace (void);
495 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
496 static void pa_text (int);
497 static void pa_data (int);
498 static void pa_comm (int);
501 static int exact_log2 (int);
502 static void pa_compiler (int);
503 static void pa_align (int);
504 static void pa_space (int);
505 static void pa_spnum (int);
506 static void pa_subspace (int);
507 static sd_chain_struct *create_new_space (const char *, int, int,
510 static ssd_chain_struct *create_new_subspace (sd_chain_struct *,
511 const char *, int, int,
515 static ssd_chain_struct *update_subspace (sd_chain_struct *,
516 char *, int, int, int,
520 static sd_chain_struct *is_defined_space (const char *);
521 static ssd_chain_struct *is_defined_subspace (const char *);
522 static sd_chain_struct *pa_segment_to_space (asection *);
523 static ssd_chain_struct *pa_subsegment_to_subspace (asection *,
525 static sd_chain_struct *pa_find_space_by_number (int);
526 static unsigned int pa_subspace_start (sd_chain_struct *, int);
527 static sd_chain_struct *pa_parse_space_stmt (const char *, int);
530 /* File and globally scoped variable declarations. */
533 /* Root and final entry in the space chain. */
534 static sd_chain_struct *space_dict_root;
535 static sd_chain_struct *space_dict_last;
537 /* The current space and subspace. */
538 static sd_chain_struct *current_space;
539 static ssd_chain_struct *current_subspace;
542 /* Root of the call_info chain. */
543 static struct call_info *call_info_root;
545 /* The last call_info (for functions) structure
546 seen so it can be associated with fixups and
548 static struct call_info *last_call_info;
550 /* The last call description (for actual calls). */
551 static struct call_desc last_call_desc;
553 /* handle of the OPCODE hash table */
554 static struct hash_control *op_hash = NULL;
556 /* These characters can be suffixes of opcode names and they may be
557 followed by meaningful whitespace. We don't include `,' and `!'
558 as they never appear followed by meaningful whitespace. */
559 const char hppa_symbol_chars[] = "*?=<>";
561 /* This array holds the chars that only start a comment at the beginning of
562 a line. If the line seems to have the form '# 123 filename'
563 .line and .file directives will appear in the pre-processed output.
565 Note that input_file.c hand checks for '#' at the beginning of the
566 first line of the input file. This is because the compiler outputs
567 #NO_APP at the beginning of its output.
569 Also note that C style comments will always work. */
570 const char line_comment_chars[] = "#";
572 /* This array holds the chars that always start a comment. If the
573 pre-processor is disabled, these aren't very useful. */
574 const char comment_chars[] = ";";
576 /* This array holds the characters which act as line separators. */
577 const char line_separator_chars[] = "!";
579 /* Chars that can be used to separate mant from exp in floating point nums. */
580 const char EXP_CHARS[] = "eE";
582 /* Chars that mean this number is a floating point constant.
583 As in 0f12.456 or 0d1.2345e12.
585 Be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
586 changed in read.c. Ideally it shouldn't have to know about it
587 at all, but nothing is ideal around here. */
588 const char FLT_CHARS[] = "rRsSfFdDxXpP";
590 static struct pa_it the_insn;
592 /* Points to the end of an expression just parsed by get_expression
593 and friends. FIXME. This shouldn't be handled with a file-global
595 static char *expr_end;
597 /* Nonzero if a .callinfo appeared within the current procedure. */
598 static int callinfo_found;
600 /* Nonzero if the assembler is currently within a .entry/.exit pair. */
601 static int within_entry_exit;
603 /* Nonzero if the assembler is currently within a procedure definition. */
604 static int within_procedure;
606 /* Handle on structure which keep track of the last symbol
607 seen in each subspace. */
608 static label_symbol_struct *label_symbols_rootp = NULL;
610 /* Last label symbol */
611 static label_symbol_struct last_label_symbol;
613 /* Nonzero when strict matching is enabled. Zero otherwise.
615 Each opcode in the table has a flag which indicates whether or
616 not strict matching should be enabled for that instruction.
618 Mainly, strict causes errors to be ignored when a match failure
619 occurs. However, it also affects the parsing of register fields
620 by pa_parse_number. */
623 /* pa_parse_number returns values in `pa_number'. Mostly
624 pa_parse_number is used to return a register number, with floating
625 point registers being numbered from FP_REG_BASE upwards.
626 The bit specified with FP_REG_RSEL is set if the floating point
627 register has a `r' suffix. */
628 #define FP_REG_BASE 64
629 #define FP_REG_RSEL 128
630 static int pa_number;
633 /* A dummy bfd symbol so that all relocations have symbols of some kind. */
634 static symbolS *dummy_symbol;
637 /* Nonzero if errors are to be printed. */
638 static int print_errors = 1;
640 /* List of registers that are pre-defined:
642 Each general register has one predefined name of the form
643 %r<REGNUM> which has the value <REGNUM>.
645 Space and control registers are handled in a similar manner,
646 but use %sr<REGNUM> and %cr<REGNUM> as their predefined names.
648 Likewise for the floating point registers, but of the form
649 %fr<REGNUM>. Floating point registers have additional predefined
650 names with 'L' and 'R' suffixes (e.g. %fr19L, %fr19R) which
651 again have the value <REGNUM>.
653 Many registers also have synonyms:
655 %r26 - %r23 have %arg0 - %arg3 as synonyms
656 %r28 - %r29 have %ret0 - %ret1 as synonyms
657 %fr4 - %fr7 have %farg0 - %farg3 as synonyms
658 %r30 has %sp as a synonym
659 %r27 has %dp as a synonym
660 %r2 has %rp as a synonym
662 Almost every control register has a synonym; they are not listed
665 The table is sorted. Suitable for searching by a binary search. */
667 static const struct pd_reg pre_defined_registers[] =
701 {"%farg0", 4 + FP_REG_BASE},
702 {"%farg1", 5 + FP_REG_BASE},
703 {"%farg2", 6 + FP_REG_BASE},
704 {"%farg3", 7 + FP_REG_BASE},
705 {"%fr0", 0 + FP_REG_BASE},
706 {"%fr0l", 0 + FP_REG_BASE},
707 {"%fr0r", 0 + FP_REG_BASE + FP_REG_RSEL},
708 {"%fr1", 1 + FP_REG_BASE},
709 {"%fr10", 10 + FP_REG_BASE},
710 {"%fr10l", 10 + FP_REG_BASE},
711 {"%fr10r", 10 + FP_REG_BASE + FP_REG_RSEL},
712 {"%fr11", 11 + FP_REG_BASE},
713 {"%fr11l", 11 + FP_REG_BASE},
714 {"%fr11r", 11 + FP_REG_BASE + FP_REG_RSEL},
715 {"%fr12", 12 + FP_REG_BASE},
716 {"%fr12l", 12 + FP_REG_BASE},
717 {"%fr12r", 12 + FP_REG_BASE + FP_REG_RSEL},
718 {"%fr13", 13 + FP_REG_BASE},
719 {"%fr13l", 13 + FP_REG_BASE},
720 {"%fr13r", 13 + FP_REG_BASE + FP_REG_RSEL},
721 {"%fr14", 14 + FP_REG_BASE},
722 {"%fr14l", 14 + FP_REG_BASE},
723 {"%fr14r", 14 + FP_REG_BASE + FP_REG_RSEL},
724 {"%fr15", 15 + FP_REG_BASE},
725 {"%fr15l", 15 + FP_REG_BASE},
726 {"%fr15r", 15 + FP_REG_BASE + FP_REG_RSEL},
727 {"%fr16", 16 + FP_REG_BASE},
728 {"%fr16l", 16 + FP_REG_BASE},
729 {"%fr16r", 16 + FP_REG_BASE + FP_REG_RSEL},
730 {"%fr17", 17 + FP_REG_BASE},
731 {"%fr17l", 17 + FP_REG_BASE},
732 {"%fr17r", 17 + FP_REG_BASE + FP_REG_RSEL},
733 {"%fr18", 18 + FP_REG_BASE},
734 {"%fr18l", 18 + FP_REG_BASE},
735 {"%fr18r", 18 + FP_REG_BASE + FP_REG_RSEL},
736 {"%fr19", 19 + FP_REG_BASE},
737 {"%fr19l", 19 + FP_REG_BASE},
738 {"%fr19r", 19 + FP_REG_BASE + FP_REG_RSEL},
739 {"%fr1l", 1 + FP_REG_BASE},
740 {"%fr1r", 1 + FP_REG_BASE + FP_REG_RSEL},
741 {"%fr2", 2 + FP_REG_BASE},
742 {"%fr20", 20 + FP_REG_BASE},
743 {"%fr20l", 20 + FP_REG_BASE},
744 {"%fr20r", 20 + FP_REG_BASE + FP_REG_RSEL},
745 {"%fr21", 21 + FP_REG_BASE},
746 {"%fr21l", 21 + FP_REG_BASE},
747 {"%fr21r", 21 + FP_REG_BASE + FP_REG_RSEL},
748 {"%fr22", 22 + FP_REG_BASE},
749 {"%fr22l", 22 + FP_REG_BASE},
750 {"%fr22r", 22 + FP_REG_BASE + FP_REG_RSEL},
751 {"%fr23", 23 + FP_REG_BASE},
752 {"%fr23l", 23 + FP_REG_BASE},
753 {"%fr23r", 23 + FP_REG_BASE + FP_REG_RSEL},
754 {"%fr24", 24 + FP_REG_BASE},
755 {"%fr24l", 24 + FP_REG_BASE},
756 {"%fr24r", 24 + FP_REG_BASE + FP_REG_RSEL},
757 {"%fr25", 25 + FP_REG_BASE},
758 {"%fr25l", 25 + FP_REG_BASE},
759 {"%fr25r", 25 + FP_REG_BASE + FP_REG_RSEL},
760 {"%fr26", 26 + FP_REG_BASE},
761 {"%fr26l", 26 + FP_REG_BASE},
762 {"%fr26r", 26 + FP_REG_BASE + FP_REG_RSEL},
763 {"%fr27", 27 + FP_REG_BASE},
764 {"%fr27l", 27 + FP_REG_BASE},
765 {"%fr27r", 27 + FP_REG_BASE + FP_REG_RSEL},
766 {"%fr28", 28 + FP_REG_BASE},
767 {"%fr28l", 28 + FP_REG_BASE},
768 {"%fr28r", 28 + FP_REG_BASE + FP_REG_RSEL},
769 {"%fr29", 29 + FP_REG_BASE},
770 {"%fr29l", 29 + FP_REG_BASE},
771 {"%fr29r", 29 + FP_REG_BASE + FP_REG_RSEL},
772 {"%fr2l", 2 + FP_REG_BASE},
773 {"%fr2r", 2 + FP_REG_BASE + FP_REG_RSEL},
774 {"%fr3", 3 + FP_REG_BASE},
775 {"%fr30", 30 + FP_REG_BASE},
776 {"%fr30l", 30 + FP_REG_BASE},
777 {"%fr30r", 30 + FP_REG_BASE + FP_REG_RSEL},
778 {"%fr31", 31 + FP_REG_BASE},
779 {"%fr31l", 31 + FP_REG_BASE},
780 {"%fr31r", 31 + FP_REG_BASE + FP_REG_RSEL},
781 {"%fr3l", 3 + FP_REG_BASE},
782 {"%fr3r", 3 + FP_REG_BASE + FP_REG_RSEL},
783 {"%fr4", 4 + FP_REG_BASE},
784 {"%fr4l", 4 + FP_REG_BASE},
785 {"%fr4r", 4 + FP_REG_BASE + FP_REG_RSEL},
786 {"%fr5", 5 + FP_REG_BASE},
787 {"%fr5l", 5 + FP_REG_BASE},
788 {"%fr5r", 5 + FP_REG_BASE + FP_REG_RSEL},
789 {"%fr6", 6 + FP_REG_BASE},
790 {"%fr6l", 6 + FP_REG_BASE},
791 {"%fr6r", 6 + FP_REG_BASE + FP_REG_RSEL},
792 {"%fr7", 7 + FP_REG_BASE},
793 {"%fr7l", 7 + FP_REG_BASE},
794 {"%fr7r", 7 + FP_REG_BASE + FP_REG_RSEL},
795 {"%fr8", 8 + FP_REG_BASE},
796 {"%fr8l", 8 + FP_REG_BASE},
797 {"%fr8r", 8 + FP_REG_BASE + FP_REG_RSEL},
798 {"%fr9", 9 + FP_REG_BASE},
799 {"%fr9l", 9 + FP_REG_BASE},
800 {"%fr9r", 9 + FP_REG_BASE + FP_REG_RSEL},
809 #if TARGET_ARCH_SIZE == 64
885 /* This table is sorted by order of the length of the string. This is
886 so we check for <> before we check for <. If we had a <> and checked
887 for < first, we would get a false match. */
888 static const struct fp_cond_map fp_cond_map[] =
924 static const struct selector_entry selector_table[] =
949 /* default space and subspace dictionaries */
951 #define GDB_SYMBOLS GDB_SYMBOLS_SUBSPACE_NAME
952 #define GDB_STRINGS GDB_STRINGS_SUBSPACE_NAME
954 /* pre-defined subsegments (subspaces) for the HPPA. */
955 #define SUBSEG_CODE 0
957 #define SUBSEG_MILLI 2
958 #define SUBSEG_DATA 0
960 #define SUBSEG_UNWIND 3
961 #define SUBSEG_GDB_STRINGS 0
962 #define SUBSEG_GDB_SYMBOLS 1
964 static struct default_subspace_dict pa_def_subspaces[] =
966 {"$CODE$", 1, 1, 1, 0, 0, 0, 0, 24, 0x2c, 0, 8, 0, 0, SUBSEG_CODE},
967 {"$DATA$", 1, 1, 0, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, SUBSEG_DATA},
968 {"$LIT$", 1, 1, 0, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, SUBSEG_LIT},
969 {"$MILLICODE$", 1, 1, 0, 0, 0, 0, 0, 8, 0x2c, 0, 8, 0, 0, SUBSEG_MILLI},
970 {"$BSS$", 1, 1, 0, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, SUBSEG_BSS},
971 {NULL, 0, 1, 0, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
974 static struct default_space_dict pa_def_spaces[] =
976 {"$TEXT$", 0, 1, 1, 0, 8, ASEC_NULL},
977 {"$PRIVATE$", 1, 1, 1, 1, 16, ASEC_NULL},
978 {NULL, 0, 0, 0, 0, 0, ASEC_NULL}
981 /* Misc local definitions used by the assembler. */
983 /* These macros are used to maintain spaces/subspaces. */
984 #define SPACE_DEFINED(space_chain) (space_chain)->sd_defined
985 #define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
986 #define SPACE_SPNUM(space_chain) (space_chain)->sd_spnum
987 #define SPACE_NAME(space_chain) (space_chain)->sd_name
989 #define SUBSPACE_DEFINED(ss_chain) (ss_chain)->ssd_defined
990 #define SUBSPACE_NAME(ss_chain) (ss_chain)->ssd_name
993 /* Return nonzero if the string pointed to by S potentially represents
994 a right or left half of a FP register */
995 #define IS_R_SELECT(S) (*(S) == 'R' || *(S) == 'r')
996 #define IS_L_SELECT(S) (*(S) == 'L' || *(S) == 'l')
998 /* Store immediate values of shift/deposit/extract functions. */
1000 #define SAVE_IMMEDIATE(VALUE) \
1002 if (immediate_check) \
1006 else if (len == -1) \
1011 /* Insert FIELD into OPCODE starting at bit START. Continue pa_ip
1012 main loop after insertion. */
1014 #define INSERT_FIELD_AND_CONTINUE(OPCODE, FIELD, START) \
1016 ((OPCODE) |= (FIELD) << (START)); \
1020 /* Simple range checking for FIELD against HIGH and LOW bounds.
1021 IGNORE is used to suppress the error message. */
1023 #define CHECK_FIELD(FIELD, HIGH, LOW, IGNORE) \
1025 if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1028 as_bad (_("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1034 /* Variant of CHECK_FIELD for use in md_apply_fix and other places where
1035 the current file and line number are not valid. */
1037 #define CHECK_FIELD_WHERE(FIELD, HIGH, LOW, FILENAME, LINE) \
1039 if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1041 as_bad_where ((FILENAME), (LINE), \
1042 _("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1048 /* Simple alignment checking for FIELD against ALIGN (a power of two).
1049 IGNORE is used to suppress the error message. */
1051 #define CHECK_ALIGN(FIELD, ALIGN, IGNORE) \
1053 if ((FIELD) & ((ALIGN) - 1)) \
1056 as_bad (_("Field not properly aligned [%d] (%d)."), (ALIGN), \
1062 #define is_DP_relative(exp) \
1063 ((exp).X_op == O_subtract \
1064 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$global$") == 0)
1066 #define is_SB_relative(exp) \
1067 ((exp).X_op == O_subtract \
1068 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$segrel$") == 0)
1070 #define is_PC_relative(exp) \
1071 ((exp).X_op == O_subtract \
1072 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$PIC_pcrel$0") == 0)
1074 #define is_tls_gdidx(exp) \
1075 ((exp).X_op == O_subtract \
1076 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_gdidx$") == 0)
1078 #define is_tls_ldidx(exp) \
1079 ((exp).X_op == O_subtract \
1080 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_ldidx$") == 0)
1082 #define is_tls_dtpoff(exp) \
1083 ((exp).X_op == O_subtract \
1084 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_dtpoff$") == 0)
1086 #define is_tls_ieoff(exp) \
1087 ((exp).X_op == O_subtract \
1088 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_ieoff$") == 0)
1090 #define is_tls_leoff(exp) \
1091 ((exp).X_op == O_subtract \
1092 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$tls_leoff$") == 0)
1094 /* We need some complex handling for stabs (sym1 - sym2). Luckily, we'll
1095 always be able to reduce the expression to a constant, so we don't
1096 need real complex handling yet. */
1097 #define is_complex(exp) \
1098 ((exp).X_op != O_constant && (exp).X_op != O_symbol)
1100 /* Actual functions to implement the PA specific code for the assembler. */
1102 /* Called before writing the object file. Make sure entry/exit and
1103 proc/procend pairs match. */
1108 if (within_entry_exit)
1109 as_fatal (_("Missing .exit\n"));
1111 if (within_procedure)
1112 as_fatal (_("Missing .procend\n"));
1115 /* Returns a pointer to the label_symbol_struct for the current space.
1116 or NULL if no label_symbol_struct exists for the current space. */
1118 static label_symbol_struct *
1121 label_symbol_struct *label_chain = label_symbols_rootp;
1126 if (current_space == label_chain->lss_space && label_chain->lss_label)
1130 if (now_seg == label_chain->lss_segment && label_chain->lss_label)
1138 /* Defines a label for the current space. If one is already defined,
1139 this function will replace it with the new label. */
1142 pa_define_label (symbolS *symbol)
1144 label_symbol_struct *label_chain = label_symbols_rootp;
1147 label_chain = &last_label_symbol;
1149 label_chain->lss_label = symbol;
1151 label_chain->lss_space = current_space;
1154 label_chain->lss_segment = now_seg;
1158 label_chain->lss_next = NULL;
1160 label_symbols_rootp = label_chain;
1163 dwarf2_emit_label (symbol);
1167 /* Removes a label definition for the current space.
1168 If there is no label_symbol_struct entry, then no action is taken. */
1171 pa_undefine_label (void)
1173 label_symbols_rootp = NULL;
1176 /* An HPPA-specific version of fix_new. This is required because the HPPA
1177 code needs to keep track of some extra stuff. Each call to fix_new_hppa
1178 results in the creation of an instance of an hppa_fix_struct. An
1179 hppa_fix_struct stores the extra information along with a pointer to the
1180 original fixS. This is attached to the original fixup via the
1181 tc_fix_data field. */
1184 fix_new_hppa (fragS *frag,
1187 symbolS *add_symbol,
1191 bfd_reloc_code_real_type r_type,
1192 enum hppa_reloc_field_selector_type_alt r_field,
1194 unsigned int arg_reloc,
1195 int unwind_bits ATTRIBUTE_UNUSED)
1198 struct hppa_fix_struct *hppa_fix = XOBNEW (¬es, struct hppa_fix_struct);
1201 new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
1203 new_fix = fix_new (frag, where, size, add_symbol, offset, pcrel, r_type);
1204 new_fix->tc_fix_data = (void *) hppa_fix;
1205 hppa_fix->fx_r_type = r_type;
1206 hppa_fix->fx_r_field = r_field;
1207 hppa_fix->fx_r_format = r_format;
1208 hppa_fix->fx_arg_reloc = arg_reloc;
1209 hppa_fix->segment = now_seg;
1211 if (r_type == R_ENTRY || r_type == R_EXIT)
1212 new_fix->fx_offset = unwind_bits;
1215 /* foo-$global$ is used to access non-automatic storage. $global$
1216 is really just a marker and has served its purpose, so eliminate
1217 it now so as not to confuse write.c. Ditto for $PIC_pcrel$0. */
1218 if (new_fix->fx_subsy
1219 && (strcmp (S_GET_NAME (new_fix->fx_subsy), "$global$") == 0
1220 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$segrel$") == 0
1221 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$PIC_pcrel$0") == 0
1222 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_gdidx$") == 0
1223 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_ldidx$") == 0
1224 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_dtpoff$") == 0
1225 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_ieoff$") == 0
1226 || strcmp (S_GET_NAME (new_fix->fx_subsy), "$tls_leoff$") == 0))
1227 new_fix->fx_subsy = NULL;
1230 /* This fix_new is called by cons via TC_CONS_FIX_NEW.
1231 hppa_field_selector is set by the parse_cons_expression_hppa. */
1234 cons_fix_new_hppa (fragS *frag, int where, int size, expressionS *exp,
1235 int hppa_field_selector)
1237 unsigned int rel_type;
1239 /* Get a base relocation type. */
1240 if (is_DP_relative (*exp))
1241 rel_type = R_HPPA_GOTOFF;
1242 else if (is_PC_relative (*exp))
1243 rel_type = R_HPPA_PCREL_CALL;
1245 else if (is_SB_relative (*exp))
1246 rel_type = R_PARISC_SEGREL32;
1247 else if (is_tls_gdidx (*exp))
1248 rel_type = R_PARISC_TLS_GD21L;
1249 else if (is_tls_ldidx (*exp))
1250 rel_type = R_PARISC_TLS_LDM21L;
1251 else if (is_tls_dtpoff (*exp))
1252 rel_type = R_PARISC_TLS_LDO21L;
1253 else if (is_tls_ieoff (*exp))
1254 rel_type = R_PARISC_TLS_IE21L;
1255 else if (is_tls_leoff (*exp))
1256 rel_type = R_PARISC_TLS_LE21L;
1258 else if (is_complex (*exp))
1259 rel_type = R_HPPA_COMPLEX;
1263 if (hppa_field_selector != e_psel && hppa_field_selector != e_fsel)
1265 as_warn (_("Invalid field selector. Assuming F%%."));
1266 hppa_field_selector = e_fsel;
1269 fix_new_hppa (frag, where, size,
1270 (symbolS *) NULL, (offsetT) 0, exp, 0, rel_type,
1271 hppa_field_selector, size * 8, 0, 0);
1274 /* Mark (via expr_end) the end of an expression (I think). FIXME. */
1277 get_expression (char *str)
1282 save_in = input_line_pointer;
1283 input_line_pointer = str;
1284 seg = expression (&the_insn.exp);
1285 if (!(seg == absolute_section
1286 || seg == undefined_section
1287 || SEG_NORMAL (seg)))
1289 as_warn (_("Bad segment in expression."));
1290 expr_end = input_line_pointer;
1291 input_line_pointer = save_in;
1294 expr_end = input_line_pointer;
1295 input_line_pointer = save_in;
1298 /* Parse a PA nullification completer (,n). Return nonzero if the
1299 completer was found; return zero if no completer was found. */
1302 pa_parse_nullif (char **s)
1310 if (strncasecmp (*s, "n", 1) == 0)
1314 as_bad (_("Invalid Nullification: (%c)"), **s);
1324 md_atof (int type, char *litP, int *sizeP)
1326 return ieee_md_atof (type, litP, sizeP, TRUE);
1329 /* Write out big-endian. */
1332 md_number_to_chars (char *buf, valueT val, int n)
1334 number_to_chars_bigendian (buf, val, n);
1337 /* Translate internal representation of relocation info to BFD target
1341 tc_gen_reloc (asection *section, fixS *fixp)
1344 struct hppa_fix_struct *hppa_fixp;
1345 static arelent *no_relocs = NULL;
1352 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
1353 if (fixp->fx_addsy == 0)
1356 gas_assert (hppa_fixp != 0);
1357 gas_assert (section != 0);
1359 reloc = XNEW (arelent);
1361 reloc->sym_ptr_ptr = XNEW (asymbol *);
1362 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1364 /* Allow fixup_segment to recognize hand-written pc-relative relocations.
1365 When we went through cons_fix_new_hppa, we classified them as complex. */
1366 /* ??? It might be better to hide this +8 stuff in tc_cfi_emit_pcrel_expr,
1367 undefine DIFF_EXPR_OK, and let these sorts of complex expressions fail
1368 when R_HPPA_COMPLEX == R_PARISC_UNIMPLEMENTED. */
1369 if (fixp->fx_r_type == (bfd_reloc_code_real_type) R_HPPA_COMPLEX
1372 fixp->fx_r_type = R_HPPA_PCREL_CALL;
1373 fixp->fx_offset += 8;
1376 codes = hppa_gen_reloc_type (stdoutput,
1378 hppa_fixp->fx_r_format,
1379 hppa_fixp->fx_r_field,
1380 fixp->fx_subsy != NULL,
1381 symbol_get_bfdsym (fixp->fx_addsy));
1385 as_bad_where (fixp->fx_file, fixp->fx_line, _("Cannot handle fixup"));
1389 for (n_relocs = 0; codes[n_relocs]; n_relocs++)
1392 relocs = XNEWVEC (arelent *, n_relocs + 1);
1393 reloc = XNEWVEC (arelent, n_relocs);
1394 for (i = 0; i < n_relocs; i++)
1395 relocs[i] = &reloc[i];
1397 relocs[n_relocs] = NULL;
1400 switch (fixp->fx_r_type)
1403 gas_assert (n_relocs == 1);
1407 /* Now, do any processing that is dependent on the relocation type. */
1410 case R_PARISC_DLTREL21L:
1411 case R_PARISC_DLTREL14R:
1412 case R_PARISC_DLTREL14F:
1413 case R_PARISC_PLABEL32:
1414 case R_PARISC_PLABEL21L:
1415 case R_PARISC_PLABEL14R:
1416 /* For plabel relocations, the addend of the
1417 relocation should be either 0 (no static link) or 2
1418 (static link required). This adjustment is done in
1419 bfd/elf32-hppa.c:elf32_hppa_relocate_section.
1421 We also slam a zero addend into the DLT relative relocs;
1422 it doesn't make a lot of sense to use any addend since
1423 it gets you a different (eg unknown) DLT entry. */
1427 #ifdef ELF_ARG_RELOC
1428 case R_PARISC_PCREL17R:
1429 case R_PARISC_PCREL17F:
1430 case R_PARISC_PCREL17C:
1431 case R_PARISC_DIR17R:
1432 case R_PARISC_DIR17F:
1433 case R_PARISC_PCREL21L:
1434 case R_PARISC_DIR21L:
1435 reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc,
1440 case R_PARISC_DIR32:
1441 /* Facilitate hand-crafted unwind info. */
1442 if (strcmp (section->name, UNWIND_SECTION_NAME) == 0)
1443 code = R_PARISC_SEGREL32;
1447 reloc->addend = fixp->fx_offset;
1451 reloc->sym_ptr_ptr = XNEW (asymbol *);
1452 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1453 reloc->howto = bfd_reloc_type_lookup (stdoutput,
1454 (bfd_reloc_code_real_type) code);
1455 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1457 gas_assert (reloc->howto && (unsigned int) code == reloc->howto->type);
1462 /* Walk over reach relocation returned by the BFD backend. */
1463 for (i = 0; i < n_relocs; i++)
1467 relocs[i]->sym_ptr_ptr = XNEW (asymbol *);
1468 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1470 bfd_reloc_type_lookup (stdoutput,
1471 (bfd_reloc_code_real_type) code);
1472 relocs[i]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1477 /* The only time we ever use a R_COMP2 fixup is for the difference
1478 of two symbols. With that in mind we fill in all four
1479 relocs now and break out of the loop. */
1480 gas_assert (i == 1);
1481 relocs[0]->sym_ptr_ptr
1482 = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
1484 = bfd_reloc_type_lookup (stdoutput,
1485 (bfd_reloc_code_real_type) *codes[0]);
1486 relocs[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1487 relocs[0]->addend = 0;
1488 relocs[1]->sym_ptr_ptr = XNEW (asymbol *);
1489 *relocs[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1491 = bfd_reloc_type_lookup (stdoutput,
1492 (bfd_reloc_code_real_type) *codes[1]);
1493 relocs[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1494 relocs[1]->addend = 0;
1495 relocs[2]->sym_ptr_ptr = XNEW (asymbol *);
1496 *relocs[2]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
1498 = bfd_reloc_type_lookup (stdoutput,
1499 (bfd_reloc_code_real_type) *codes[2]);
1500 relocs[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1501 relocs[2]->addend = 0;
1502 relocs[3]->sym_ptr_ptr
1503 = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
1505 = bfd_reloc_type_lookup (stdoutput,
1506 (bfd_reloc_code_real_type) *codes[3]);
1507 relocs[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1508 relocs[3]->addend = 0;
1509 relocs[4]->sym_ptr_ptr
1510 = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
1512 = bfd_reloc_type_lookup (stdoutput,
1513 (bfd_reloc_code_real_type) *codes[4]);
1514 relocs[4]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1515 relocs[4]->addend = 0;
1519 relocs[i]->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
1525 /* For plabel relocations, the addend of the
1526 relocation should be either 0 (no static link) or 2
1527 (static link required).
1529 FIXME: We always assume no static link!
1531 We also slam a zero addend into the DLT relative relocs;
1532 it doesn't make a lot of sense to use any addend since
1533 it gets you a different (eg unknown) DLT entry. */
1534 relocs[i]->addend = 0;
1549 /* There is no symbol or addend associated with these fixups. */
1550 relocs[i]->sym_ptr_ptr = XNEW (asymbol *);
1551 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
1552 relocs[i]->addend = 0;
1558 /* There is no symbol associated with these fixups. */
1559 relocs[i]->sym_ptr_ptr = XNEW (asymbol *);
1560 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
1561 relocs[i]->addend = fixp->fx_offset;
1565 relocs[i]->addend = fixp->fx_offset;
1575 /* Process any machine dependent frag types. */
1578 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
1579 asection *sec ATTRIBUTE_UNUSED,
1582 unsigned int address;
1584 if (fragP->fr_type == rs_machine_dependent)
1586 switch ((int) fragP->fr_subtype)
1589 fragP->fr_type = rs_fill;
1590 know (fragP->fr_var == 1);
1591 know (fragP->fr_next);
1592 address = fragP->fr_address + fragP->fr_fix;
1593 if (address % fragP->fr_offset)
1596 fragP->fr_next->fr_address
1601 fragP->fr_offset = 0;
1607 /* Round up a section size to the appropriate boundary. */
1610 md_section_align (asection *segment, valueT size)
1612 int align = bfd_get_section_alignment (stdoutput, segment);
1613 int align2 = (1 << align) - 1;
1615 return (size + align2) & ~align2;
1618 /* Return the approximate size of a frag before relaxation has occurred. */
1621 md_estimate_size_before_relax (fragS *fragP, asection *segment ATTRIBUTE_UNUSED)
1627 while ((fragP->fr_fix + size) % fragP->fr_offset)
1634 # ifdef WARN_COMMENTS
1635 const char *md_shortopts = "Vc";
1637 const char *md_shortopts = "V";
1640 # ifdef WARN_COMMENTS
1641 const char *md_shortopts = "c";
1643 const char *md_shortopts = "";
1647 struct option md_longopts[] =
1649 #ifdef WARN_COMMENTS
1650 {"warn-comment", no_argument, NULL, 'c'},
1652 {NULL, no_argument, NULL, 0}
1654 size_t md_longopts_size = sizeof (md_longopts);
1657 md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED)
1666 print_version_id ();
1669 #ifdef WARN_COMMENTS
1680 md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
1683 fprintf (stream, _("\
1686 #ifdef WARN_COMMENTS
1687 fprintf (stream, _("\
1688 -c print a warning if a comment is found\n"));
1692 /* We have no need to default values of symbols. */
1695 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
1700 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
1701 #define nonzero_dibits(x) \
1702 ((x) | (((x) & 0x55555555) << 1) | (((x) & 0xAAAAAAAA) >> 1))
1703 #define arg_reloc_stub_needed(CALLER, CALLEE) \
1704 (((CALLER) ^ (CALLEE)) & nonzero_dibits (CALLER) & nonzero_dibits (CALLEE))
1706 #define arg_reloc_stub_needed(CALLER, CALLEE) 0
1709 /* Apply a fixup to an instruction. */
1712 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
1715 struct hppa_fix_struct *hppa_fixP;
1719 /* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
1720 never be "applied" (they are just markers). Likewise for
1721 R_HPPA_BEGIN_BRTAB and R_HPPA_END_BRTAB. */
1723 if (fixP->fx_r_type == R_HPPA_ENTRY
1724 || fixP->fx_r_type == R_HPPA_EXIT
1725 || fixP->fx_r_type == R_HPPA_BEGIN_BRTAB
1726 || fixP->fx_r_type == R_HPPA_END_BRTAB
1727 || fixP->fx_r_type == R_HPPA_BEGIN_TRY)
1730 /* Disgusting. We must set fx_offset ourselves -- R_HPPA_END_TRY
1731 fixups are considered not adjustable, which in turn causes
1732 adjust_reloc_syms to not set fx_offset. Ugh. */
1733 if (fixP->fx_r_type == R_HPPA_END_TRY)
1735 fixP->fx_offset = * valP;
1740 if (fixP->fx_r_type == (int) R_PARISC_GNU_VTENTRY
1741 || fixP->fx_r_type == (int) R_PARISC_GNU_VTINHERIT)
1745 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
1748 /* There should be a HPPA specific fixup associated with the GAS fixup. */
1749 hppa_fixP = (struct hppa_fix_struct *) fixP->tc_fix_data;
1750 if (hppa_fixP == NULL)
1752 as_bad_where (fixP->fx_file, fixP->fx_line,
1753 _("no hppa_fixup entry for fixup type 0x%x"),
1758 fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
1760 if (fixP->fx_size != 4 || hppa_fixP->fx_r_format == 32)
1762 /* Handle constant output. */
1763 number_to_chars_bigendian (fixpos, *valP, fixP->fx_size);
1767 insn = bfd_get_32 (stdoutput, fixpos);
1768 fmt = bfd_hppa_insn2fmt (stdoutput, insn);
1770 /* If there is a symbol associated with this fixup, then it's something
1771 which will need a SOM relocation (except for some PC-relative relocs).
1772 In such cases we should treat the "val" or "addend" as zero since it
1773 will be added in as needed from fx_offset in tc_gen_reloc. */
1774 if ((fixP->fx_addsy != NULL
1775 || fixP->fx_r_type == (int) R_HPPA_NONE)
1780 new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
1782 /* These field selectors imply that we do not want an addend. */
1783 else if (hppa_fixP->fx_r_field == e_psel
1784 || hppa_fixP->fx_r_field == e_rpsel
1785 || hppa_fixP->fx_r_field == e_lpsel
1786 || hppa_fixP->fx_r_field == e_tsel
1787 || hppa_fixP->fx_r_field == e_rtsel
1788 || hppa_fixP->fx_r_field == e_ltsel)
1789 new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
1792 new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
1794 /* Handle pc-relative exceptions from above. */
1795 if ((fmt == 12 || fmt == 17 || fmt == 22)
1798 && !arg_reloc_stub_needed (symbol_arg_reloc_info (fixP->fx_addsy),
1799 hppa_fixP->fx_arg_reloc)
1801 && (* valP - 8 + 8192 < 16384
1802 || (fmt == 17 && * valP - 8 + 262144 < 524288)
1803 || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
1806 && (* valP - 8 + 262144 < 524288
1807 || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
1809 && !S_IS_EXTERNAL (fixP->fx_addsy)
1810 && !S_IS_WEAK (fixP->fx_addsy)
1811 && S_GET_SEGMENT (fixP->fx_addsy) == hppa_fixP->segment
1813 && S_GET_SEGMENT (fixP->fx_subsy) != hppa_fixP->segment))
1815 new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
1821 CHECK_FIELD_WHERE (new_val, 8191, -8192,
1822 fixP->fx_file, fixP->fx_line);
1825 insn = (insn & ~ 0x3ff1) | (((val & 0x1ff8) << 1)
1826 | ((val & 0x2000) >> 13));
1829 CHECK_FIELD_WHERE (new_val, 8191, -8192,
1830 fixP->fx_file, fixP->fx_line);
1833 insn = (insn & ~ 0x3ff9) | (((val & 0x1ffc) << 1)
1834 | ((val & 0x2000) >> 13));
1836 /* Handle all opcodes with the 'j' operand type. */
1838 CHECK_FIELD_WHERE (new_val, 8191, -8192,
1839 fixP->fx_file, fixP->fx_line);
1842 insn = ((insn & ~ 0x3fff) | low_sign_unext (val, 14));
1845 /* Handle all opcodes with the 'k' operand type. */
1847 CHECK_FIELD_WHERE (new_val, 1048575, -1048576,
1848 fixP->fx_file, fixP->fx_line);
1851 insn = (insn & ~ 0x1fffff) | re_assemble_21 (val);
1854 /* Handle all the opcodes with the 'i' operand type. */
1856 CHECK_FIELD_WHERE (new_val, 1023, -1024,
1857 fixP->fx_file, fixP->fx_line);
1860 insn = (insn & ~ 0x7ff) | low_sign_unext (val, 11);
1863 /* Handle all the opcodes with the 'w' operand type. */
1865 CHECK_FIELD_WHERE (new_val - 8, 8191, -8192,
1866 fixP->fx_file, fixP->fx_line);
1869 insn = (insn & ~ 0x1ffd) | re_assemble_12 (val >> 2);
1872 /* Handle some of the opcodes with the 'W' operand type. */
1875 offsetT distance = * valP;
1877 /* If this is an absolute branch (ie no link) with an out of
1878 range target, then we want to complain. */
1879 if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
1880 && (insn & 0xffe00000) == 0xe8000000)
1881 CHECK_FIELD_WHERE (distance - 8, 262143, -262144,
1882 fixP->fx_file, fixP->fx_line);
1884 CHECK_FIELD_WHERE (new_val - 8, 262143, -262144,
1885 fixP->fx_file, fixP->fx_line);
1888 insn = (insn & ~ 0x1f1ffd) | re_assemble_17 (val >> 2);
1894 offsetT distance = * valP;
1896 /* If this is an absolute branch (ie no link) with an out of
1897 range target, then we want to complain. */
1898 if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
1899 && (insn & 0xffe00000) == 0xe8000000)
1900 CHECK_FIELD_WHERE (distance - 8, 8388607, -8388608,
1901 fixP->fx_file, fixP->fx_line);
1903 CHECK_FIELD_WHERE (new_val - 8, 8388607, -8388608,
1904 fixP->fx_file, fixP->fx_line);
1907 insn = (insn & ~ 0x3ff1ffd) | re_assemble_22 (val >> 2);
1913 insn = (insn & ~ 0xfff1) | re_assemble_16 (val & -8);
1918 insn = (insn & ~ 0xfff9) | re_assemble_16 (val & -4);
1923 insn = (insn & ~ 0xffff) | re_assemble_16 (val);
1931 as_bad_where (fixP->fx_file, fixP->fx_line,
1932 _("Unknown relocation encountered in md_apply_fix."));
1937 switch (fixP->fx_r_type)
1939 case R_PARISC_TLS_GD21L:
1940 case R_PARISC_TLS_GD14R:
1941 case R_PARISC_TLS_LDM21L:
1942 case R_PARISC_TLS_LDM14R:
1943 case R_PARISC_TLS_LE21L:
1944 case R_PARISC_TLS_LE14R:
1945 case R_PARISC_TLS_IE21L:
1946 case R_PARISC_TLS_IE14R:
1948 S_SET_THREAD_LOCAL (fixP->fx_addsy);
1955 /* Insert the relocation. */
1956 bfd_put_32 (stdoutput, insn, fixpos);
1959 /* Exactly what point is a PC-relative offset relative TO?
1960 On the PA, they're relative to the address of the offset. */
1963 md_pcrel_from (fixS *fixP)
1965 return fixP->fx_where + fixP->fx_frag->fr_address;
1968 /* Return nonzero if the input line pointer is at the end of
1972 is_end_of_statement (void)
1974 return ((*input_line_pointer == '\n')
1975 || (*input_line_pointer == ';')
1976 || (*input_line_pointer == '!'));
1979 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
1981 /* Given NAME, find the register number associated with that name, return
1982 the integer value associated with the given name or -1 on failure. */
1985 reg_name_search (char *name)
1987 int middle, low, high;
1991 high = REG_NAME_CNT - 1;
1995 middle = (low + high) / 2;
1996 cmp = strcasecmp (name, pre_defined_registers[middle].name);
2002 return pre_defined_registers[middle].value;
2004 while (low <= high);
2009 /* Read a number from S. The number might come in one of many forms,
2010 the most common will be a hex or decimal constant, but it could be
2011 a pre-defined register (Yuk!), or an absolute symbol.
2013 Return 1 on success or 0 on failure. If STRICT, then a missing
2014 register prefix will cause a failure. The number itself is
2015 returned in `pa_number'.
2017 IS_FLOAT indicates that a PA-89 FP register number should be
2018 parsed; A `l' or `r' suffix is checked for if but 2 of IS_FLOAT is
2021 pa_parse_number can not handle negative constants and will fail
2022 horribly if it is passed such a constant. */
2025 pa_parse_number (char **s, int is_float)
2033 bfd_boolean have_prefix;
2035 /* Skip whitespace before the number. */
2036 while (*p == ' ' || *p == '\t')
2042 if (!strict && ISDIGIT (*p))
2044 /* Looks like a number. */
2046 if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
2048 /* The number is specified in hex. */
2050 while (ISDIGIT (*p) || ((*p >= 'a') && (*p <= 'f'))
2051 || ((*p >= 'A') && (*p <= 'F')))
2054 num = num * 16 + *p - '0';
2055 else if (*p >= 'a' && *p <= 'f')
2056 num = num * 16 + *p - 'a' + 10;
2058 num = num * 16 + *p - 'A' + 10;
2064 /* The number is specified in decimal. */
2065 while (ISDIGIT (*p))
2067 num = num * 10 + *p - '0';
2074 /* Check for a `l' or `r' suffix. */
2077 pa_number += FP_REG_BASE;
2078 if (! (is_float & 2))
2080 if (IS_R_SELECT (p))
2082 pa_number += FP_REG_RSEL;
2085 else if (IS_L_SELECT (p))
2094 /* The number might be a predefined register. */
2099 /* Tege hack: Special case for general registers as the general
2100 code makes a binary search with case translation, and is VERY
2105 if (*p == 'e' && *(p + 1) == 't'
2106 && (*(p + 2) == '0' || *(p + 2) == '1'))
2109 num = *p - '0' + 28;
2117 else if (!ISDIGIT (*p))
2120 as_bad (_("Undefined register: '%s'."), name);
2126 num = num * 10 + *p++ - '0';
2127 while (ISDIGIT (*p));
2132 /* Do a normal register search. */
2133 while (is_part_of_name (c))
2139 status = reg_name_search (name);
2145 as_bad (_("Undefined register: '%s'."), name);
2155 /* And finally, it could be a symbol in the absolute section which
2156 is effectively a constant, or a register alias symbol. */
2159 while (is_part_of_name (c))
2165 if ((sym = symbol_find (name)) != NULL)
2167 if (S_GET_SEGMENT (sym) == reg_section)
2169 num = S_GET_VALUE (sym);
2170 /* Well, we don't really have one, but we do have a
2174 else if (S_GET_SEGMENT (sym) == bfd_abs_section_ptr)
2175 num = S_GET_VALUE (sym);
2179 as_bad (_("Non-absolute symbol: '%s'."), name);
2185 /* There is where we'd come for an undefined symbol
2186 or for an empty string. For an empty string we
2187 will return zero. That's a concession made for
2188 compatibility with the braindamaged HP assemblers. */
2194 as_bad (_("Undefined absolute constant: '%s'."), name);
2203 if (!strict || have_prefix)
2211 /* Return nonzero if the given INSN and L/R information will require
2212 a new PA-1.1 opcode. */
2215 need_pa11_opcode (void)
2217 if ((pa_number & FP_REG_RSEL) != 0
2218 && !(the_insn.fpof1 == DBL && the_insn.fpof2 == DBL))
2220 /* If this instruction is specific to a particular architecture,
2221 then set a new architecture. */
2222 if (bfd_get_mach (stdoutput) < pa11)
2224 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, pa11))
2225 as_warn (_("could not update architecture and machine"));
2233 /* Parse a condition for a fcmp instruction. Return the numerical
2234 code associated with the condition. */
2237 pa_parse_fp_cmp_cond (char **s)
2243 for (i = 0; i < 32; i++)
2245 if (strncasecmp (*s, fp_cond_map[i].string,
2246 strlen (fp_cond_map[i].string)) == 0)
2248 cond = fp_cond_map[i].cond;
2249 *s += strlen (fp_cond_map[i].string);
2250 /* If not a complete match, back up the input string and
2252 if (**s != ' ' && **s != '\t')
2254 *s -= strlen (fp_cond_map[i].string);
2257 while (**s == ' ' || **s == '\t')
2263 as_bad (_("Invalid FP Compare Condition: %s"), *s);
2265 /* Advance over the bogus completer. */
2266 while (**s != ',' && **s != ' ' && **s != '\t')
2272 /* Parse a graphics test complete for ftest. */
2275 pa_parse_ftest_gfx_completer (char **s)
2280 if (strncasecmp (*s, "acc8", 4) == 0)
2285 else if (strncasecmp (*s, "acc6", 4) == 0)
2290 else if (strncasecmp (*s, "acc4", 4) == 0)
2295 else if (strncasecmp (*s, "acc2", 4) == 0)
2300 else if (strncasecmp (*s, "acc", 3) == 0)
2305 else if (strncasecmp (*s, "rej8", 4) == 0)
2310 else if (strncasecmp (*s, "rej", 3) == 0)
2318 as_bad (_("Invalid FTEST completer: %s"), *s);
2324 /* Parse an FP operand format completer returning the completer
2327 static fp_operand_format
2328 pa_parse_fp_cnv_format (char **s)
2336 if (strncasecmp (*s, "sgl", 3) == 0)
2341 else if (strncasecmp (*s, "dbl", 3) == 0)
2346 else if (strncasecmp (*s, "quad", 4) == 0)
2351 else if (strncasecmp (*s, "w", 1) == 0)
2356 else if (strncasecmp (*s, "uw", 2) == 0)
2361 else if (strncasecmp (*s, "dw", 2) == 0)
2366 else if (strncasecmp (*s, "udw", 3) == 0)
2371 else if (strncasecmp (*s, "qw", 2) == 0)
2376 else if (strncasecmp (*s, "uqw", 3) == 0)
2383 format = ILLEGAL_FMT;
2384 as_bad (_("Invalid FP Operand Format: %3s"), *s);
2391 /* Parse an FP operand format completer returning the completer
2394 static fp_operand_format
2395 pa_parse_fp_format (char **s)
2403 if (strncasecmp (*s, "sgl", 3) == 0)
2408 else if (strncasecmp (*s, "dbl", 3) == 0)
2413 else if (strncasecmp (*s, "quad", 4) == 0)
2420 format = ILLEGAL_FMT;
2421 as_bad (_("Invalid FP Operand Format: %3s"), *s);
2428 /* Convert from a selector string into a selector type. */
2431 pa_chk_field_selector (char **str)
2433 int middle, low, high;
2437 /* Read past any whitespace. */
2438 /* FIXME: should we read past newlines and formfeeds??? */
2439 while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
2442 if ((*str)[1] == '\'' || (*str)[1] == '%')
2443 name[0] = TOLOWER ((*str)[0]),
2445 else if ((*str)[2] == '\'' || (*str)[2] == '%')
2446 name[0] = TOLOWER ((*str)[0]),
2447 name[1] = TOLOWER ((*str)[1]),
2449 else if ((*str)[3] == '\'' || (*str)[3] == '%')
2450 name[0] = TOLOWER ((*str)[0]),
2451 name[1] = TOLOWER ((*str)[1]),
2452 name[2] = TOLOWER ((*str)[2]),
2458 high = sizeof (selector_table) / sizeof (struct selector_entry) - 1;
2462 middle = (low + high) / 2;
2463 cmp = strcmp (name, selector_table[middle].prefix);
2470 *str += strlen (name) + 1;
2472 if (selector_table[middle].field_selector == e_nsel)
2475 return selector_table[middle].field_selector;
2478 while (low <= high);
2483 /* Parse a .byte, .word, .long expression for the HPPA. Called by
2484 cons via the TC_PARSE_CONS_EXPRESSION macro. */
2487 parse_cons_expression_hppa (expressionS *exp)
2489 int hppa_field_selector = pa_chk_field_selector (&input_line_pointer);
2491 return hppa_field_selector;
2494 /* Evaluate an absolute expression EXP which may be modified by
2495 the selector FIELD_SELECTOR. Return the value of the expression. */
2497 evaluate_absolute (struct pa_it *insn)
2501 int field_selector = insn->field_selector;
2504 value = exp.X_add_number;
2506 return hppa_field_adjust (0, value, field_selector);
2509 /* Mark (via expr_end) the end of an absolute expression. FIXME. */
2512 pa_get_absolute_expression (struct pa_it *insn, char **strp)
2516 insn->field_selector = pa_chk_field_selector (strp);
2517 save_in = input_line_pointer;
2518 input_line_pointer = *strp;
2519 expression (&insn->exp);
2520 expr_end = input_line_pointer;
2521 input_line_pointer = save_in;
2522 if (insn->exp.X_op != O_constant)
2524 /* We have a non-match in strict mode. */
2526 as_bad (_("Bad segment (should be absolute)."));
2529 return evaluate_absolute (insn);
2532 /* Get an absolute number. The input string is terminated at the
2533 first whitespace character. */
2536 pa_get_number (struct pa_it *insn, char **strp)
2542 save_in = input_line_pointer;
2543 input_line_pointer = *strp;
2545 /* The PA assembly syntax is ambiguous in a variety of ways. Consider
2546 this string "4 %r5" Is that the number 4 followed by the register
2547 r5, or is that 4 MOD r5? This situation occurs for example in the
2548 coprocessor load and store instructions. Previously, calling
2549 pa_get_absolute_expression directly results in r5 being entered
2550 in the symbol table.
2552 So, when looking for an absolute number, we cut off the input string
2553 at the first whitespace character. Thus, expressions should generally
2554 contain no whitespace. */
2557 while (*s != ',' && *s != ' ' && *s != '\t')
2563 result = pa_get_absolute_expression (insn, strp);
2565 input_line_pointer = save_in;
2570 /* Given an argument location specification return the associated
2571 argument location number. */
2574 pa_build_arg_reloc (char *type_name)
2577 if (strncasecmp (type_name, "no", 2) == 0)
2579 if (strncasecmp (type_name, "gr", 2) == 0)
2581 else if (strncasecmp (type_name, "fr", 2) == 0)
2583 else if (strncasecmp (type_name, "fu", 2) == 0)
2586 as_bad (_("Invalid argument location: %s\n"), type_name);
2591 /* Encode and return an argument relocation specification for
2592 the given register in the location specified by arg_reloc. */
2595 pa_align_arg_reloc (unsigned int reg, unsigned int arg_reloc)
2597 unsigned int new_reloc;
2599 new_reloc = arg_reloc;
2615 as_bad (_("Invalid argument description: %d"), reg);
2621 /* Parse a non-negated compare/subtract completer returning the
2622 number (for encoding in instructions) of the given completer. */
2625 pa_parse_nonneg_cmpsub_cmpltr (char **s)
2628 char *name = *s + 1;
2637 while (**s != ',' && **s != ' ' && **s != '\t')
2642 if (strcmp (name, "=") == 0)
2646 else if (strcmp (name, "<") == 0)
2650 else if (strcmp (name, "<=") == 0)
2654 else if (strcmp (name, "<<") == 0)
2658 else if (strcmp (name, "<<=") == 0)
2662 else if (strcasecmp (name, "sv") == 0)
2666 else if (strcasecmp (name, "od") == 0)
2670 /* If we have something like addb,n then there is no condition
2672 else if (strcasecmp (name, "n") == 0)
2684 /* Reset pointers if this was really a ,n for a branch instruction. */
2691 /* Parse a negated compare/subtract completer returning the
2692 number (for encoding in instructions) of the given completer. */
2695 pa_parse_neg_cmpsub_cmpltr (char **s)
2698 char *name = *s + 1;
2707 while (**s != ',' && **s != ' ' && **s != '\t')
2712 if (strcasecmp (name, "tr") == 0)
2716 else if (strcmp (name, "<>") == 0)
2720 else if (strcmp (name, ">=") == 0)
2724 else if (strcmp (name, ">") == 0)
2728 else if (strcmp (name, ">>=") == 0)
2732 else if (strcmp (name, ">>") == 0)
2736 else if (strcasecmp (name, "nsv") == 0)
2740 else if (strcasecmp (name, "ev") == 0)
2744 /* If we have something like addb,n then there is no condition
2746 else if (strcasecmp (name, "n") == 0)
2758 /* Reset pointers if this was really a ,n for a branch instruction. */
2765 /* Parse a 64 bit compare and branch completer returning the number (for
2766 encoding in instructions) of the given completer.
2768 Nonnegated comparisons are returned as 0-7, negated comparisons are
2769 returned as 8-15. */
2772 pa_parse_cmpb_64_cmpltr (char **s)
2775 char *name = *s + 1;
2782 while (**s != ',' && **s != ' ' && **s != '\t')
2787 if (strcmp (name, "*") == 0)
2791 else if (strcmp (name, "*=") == 0)
2795 else if (strcmp (name, "*<") == 0)
2799 else if (strcmp (name, "*<=") == 0)
2803 else if (strcmp (name, "*<<") == 0)
2807 else if (strcmp (name, "*<<=") == 0)
2811 else if (strcasecmp (name, "*sv") == 0)
2815 else if (strcasecmp (name, "*od") == 0)
2819 else if (strcasecmp (name, "*tr") == 0)
2823 else if (strcmp (name, "*<>") == 0)
2827 else if (strcmp (name, "*>=") == 0)
2831 else if (strcmp (name, "*>") == 0)
2835 else if (strcmp (name, "*>>=") == 0)
2839 else if (strcmp (name, "*>>") == 0)
2843 else if (strcasecmp (name, "*nsv") == 0)
2847 else if (strcasecmp (name, "*ev") == 0)
2861 /* Parse a 64 bit compare immediate and branch completer returning the number
2862 (for encoding in instructions) of the given completer. */
2865 pa_parse_cmpib_64_cmpltr (char **s)
2868 char *name = *s + 1;
2875 while (**s != ',' && **s != ' ' && **s != '\t')
2880 if (strcmp (name, "*<<") == 0)
2884 else if (strcmp (name, "*=") == 0)
2888 else if (strcmp (name, "*<") == 0)
2892 else if (strcmp (name, "*<=") == 0)
2896 else if (strcmp (name, "*>>=") == 0)
2900 else if (strcmp (name, "*<>") == 0)
2904 else if (strcasecmp (name, "*>=") == 0)
2908 else if (strcasecmp (name, "*>") == 0)
2922 /* Parse a non-negated addition completer returning the number
2923 (for encoding in instructions) of the given completer. */
2926 pa_parse_nonneg_add_cmpltr (char **s)
2929 char *name = *s + 1;
2938 while (**s != ',' && **s != ' ' && **s != '\t')
2942 if (strcmp (name, "=") == 0)
2946 else if (strcmp (name, "<") == 0)
2950 else if (strcmp (name, "<=") == 0)
2954 else if (strcasecmp (name, "nuv") == 0)
2958 else if (strcasecmp (name, "znv") == 0)
2962 else if (strcasecmp (name, "sv") == 0)
2966 else if (strcasecmp (name, "od") == 0)
2970 /* If we have something like addb,n then there is no condition
2972 else if (strcasecmp (name, "n") == 0)
2984 /* Reset pointers if this was really a ,n for a branch instruction. */
2991 /* Parse a negated addition completer returning the number
2992 (for encoding in instructions) of the given completer. */
2995 pa_parse_neg_add_cmpltr (char **s)
2998 char *name = *s + 1;
3007 while (**s != ',' && **s != ' ' && **s != '\t')
3011 if (strcasecmp (name, "tr") == 0)
3015 else if (strcmp (name, "<>") == 0)
3019 else if (strcmp (name, ">=") == 0)
3023 else if (strcmp (name, ">") == 0)
3027 else if (strcasecmp (name, "uv") == 0)
3031 else if (strcasecmp (name, "vnz") == 0)
3035 else if (strcasecmp (name, "nsv") == 0)
3039 else if (strcasecmp (name, "ev") == 0)
3043 /* If we have something like addb,n then there is no condition
3045 else if (strcasecmp (name, "n") == 0)
3057 /* Reset pointers if this was really a ,n for a branch instruction. */
3064 /* Parse a 64 bit wide mode add and branch completer returning the number (for
3065 encoding in instructions) of the given completer. */
3068 pa_parse_addb_64_cmpltr (char **s)
3071 char *name = *s + 1;
3080 while (**s != ',' && **s != ' ' && **s != '\t')
3084 if (strcmp (name, "=") == 0)
3088 else if (strcmp (name, "<") == 0)
3092 else if (strcmp (name, "<=") == 0)
3096 else if (strcasecmp (name, "nuv") == 0)
3100 else if (strcasecmp (name, "*=") == 0)
3104 else if (strcasecmp (name, "*<") == 0)
3108 else if (strcasecmp (name, "*<=") == 0)
3112 else if (strcmp (name, "tr") == 0)
3116 else if (strcmp (name, "<>") == 0)
3120 else if (strcmp (name, ">=") == 0)
3124 else if (strcmp (name, ">") == 0)
3128 else if (strcasecmp (name, "uv") == 0)
3132 else if (strcasecmp (name, "*<>") == 0)
3136 else if (strcasecmp (name, "*>=") == 0)
3140 else if (strcasecmp (name, "*>") == 0)
3144 /* If we have something like addb,n then there is no condition
3146 else if (strcasecmp (name, "n") == 0)
3158 /* Reset pointers if this was really a ,n for a branch instruction. */
3165 /* Do the real work for assembling a single instruction. Store results
3166 into the global "the_insn" variable. */
3171 const char *error_message = "";
3172 char *s, c, *argstart, *name, *save_s;
3176 int cmpltr, nullif, flag, cond, need_cond, num;
3177 int immediate_check = 0, pos = -1, len = -1;
3178 unsigned long opcode;
3179 struct pa_opcode *insn;
3182 /* We must have a valid space and subspace. */
3183 pa_check_current_space_and_subspace ();
3186 /* Convert everything up to the first whitespace character into lower
3188 for (s = str; *s != ' ' && *s != '\t' && *s != '\n' && *s != '\0'; s++)
3191 /* Skip to something interesting. */
3193 ISUPPER (*s) || ISLOWER (*s) || (*s >= '0' && *s <= '3');
3213 as_bad (_("Unknown opcode: `%s'"), str);
3217 /* Look up the opcode in the hash table. */
3218 if ((insn = (struct pa_opcode *) hash_find (op_hash, str)) == NULL)
3220 as_bad (_("Unknown opcode: `%s'"), str);
3227 /* Mark the location where arguments for the instruction start, then
3228 start processing them. */
3232 /* Do some initialization. */
3233 opcode = insn->match;
3234 strict = (insn->flags & FLAG_STRICT);
3235 memset (&the_insn, 0, sizeof (the_insn));
3238 the_insn.reloc = R_HPPA_NONE;
3240 if (insn->arch >= pa20
3241 && bfd_get_mach (stdoutput) < insn->arch)
3244 /* Build the opcode, checking as we go to make
3245 sure that the operands match. */
3246 for (args = insn->args;; ++args)
3248 /* Absorb white space in instruction. */
3249 while (*s == ' ' || *s == '\t')
3254 /* End of arguments. */
3270 /* These must match exactly. */
3279 /* Handle a 5 bit register or control register field at 10. */
3282 if (!pa_parse_number (&s, 0))
3285 CHECK_FIELD (num, 31, 0, 0);
3286 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3288 /* Handle %sar or %cr11. No bits get set, we just verify that it
3291 /* Skip whitespace before register. */
3292 while (*s == ' ' || *s == '\t')
3295 if (!strncasecmp (s, "%sar", 4))
3300 else if (!strncasecmp (s, "%cr11", 5))
3307 /* Handle a 5 bit register field at 15. */
3309 if (!pa_parse_number (&s, 0))
3312 CHECK_FIELD (num, 31, 0, 0);
3313 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3315 /* Handle a 5 bit register field at 31. */
3317 if (!pa_parse_number (&s, 0))
3320 CHECK_FIELD (num, 31, 0, 0);
3321 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3323 /* Handle a 5 bit register field at 10 and 15. */
3325 if (!pa_parse_number (&s, 0))
3328 CHECK_FIELD (num, 31, 0, 0);
3329 opcode |= num << 16;
3330 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3332 /* Handle a 5 bit field length at 31. */
3334 num = pa_get_absolute_expression (&the_insn, &s);
3335 if (strict && the_insn.exp.X_op != O_constant)
3338 CHECK_FIELD (num, 32, 1, 0);
3339 SAVE_IMMEDIATE(num);
3340 INSERT_FIELD_AND_CONTINUE (opcode, 32 - num, 0);
3342 /* Handle a 5 bit immediate at 15. */
3344 num = pa_get_absolute_expression (&the_insn, &s);
3345 if (strict && the_insn.exp.X_op != O_constant)
3348 /* When in strict mode, we want to just reject this
3349 match instead of giving an out of range error. */
3350 CHECK_FIELD (num, 15, -16, strict);
3351 num = low_sign_unext (num, 5);
3352 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3354 /* Handle a 5 bit immediate at 31. */
3356 num = pa_get_absolute_expression (&the_insn, &s);
3357 if (strict && the_insn.exp.X_op != O_constant)
3360 /* When in strict mode, we want to just reject this
3361 match instead of giving an out of range error. */
3362 CHECK_FIELD (num, 15, -16, strict);
3363 num = low_sign_unext (num, 5);
3364 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3366 /* Handle an unsigned 5 bit immediate at 31. */
3368 num = pa_get_absolute_expression (&the_insn, &s);
3369 if (strict && the_insn.exp.X_op != O_constant)
3372 CHECK_FIELD (num, 31, 0, strict);
3373 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3375 /* Handle an unsigned 5 bit immediate at 15. */
3377 num = pa_get_absolute_expression (&the_insn, &s);
3378 if (strict && the_insn.exp.X_op != O_constant)
3381 CHECK_FIELD (num, 31, 0, strict);
3382 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3384 /* Handle an unsigned 10 bit immediate at 15. */
3386 num = pa_get_absolute_expression (&the_insn, &s);
3387 if (strict && the_insn.exp.X_op != O_constant)
3390 CHECK_FIELD (num, 1023, 0, strict);
3391 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3393 /* Handle a 2 bit space identifier at 17. */
3395 if (!pa_parse_number (&s, 0))
3398 CHECK_FIELD (num, 3, 0, 1);
3399 INSERT_FIELD_AND_CONTINUE (opcode, num, 14);
3401 /* Handle a 3 bit space identifier at 18. */
3403 if (!pa_parse_number (&s, 0))
3406 CHECK_FIELD (num, 7, 0, 1);
3407 opcode |= re_assemble_3 (num);
3410 /* Handle all completers. */
3415 /* Handle a completer for an indexing load or store. */
3422 while (*s == ',' && i < 2)
3425 if (strncasecmp (s, "sm", 2) == 0)
3432 else if (strncasecmp (s, "m", 1) == 0)
3434 else if ((strncasecmp (s, "s ", 2) == 0)
3435 || (strncasecmp (s, "s,", 2) == 0))
3439 /* This is a match failure. */
3444 as_bad (_("Invalid Indexed Load Completer."));
3449 as_bad (_("Invalid Indexed Load Completer Syntax."));
3451 INSERT_FIELD_AND_CONTINUE (opcode, uu, 13);
3454 /* Handle a short load/store completer. */
3466 if (strncasecmp (s, "ma", 2) == 0)
3472 else if (strncasecmp (s, "mb", 2) == 0)
3479 /* This is a match failure. */
3483 as_bad (_("Invalid Short Load/Store Completer."));
3487 /* If we did not get a ma/mb completer, then we do not
3488 consider this a positive match for 'ce'. */
3489 else if (*args == 'e')
3492 /* 'J', 'm', 'M' and 'q' are the same, except for where they
3493 encode the before/after field. */
3494 if (*args == 'm' || *args == 'M')
3497 INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
3499 else if (*args == 'q')
3502 INSERT_FIELD_AND_CONTINUE (opcode, a, 2);
3504 else if (*args == 'J')
3506 /* M bit is explicit in the major opcode. */
3507 INSERT_FIELD_AND_CONTINUE (opcode, a, 2);
3511 gas_assert (*args == 'e');
3512 /* Stash the ma/mb flag temporarily in the
3513 instruction. We will use (and remove it)
3514 later when handling 'J', 'K', '<' & '>'. */
3520 /* Handle a stbys completer. */
3527 while (*s == ',' && i < 2)
3530 if (strncasecmp (s, "m", 1) == 0)
3532 else if ((strncasecmp (s, "b ", 2) == 0)
3533 || (strncasecmp (s, "b,", 2) == 0))
3535 else if (strncasecmp (s, "e", 1) == 0)
3537 /* In strict mode, this is a match failure. */
3544 as_bad (_("Invalid Store Bytes Short Completer"));
3549 as_bad (_("Invalid Store Bytes Short Completer"));
3551 INSERT_FIELD_AND_CONTINUE (opcode, a, 13);
3554 /* Handle load cache hint completer. */
3557 if (!strncmp (s, ",sl", 3))
3562 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3564 /* Handle store cache hint completer. */
3567 if (!strncmp (s, ",sl", 3))
3572 else if (!strncmp (s, ",bc", 3))
3577 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3579 /* Handle load and clear cache hint completer. */
3582 if (!strncmp (s, ",co", 3))
3587 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 10);
3589 /* Handle load ordering completer. */
3591 if (strncmp (s, ",o", 2) != 0)
3596 /* Handle a branch gate completer. */
3598 if (strncasecmp (s, ",gate", 5) != 0)
3603 /* Handle a branch link and push completer. */
3605 if (strncasecmp (s, ",l,push", 7) != 0)
3610 /* Handle a branch link completer. */
3612 if (strncasecmp (s, ",l", 2) != 0)
3617 /* Handle a branch pop completer. */
3619 if (strncasecmp (s, ",pop", 4) != 0)
3624 /* Handle a local processor completer. */
3626 if (strncasecmp (s, ",l", 2) != 0)
3631 /* Handle a PROBE read/write completer. */
3634 if (!strncasecmp (s, ",w", 2))
3639 else if (!strncasecmp (s, ",r", 2))
3645 INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3647 /* Handle MFCTL wide completer. */
3649 if (strncasecmp (s, ",w", 2) != 0)
3654 /* Handle an RFI restore completer. */
3657 if (!strncasecmp (s, ",r", 2))
3663 INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
3665 /* Handle a system control completer. */
3667 if (*s == ',' && (*(s + 1) == 'm' || *(s + 1) == 'M'))
3675 INSERT_FIELD_AND_CONTINUE (opcode, flag, 5);
3677 /* Handle intermediate/final completer for DCOR. */
3680 if (!strncasecmp (s, ",i", 2))
3686 INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3688 /* Handle zero/sign extension completer. */
3691 if (!strncasecmp (s, ",z", 2))
3697 INSERT_FIELD_AND_CONTINUE (opcode, flag, 10);
3699 /* Handle add completer. */
3702 if (!strncasecmp (s, ",l", 2))
3707 else if (!strncasecmp (s, ",tsv", 4))
3713 INSERT_FIELD_AND_CONTINUE (opcode, flag, 10);
3715 /* Handle 64 bit carry for ADD. */
3718 if (!strncasecmp (s, ",dc,tsv", 7) ||
3719 !strncasecmp (s, ",tsv,dc", 7))
3724 else if (!strncasecmp (s, ",dc", 3))
3732 /* Condition is not required with "dc". */
3734 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3736 /* Handle 32 bit carry for ADD. */
3739 if (!strncasecmp (s, ",c,tsv", 6) ||
3740 !strncasecmp (s, ",tsv,c", 6))
3745 else if (!strncasecmp (s, ",c", 2))
3753 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3755 /* Handle trap on signed overflow. */
3758 if (!strncasecmp (s, ",tsv", 4))
3764 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3766 /* Handle trap on condition and overflow. */
3769 if (!strncasecmp (s, ",tc,tsv", 7) ||
3770 !strncasecmp (s, ",tsv,tc", 7))
3775 else if (!strncasecmp (s, ",tc", 3))
3783 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3785 /* Handle 64 bit borrow for SUB. */
3788 if (!strncasecmp (s, ",db,tsv", 7) ||
3789 !strncasecmp (s, ",tsv,db", 7))
3794 else if (!strncasecmp (s, ",db", 3))
3802 /* Condition is not required with "db". */
3804 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3806 /* Handle 32 bit borrow for SUB. */
3809 if (!strncasecmp (s, ",b,tsv", 6) ||
3810 !strncasecmp (s, ",tsv,b", 6))
3815 else if (!strncasecmp (s, ",b", 2))
3823 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3825 /* Handle trap condition completer for UADDCM. */
3828 if (!strncasecmp (s, ",tc", 3))
3834 INSERT_FIELD_AND_CONTINUE (opcode, flag, 6);
3836 /* Handle signed/unsigned at 21. */
3840 if (strncasecmp (s, ",s", 2) == 0)
3845 else if (strncasecmp (s, ",u", 2) == 0)
3851 INSERT_FIELD_AND_CONTINUE (opcode, sign, 10);
3854 /* Handle left/right combination at 17:18. */
3864 as_bad (_("Invalid left/right combination completer"));
3867 INSERT_FIELD_AND_CONTINUE (opcode, lr, 13);
3870 as_bad (_("Invalid left/right combination completer"));
3873 /* Handle saturation at 24:25. */
3877 if (strncasecmp (s, ",ss", 3) == 0)
3882 else if (strncasecmp (s, ",us", 3) == 0)
3888 INSERT_FIELD_AND_CONTINUE (opcode, sat, 6);
3891 /* Handle permutation completer. */
3919 as_bad (_("Invalid permutation completer"));
3921 opcode |= perm << permloc[i];
3926 as_bad (_("Invalid permutation completer"));
3934 /* Handle all conditions. */
3940 /* Handle FP compare conditions. */
3942 cond = pa_parse_fp_cmp_cond (&s);
3943 INSERT_FIELD_AND_CONTINUE (opcode, cond, 0);
3945 /* Handle an add condition. */
3954 /* 64 bit conditions. */
3966 while (*s != ',' && *s != ' ' && *s != '\t')
3970 if (strcmp (name, "=") == 0)
3972 else if (strcmp (name, "<") == 0)
3974 else if (strcmp (name, "<=") == 0)
3976 else if (strcasecmp (name, "nuv") == 0)
3978 else if (strcasecmp (name, "znv") == 0)
3980 else if (strcasecmp (name, "sv") == 0)
3982 else if (strcasecmp (name, "od") == 0)
3984 else if (strcasecmp (name, "tr") == 0)
3989 else if (strcmp (name, "<>") == 0)
3994 else if (strcmp (name, ">=") == 0)
3999 else if (strcmp (name, ">") == 0)
4004 else if (strcasecmp (name, "uv") == 0)
4009 else if (strcasecmp (name, "vnz") == 0)
4014 else if (strcasecmp (name, "nsv") == 0)
4019 else if (strcasecmp (name, "ev") == 0)
4024 /* ",*" is a valid condition. */
4025 else if (*args == 'a' || *name)
4026 as_bad (_("Invalid Add Condition: %s"), name);
4029 /* Except with "dc", we have a match failure with
4030 'A' if we don't have a doubleword condition. */
4031 else if (*args == 'A' && need_cond)
4034 opcode |= cmpltr << 13;
4035 INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4037 /* Handle non-negated add and branch condition. */
4039 cmpltr = pa_parse_nonneg_add_cmpltr (&s);
4042 as_bad (_("Invalid Add and Branch Condition"));
4045 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4047 /* Handle 64 bit wide-mode add and branch condition. */
4049 cmpltr = pa_parse_addb_64_cmpltr (&s);
4052 as_bad (_("Invalid Add and Branch Condition"));
4057 /* Negated condition requires an opcode change. */
4058 opcode |= (cmpltr & 8) << 24;
4060 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr & 7, 13);
4062 /* Handle a negated or non-negated add and branch
4066 cmpltr = pa_parse_nonneg_add_cmpltr (&s);
4070 cmpltr = pa_parse_neg_add_cmpltr (&s);
4073 as_bad (_("Invalid Compare/Subtract Condition"));
4078 /* Negated condition requires an opcode change. */
4082 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4084 /* Handle branch on bit conditions. */
4102 if (strncmp (s, "<", 1) == 0)
4107 else if (strncmp (s, ">=", 2) == 0)
4113 as_bad (_("Invalid Branch On Bit Condition: %c"), *s);
4116 as_bad (_("Missing Branch On Bit Condition"));
4118 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 15);
4120 /* Handle a compare/subtract condition. */
4129 /* 64 bit conditions. */
4141 while (*s != ',' && *s != ' ' && *s != '\t')
4145 if (strcmp (name, "=") == 0)
4147 else if (strcmp (name, "<") == 0)
4149 else if (strcmp (name, "<=") == 0)
4151 else if (strcasecmp (name, "<<") == 0)
4153 else if (strcasecmp (name, "<<=") == 0)
4155 else if (strcasecmp (name, "sv") == 0)
4157 else if (strcasecmp (name, "od") == 0)
4159 else if (strcasecmp (name, "tr") == 0)
4164 else if (strcmp (name, "<>") == 0)
4169 else if (strcmp (name, ">=") == 0)
4174 else if (strcmp (name, ">") == 0)
4179 else if (strcasecmp (name, ">>=") == 0)
4184 else if (strcasecmp (name, ">>") == 0)
4189 else if (strcasecmp (name, "nsv") == 0)
4194 else if (strcasecmp (name, "ev") == 0)
4199 /* ",*" is a valid condition. */
4200 else if (*args != 'S' || *name)
4201 as_bad (_("Invalid Compare/Subtract Condition: %s"),
4205 /* Except with "db", we have a match failure with
4206 'S' if we don't have a doubleword condition. */
4207 else if (*args == 'S' && need_cond)
4210 opcode |= cmpltr << 13;
4211 INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4213 /* Handle a non-negated compare condition. */
4215 cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s);
4218 as_bad (_("Invalid Compare/Subtract Condition"));
4221 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4223 /* Handle a 32 bit compare and branch condition. */
4226 cmpltr = pa_parse_nonneg_cmpsub_cmpltr (&s);
4230 cmpltr = pa_parse_neg_cmpsub_cmpltr (&s);
4233 as_bad (_("Invalid Compare and Branch Condition"));
4238 /* Negated condition requires an opcode change. */
4243 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4245 /* Handle a 64 bit compare and branch condition. */
4247 cmpltr = pa_parse_cmpb_64_cmpltr (&s);
4250 /* Negated condition requires an opcode change. */
4251 opcode |= (cmpltr & 8) << 26;
4254 /* Not a 64 bit cond. Give 32 bit a chance. */
4257 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr & 7, 13);
4259 /* Handle a 64 bit cmpib condition. */
4261 cmpltr = pa_parse_cmpib_64_cmpltr (&s);
4263 /* Not a 64 bit cond. Give 32 bit a chance. */
4266 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4268 /* Handle a logical instruction condition. */
4277 /* 64 bit conditions. */
4289 while (*s != ',' && *s != ' ' && *s != '\t')
4294 if (strcmp (name, "=") == 0)
4296 else if (strcmp (name, "<") == 0)
4298 else if (strcmp (name, "<=") == 0)
4300 else if (strcasecmp (name, "od") == 0)
4302 else if (strcasecmp (name, "tr") == 0)
4307 else if (strcmp (name, "<>") == 0)
4312 else if (strcmp (name, ">=") == 0)
4317 else if (strcmp (name, ">") == 0)
4322 else if (strcasecmp (name, "ev") == 0)
4327 /* ",*" is a valid condition. */
4328 else if (*args != 'L' || *name)
4329 as_bad (_("Invalid Logical Instruction Condition."));
4332 /* 32-bit is default for no condition. */
4333 else if (*args == 'L')
4336 opcode |= cmpltr << 13;
4337 INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4339 /* Handle a shift/extract/deposit condition. */
4344 /* Check immediate values in shift/extract/deposit
4345 * instructions if they will give undefined behaviour. */
4346 immediate_check = 1;
4351 /* 64 bit conditions. */
4363 while (*s != ',' && *s != ' ' && *s != '\t')
4367 if (strcmp (name, "=") == 0)
4369 else if (strcmp (name, "<") == 0)
4371 else if (strcasecmp (name, "od") == 0)
4373 else if (strcasecmp (name, "tr") == 0)
4375 else if (strcmp (name, "<>") == 0)
4377 else if (strcmp (name, ">=") == 0)
4379 else if (strcasecmp (name, "ev") == 0)
4381 /* Handle movb,n. Put things back the way they were.
4382 This includes moving s back to where it started. */
4383 else if (strcasecmp (name, "n") == 0 && *args == 'y')
4389 /* ",*" is a valid condition. */
4390 else if (*args != 'X' || *name)
4391 as_bad (_("Invalid Shift/Extract/Deposit Condition."));
4395 INSERT_FIELD_AND_CONTINUE (opcode, cmpltr, 13);
4397 /* Handle a unit instruction condition. */
4407 /* 64 bit conditions. */
4418 /* The uxor instruction only supports unit conditions
4419 not involving carries. */
4420 uxor = (opcode & 0xfc000fc0) == 0x08000380;
4421 if (strncasecmp (s, "sbz", 3) == 0)
4426 else if (strncasecmp (s, "shz", 3) == 0)
4431 else if (!uxor && strncasecmp (s, "sdc", 3) == 0)
4436 else if (!uxor && strncasecmp (s, "sbc", 3) == 0)
4441 else if (!uxor && strncasecmp (s, "shc", 3) == 0)
4446 else if (strncasecmp (s, "tr", 2) == 0)
4452 else if (strncasecmp (s, "nbz", 3) == 0)
4458 else if (strncasecmp (s, "nhz", 3) == 0)
4464 else if (!uxor && strncasecmp (s, "ndc", 3) == 0)
4470 else if (!uxor && strncasecmp (s, "nbc", 3) == 0)
4476 else if (!uxor && strncasecmp (s, "nhc", 3) == 0)
4482 else if (strncasecmp (s, "swz", 3) == 0)
4488 else if (!uxor && strncasecmp (s, "swc", 3) == 0)
4494 else if (strncasecmp (s, "nwz", 3) == 0)
4500 else if (!uxor && strncasecmp (s, "nwc", 3) == 0)
4506 /* ",*" is a valid condition. */
4507 else if (*args != 'U' || (*s != ' ' && *s != '\t'))
4508 as_bad (_("Invalid Unit Instruction Condition."));
4510 /* 32-bit is default for no condition. */
4511 else if (*args == 'U')
4514 opcode |= cmpltr << 13;
4515 INSERT_FIELD_AND_CONTINUE (opcode, flag, 12);
4523 /* Handle a nullification completer for branch instructions. */
4525 nullif = pa_parse_nullif (&s);
4526 INSERT_FIELD_AND_CONTINUE (opcode, nullif, 1);
4528 /* Handle a nullification completer for copr and spop insns. */
4530 nullif = pa_parse_nullif (&s);
4531 INSERT_FIELD_AND_CONTINUE (opcode, nullif, 5);
4533 /* Handle ,%r2 completer for new syntax branches. */
4535 if (*s == ',' && strncasecmp (s + 1, "%r2", 3) == 0)
4537 else if (*s == ',' && strncasecmp (s + 1, "%rp", 3) == 0)
4543 /* Handle 3 bit entry into the fp compare array. Valid values
4544 are 0..6 inclusive. */
4548 if (the_insn.exp.X_op == O_constant)
4550 num = evaluate_absolute (&the_insn);
4551 CHECK_FIELD (num, 6, 0, 0);
4553 INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
4558 /* Handle 3 bit entry into the fp compare array. Valid values
4559 are 0..6 inclusive. */
4562 if (the_insn.exp.X_op == O_constant)
4565 num = evaluate_absolute (&the_insn);
4566 CHECK_FIELD (num, 6, 0, 0);
4567 num = (num + 1) ^ 1;
4568 INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
4573 /* Handle graphics test completers for ftest */
4576 num = pa_parse_ftest_gfx_completer (&s);
4577 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4580 /* Handle a 11 bit immediate at 31. */
4582 the_insn.field_selector = pa_chk_field_selector (&s);
4585 if (the_insn.exp.X_op == O_constant)
4587 num = evaluate_absolute (&the_insn);
4588 CHECK_FIELD (num, 1023, -1024, 0);
4589 num = low_sign_unext (num, 11);
4590 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4594 if (is_DP_relative (the_insn.exp))
4595 the_insn.reloc = R_HPPA_GOTOFF;
4596 else if (is_PC_relative (the_insn.exp))
4597 the_insn.reloc = R_HPPA_PCREL_CALL;
4599 else if (is_tls_gdidx (the_insn.exp))
4600 the_insn.reloc = R_PARISC_TLS_GD21L;
4601 else if (is_tls_ldidx (the_insn.exp))
4602 the_insn.reloc = R_PARISC_TLS_LDM21L;
4603 else if (is_tls_dtpoff (the_insn.exp))
4604 the_insn.reloc = R_PARISC_TLS_LDO21L;
4605 else if (is_tls_ieoff (the_insn.exp))
4606 the_insn.reloc = R_PARISC_TLS_IE21L;
4607 else if (is_tls_leoff (the_insn.exp))
4608 the_insn.reloc = R_PARISC_TLS_LE21L;
4611 the_insn.reloc = R_HPPA;
4612 the_insn.format = 11;
4616 /* Handle a 14 bit immediate at 31. */
4618 the_insn.field_selector = pa_chk_field_selector (&s);
4621 if (the_insn.exp.X_op == O_constant)
4625 /* XXX the completer stored away tidbits of information
4626 for us to extract. We need a cleaner way to do this.
4627 Now that we have lots of letters again, it would be
4628 good to rethink this. */
4631 num = evaluate_absolute (&the_insn);
4632 if (mb != (num < 0))
4634 CHECK_FIELD (num, 8191, -8192, 0);
4635 num = low_sign_unext (num, 14);
4636 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4640 /* Handle a 14 bit immediate at 31. */
4642 the_insn.field_selector = pa_chk_field_selector (&s);
4645 if (the_insn.exp.X_op == O_constant)
4651 num = evaluate_absolute (&the_insn);
4652 if (mb == (num < 0))
4656 CHECK_FIELD (num, 8191, -8192, 0);
4657 num = low_sign_unext (num, 14);
4658 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4662 /* Handle a 16 bit immediate at 31. */
4664 the_insn.field_selector = pa_chk_field_selector (&s);
4667 if (the_insn.exp.X_op == O_constant)
4673 num = evaluate_absolute (&the_insn);
4674 if (mb != (num < 0))
4676 CHECK_FIELD (num, 32767, -32768, 0);
4677 num = re_assemble_16 (num);
4678 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4682 /* Handle a 16 bit immediate at 31. */
4684 the_insn.field_selector = pa_chk_field_selector (&s);
4687 if (the_insn.exp.X_op == O_constant)
4693 num = evaluate_absolute (&the_insn);
4694 if (mb == (num < 0))
4698 CHECK_FIELD (num, 32767, -32768, 0);
4699 num = re_assemble_16 (num);
4700 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4704 /* Handle 14 bit immediate, shifted left three times. */
4706 if (bfd_get_mach (stdoutput) != pa20)
4708 the_insn.field_selector = pa_chk_field_selector (&s);
4711 if (the_insn.exp.X_op == O_constant)
4713 num = evaluate_absolute (&the_insn);
4716 CHECK_FIELD (num, 8191, -8192, 0);
4721 INSERT_FIELD_AND_CONTINUE (opcode, num, 4);
4725 if (is_DP_relative (the_insn.exp))
4726 the_insn.reloc = R_HPPA_GOTOFF;
4727 else if (is_PC_relative (the_insn.exp))
4728 the_insn.reloc = R_HPPA_PCREL_CALL;
4730 else if (is_tls_gdidx (the_insn.exp))
4731 the_insn.reloc = R_PARISC_TLS_GD21L;
4732 else if (is_tls_ldidx (the_insn.exp))
4733 the_insn.reloc = R_PARISC_TLS_LDM21L;
4734 else if (is_tls_dtpoff (the_insn.exp))
4735 the_insn.reloc = R_PARISC_TLS_LDO21L;
4736 else if (is_tls_ieoff (the_insn.exp))
4737 the_insn.reloc = R_PARISC_TLS_IE21L;
4738 else if (is_tls_leoff (the_insn.exp))
4739 the_insn.reloc = R_PARISC_TLS_LE21L;
4742 the_insn.reloc = R_HPPA;
4743 the_insn.format = 14;
4748 /* Handle 14 bit immediate, shifted left twice. */
4750 the_insn.field_selector = pa_chk_field_selector (&s);
4753 if (the_insn.exp.X_op == O_constant)
4755 num = evaluate_absolute (&the_insn);
4758 CHECK_FIELD (num, 8191, -8192, 0);
4763 INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
4767 if (is_DP_relative (the_insn.exp))
4768 the_insn.reloc = R_HPPA_GOTOFF;
4769 else if (is_PC_relative (the_insn.exp))
4770 the_insn.reloc = R_HPPA_PCREL_CALL;
4772 else if (is_tls_gdidx (the_insn.exp))
4773 the_insn.reloc = R_PARISC_TLS_GD21L;
4774 else if (is_tls_ldidx (the_insn.exp))
4775 the_insn.reloc = R_PARISC_TLS_LDM21L;
4776 else if (is_tls_dtpoff (the_insn.exp))
4777 the_insn.reloc = R_PARISC_TLS_LDO21L;
4778 else if (is_tls_ieoff (the_insn.exp))
4779 the_insn.reloc = R_PARISC_TLS_IE21L;
4780 else if (is_tls_leoff (the_insn.exp))
4781 the_insn.reloc = R_PARISC_TLS_LE21L;
4784 the_insn.reloc = R_HPPA;
4785 the_insn.format = 14;
4789 /* Handle a 14 bit immediate at 31. */
4791 the_insn.field_selector = pa_chk_field_selector (&s);
4794 if (the_insn.exp.X_op == O_constant)
4796 num = evaluate_absolute (&the_insn);
4797 CHECK_FIELD (num, 8191, -8192, 0);
4798 num = low_sign_unext (num, 14);
4799 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
4803 if (is_DP_relative (the_insn.exp))
4804 the_insn.reloc = R_HPPA_GOTOFF;
4805 else if (is_PC_relative (the_insn.exp))
4806 the_insn.reloc = R_HPPA_PCREL_CALL;
4808 else if (is_tls_gdidx (the_insn.exp))
4809 the_insn.reloc = R_PARISC_TLS_GD21L;
4810 else if (is_tls_ldidx (the_insn.exp))
4811 the_insn.reloc = R_PARISC_TLS_LDM21L;
4812 else if (is_tls_dtpoff (the_insn.exp))
4813 the_insn.reloc = R_PARISC_TLS_LDO21L;
4814 else if (is_tls_ieoff (the_insn.exp))
4815 the_insn.reloc = R_PARISC_TLS_IE21L;
4816 else if (is_tls_leoff (the_insn.exp))
4817 the_insn.reloc = R_PARISC_TLS_LE21L;
4820 the_insn.reloc = R_HPPA;
4821 the_insn.format = 14;
4825 /* Handle a 21 bit immediate at 31. */
4827 the_insn.field_selector = pa_chk_field_selector (&s);
4830 if (the_insn.exp.X_op == O_constant)
4832 num = evaluate_absolute (&the_insn);
4833 CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
4834 opcode |= re_assemble_21 (num);
4839 if (is_DP_relative (the_insn.exp))
4840 the_insn.reloc = R_HPPA_GOTOFF;
4841 else if (is_PC_relative (the_insn.exp))
4842 the_insn.reloc = R_HPPA_PCREL_CALL;
4844 else if (is_tls_gdidx (the_insn.exp))
4845 the_insn.reloc = R_PARISC_TLS_GD21L;
4846 else if (is_tls_ldidx (the_insn.exp))
4847 the_insn.reloc = R_PARISC_TLS_LDM21L;
4848 else if (is_tls_dtpoff (the_insn.exp))
4849 the_insn.reloc = R_PARISC_TLS_LDO21L;
4850 else if (is_tls_ieoff (the_insn.exp))
4851 the_insn.reloc = R_PARISC_TLS_IE21L;
4852 else if (is_tls_leoff (the_insn.exp))
4853 the_insn.reloc = R_PARISC_TLS_LE21L;
4856 the_insn.reloc = R_HPPA;
4857 the_insn.format = 21;
4861 /* Handle a 16 bit immediate at 31 (PA 2.0 wide mode only). */
4863 the_insn.field_selector = pa_chk_field_selector (&s);
4866 if (the_insn.exp.X_op == O_constant)
4868 num = evaluate_absolute (&the_insn);
4869 CHECK_FIELD (num, 32767, -32768, 0);
4870 opcode |= re_assemble_16 (num);
4875 /* ??? Is this valid for wide mode? */
4876 if (is_DP_relative (the_insn.exp))
4877 the_insn.reloc = R_HPPA_GOTOFF;
4878 else if (is_PC_relative (the_insn.exp))
4879 the_insn.reloc = R_HPPA_PCREL_CALL;
4881 else if (is_tls_gdidx (the_insn.exp))
4882 the_insn.reloc = R_PARISC_TLS_GD21L;
4883 else if (is_tls_ldidx (the_insn.exp))
4884 the_insn.reloc = R_PARISC_TLS_LDM21L;
4885 else if (is_tls_dtpoff (the_insn.exp))
4886 the_insn.reloc = R_PARISC_TLS_LDO21L;
4887 else if (is_tls_ieoff (the_insn.exp))
4888 the_insn.reloc = R_PARISC_TLS_IE21L;
4889 else if (is_tls_leoff (the_insn.exp))
4890 the_insn.reloc = R_PARISC_TLS_LE21L;
4893 the_insn.reloc = R_HPPA;
4894 the_insn.format = 14;
4898 /* Handle a word-aligned 16-bit imm. at 31 (PA2.0 wide). */
4900 the_insn.field_selector = pa_chk_field_selector (&s);
4903 if (the_insn.exp.X_op == O_constant)
4905 num = evaluate_absolute (&the_insn);
4906 CHECK_FIELD (num, 32767, -32768, 0);
4907 CHECK_ALIGN (num, 4, 0);
4908 opcode |= re_assemble_16 (num);
4913 /* ??? Is this valid for wide mode? */
4914 if (is_DP_relative (the_insn.exp))
4915 the_insn.reloc = R_HPPA_GOTOFF;
4916 else if (is_PC_relative (the_insn.exp))
4917 the_insn.reloc = R_HPPA_PCREL_CALL;
4919 else if (is_tls_gdidx (the_insn.exp))
4920 the_insn.reloc = R_PARISC_TLS_GD21L;
4921 else if (is_tls_ldidx (the_insn.exp))
4922 the_insn.reloc = R_PARISC_TLS_LDM21L;
4923 else if (is_tls_dtpoff (the_insn.exp))
4924 the_insn.reloc = R_PARISC_TLS_LDO21L;
4925 else if (is_tls_ieoff (the_insn.exp))
4926 the_insn.reloc = R_PARISC_TLS_IE21L;
4927 else if (is_tls_leoff (the_insn.exp))
4928 the_insn.reloc = R_PARISC_TLS_LE21L;
4931 the_insn.reloc = R_HPPA;
4932 the_insn.format = 14;
4936 /* Handle a dword-aligned 16-bit imm. at 31 (PA2.0 wide). */
4938 the_insn.field_selector = pa_chk_field_selector (&s);
4941 if (the_insn.exp.X_op == O_constant)
4943 num = evaluate_absolute (&the_insn);
4944 CHECK_FIELD (num, 32767, -32768, 0);
4945 CHECK_ALIGN (num, 8, 0);
4946 opcode |= re_assemble_16 (num);
4951 /* ??? Is this valid for wide mode? */
4952 if (is_DP_relative (the_insn.exp))
4953 the_insn.reloc = R_HPPA_GOTOFF;
4954 else if (is_PC_relative (the_insn.exp))
4955 the_insn.reloc = R_HPPA_PCREL_CALL;
4957 else if (is_tls_gdidx (the_insn.exp))
4958 the_insn.reloc = R_PARISC_TLS_GD21L;
4959 else if (is_tls_ldidx (the_insn.exp))
4960 the_insn.reloc = R_PARISC_TLS_LDM21L;
4961 else if (is_tls_dtpoff (the_insn.exp))
4962 the_insn.reloc = R_PARISC_TLS_LDO21L;
4963 else if (is_tls_ieoff (the_insn.exp))
4964 the_insn.reloc = R_PARISC_TLS_IE21L;
4965 else if (is_tls_leoff (the_insn.exp))
4966 the_insn.reloc = R_PARISC_TLS_LE21L;
4969 the_insn.reloc = R_HPPA;
4970 the_insn.format = 14;
4974 /* Handle a 12 bit branch displacement. */
4976 the_insn.field_selector = pa_chk_field_selector (&s);
4980 if (!the_insn.exp.X_add_symbol
4981 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
4984 num = evaluate_absolute (&the_insn);
4987 as_bad (_("Branch to unaligned address"));
4990 if (the_insn.exp.X_add_symbol)
4992 CHECK_FIELD (num, 8191, -8192, 0);
4993 opcode |= re_assemble_12 (num >> 2);
4998 the_insn.reloc = R_HPPA_PCREL_CALL;
4999 the_insn.format = 12;
5000 the_insn.arg_reloc = last_call_desc.arg_reloc;
5001 memset (&last_call_desc, 0, sizeof (struct call_desc));
5006 /* Handle a 17 bit branch displacement. */
5008 the_insn.field_selector = pa_chk_field_selector (&s);
5012 if (!the_insn.exp.X_add_symbol
5013 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5016 num = evaluate_absolute (&the_insn);
5019 as_bad (_("Branch to unaligned address"));
5022 if (the_insn.exp.X_add_symbol)
5024 CHECK_FIELD (num, 262143, -262144, 0);
5025 opcode |= re_assemble_17 (num >> 2);
5030 the_insn.reloc = R_HPPA_PCREL_CALL;
5031 the_insn.format = 17;
5032 the_insn.arg_reloc = last_call_desc.arg_reloc;
5033 memset (&last_call_desc, 0, sizeof (struct call_desc));
5037 /* Handle a 22 bit branch displacement. */
5039 the_insn.field_selector = pa_chk_field_selector (&s);
5043 if (!the_insn.exp.X_add_symbol
5044 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5047 num = evaluate_absolute (&the_insn);
5050 as_bad (_("Branch to unaligned address"));
5053 if (the_insn.exp.X_add_symbol)
5055 CHECK_FIELD (num, 8388607, -8388608, 0);
5056 opcode |= re_assemble_22 (num >> 2);
5060 the_insn.reloc = R_HPPA_PCREL_CALL;
5061 the_insn.format = 22;
5062 the_insn.arg_reloc = last_call_desc.arg_reloc;
5063 memset (&last_call_desc, 0, sizeof (struct call_desc));
5067 /* Handle an absolute 17 bit branch target. */
5069 the_insn.field_selector = pa_chk_field_selector (&s);
5073 if (!the_insn.exp.X_add_symbol
5074 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
5077 num = evaluate_absolute (&the_insn);
5080 as_bad (_("Branch to unaligned address"));
5083 if (the_insn.exp.X_add_symbol)
5085 CHECK_FIELD (num, 262143, -262144, 0);
5086 opcode |= re_assemble_17 (num >> 2);
5091 the_insn.reloc = R_HPPA_ABS_CALL;
5092 the_insn.format = 17;
5093 the_insn.arg_reloc = last_call_desc.arg_reloc;
5094 memset (&last_call_desc, 0, sizeof (struct call_desc));
5098 /* Handle '%r1' implicit operand of addil instruction. */
5100 if (*s == ',' && *(s + 1) == '%' && *(s + 3) == '1'
5101 && (*(s + 2) == 'r' || *(s + 2) == 'R'))
5109 /* Handle '%sr0,%r31' implicit operand of be,l instruction. */
5111 if (strncasecmp (s, "%sr0,%r31", 9) != 0)
5116 /* Handle immediate value of 0 for ordered load/store instructions. */
5123 /* Handle a 2 bit shift count at 25. */
5125 num = pa_get_absolute_expression (&the_insn, &s);
5126 if (strict && the_insn.exp.X_op != O_constant)
5129 CHECK_FIELD (num, 3, 1, strict);
5130 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5132 /* Handle a 4 bit shift count at 25. */
5134 num = pa_get_absolute_expression (&the_insn, &s);
5135 if (strict && the_insn.exp.X_op != O_constant)
5138 CHECK_FIELD (num, 15, 0, strict);
5139 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5141 /* Handle a 5 bit shift count at 26. */
5143 num = pa_get_absolute_expression (&the_insn, &s);
5144 if (strict && the_insn.exp.X_op != O_constant)
5147 CHECK_FIELD (num, 31, 0, strict);
5148 SAVE_IMMEDIATE(num);
5149 INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
5151 /* Handle a 6 bit shift count at 20,22:26. */
5153 num = pa_get_absolute_expression (&the_insn, &s);
5154 if (strict && the_insn.exp.X_op != O_constant)
5157 CHECK_FIELD (num, 63, 0, strict);
5158 SAVE_IMMEDIATE(num);
5160 opcode |= (num & 0x20) << 6;
5161 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
5163 /* Handle a 6 bit field length at 23,27:31. */
5166 num = pa_get_absolute_expression (&the_insn, &s);
5167 if (strict && the_insn.exp.X_op != O_constant)
5170 CHECK_FIELD (num, 64, 1, strict);
5171 SAVE_IMMEDIATE(num);
5173 opcode |= (num & 0x20) << 3;
5174 num = 31 - (num & 0x1f);
5175 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5177 /* Handle a 6 bit field length at 19,27:31. */
5179 num = pa_get_absolute_expression (&the_insn, &s);
5180 if (strict && the_insn.exp.X_op != O_constant)
5183 CHECK_FIELD (num, 64, 1, strict);
5184 SAVE_IMMEDIATE(num);
5186 opcode |= (num & 0x20) << 7;
5187 num = 31 - (num & 0x1f);
5188 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5190 /* Handle a 5 bit bit position at 26. */
5192 num = pa_get_absolute_expression (&the_insn, &s);
5193 if (strict && the_insn.exp.X_op != O_constant)
5196 CHECK_FIELD (num, 31, 0, strict);
5197 SAVE_IMMEDIATE(num);
5198 INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
5200 /* Handle a 6 bit bit position at 20,22:26. */
5202 num = pa_get_absolute_expression (&the_insn, &s);
5203 if (strict && the_insn.exp.X_op != O_constant)
5206 CHECK_FIELD (num, 63, 0, strict);
5207 SAVE_IMMEDIATE(num);
5208 opcode |= (num & 0x20) << 6;
5209 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
5211 /* Handle a 5 bit immediate at 10 with 'd' as the complement
5212 of the high bit of the immediate. */
5214 num = pa_get_absolute_expression (&the_insn, &s);
5215 if (strict && the_insn.exp.X_op != O_constant)
5218 CHECK_FIELD (num, 63, 0, strict);
5220 opcode &= ~(1 << 13);
5221 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 21);
5223 /* Handle a 5 bit immediate at 10. */
5225 num = pa_get_absolute_expression (&the_insn, &s);
5226 if (strict && the_insn.exp.X_op != O_constant)
5229 CHECK_FIELD (num, 31, 0, strict);
5230 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
5232 /* Handle a 9 bit immediate at 28. */
5234 num = pa_get_absolute_expression (&the_insn, &s);
5235 if (strict && the_insn.exp.X_op != O_constant)
5238 CHECK_FIELD (num, 511, 1, strict);
5239 INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
5241 /* Handle a 13 bit immediate at 18. */
5243 num = pa_get_absolute_expression (&the_insn, &s);
5244 if (strict && the_insn.exp.X_op != O_constant)
5247 CHECK_FIELD (num, 8191, 0, strict);
5248 INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
5250 /* Handle a 26 bit immediate at 31. */
5252 num = pa_get_absolute_expression (&the_insn, &s);
5253 if (strict && the_insn.exp.X_op != O_constant)
5256 CHECK_FIELD (num, 67108863, 0, strict);
5257 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5259 /* Handle a 3 bit SFU identifier at 25. */
5262 as_bad (_("Invalid SFU identifier"));
5263 num = pa_get_number (&the_insn, &s);
5264 if (strict && the_insn.exp.X_op != O_constant)
5267 CHECK_FIELD (num, 7, 0, strict);
5268 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5270 /* Handle a 20 bit SOP field for spop0. */
5272 num = pa_get_number (&the_insn, &s);
5273 if (strict && the_insn.exp.X_op != O_constant)
5276 CHECK_FIELD (num, 1048575, 0, strict);
5277 num = (num & 0x1f) | ((num & 0x000fffe0) << 6);
5278 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5280 /* Handle a 15bit SOP field for spop1. */
5282 num = pa_get_number (&the_insn, &s);
5283 if (strict && the_insn.exp.X_op != O_constant)
5286 CHECK_FIELD (num, 32767, 0, strict);
5287 INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
5289 /* Handle a 10bit SOP field for spop3. */
5291 num = pa_get_number (&the_insn, &s);
5292 if (strict && the_insn.exp.X_op != O_constant)
5295 CHECK_FIELD (num, 1023, 0, strict);
5296 num = (num & 0x1f) | ((num & 0x000003e0) << 6);
5297 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5299 /* Handle a 15 bit SOP field for spop2. */
5301 num = pa_get_number (&the_insn, &s);
5302 if (strict && the_insn.exp.X_op != O_constant)
5305 CHECK_FIELD (num, 32767, 0, strict);
5306 num = (num & 0x1f) | ((num & 0x00007fe0) << 6);
5307 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5309 /* Handle a 3-bit co-processor ID field. */
5312 as_bad (_("Invalid COPR identifier"));
5313 num = pa_get_number (&the_insn, &s);
5314 if (strict && the_insn.exp.X_op != O_constant)
5317 CHECK_FIELD (num, 7, 0, strict);
5318 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5320 /* Handle a 22bit SOP field for copr. */
5322 num = pa_get_number (&the_insn, &s);
5323 if (strict && the_insn.exp.X_op != O_constant)
5326 CHECK_FIELD (num, 4194303, 0, strict);
5327 num = (num & 0x1f) | ((num & 0x003fffe0) << 4);
5328 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5330 /* Handle a source FP operand format completer. */
5332 if (*s == ',' && *(s+1) == 't')
5339 flag = pa_parse_fp_cnv_format (&s);
5340 the_insn.fpof1 = flag;
5341 if (flag == W || flag == UW)
5343 if (flag == DW || flag == UDW)
5345 if (flag == QW || flag == UQW)
5347 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5349 /* Handle a destination FP operand format completer. */
5351 /* pa_parse_format needs the ',' prefix. */
5353 flag = pa_parse_fp_cnv_format (&s);
5354 the_insn.fpof2 = flag;
5355 if (flag == W || flag == UW)
5357 if (flag == DW || flag == UDW)
5359 if (flag == QW || flag == UQW)
5361 opcode |= flag << 13;
5362 if (the_insn.fpof1 == SGL
5363 || the_insn.fpof1 == DBL
5364 || the_insn.fpof1 == QUAD)
5366 if (the_insn.fpof2 == SGL
5367 || the_insn.fpof2 == DBL
5368 || the_insn.fpof2 == QUAD)
5370 else if (the_insn.fpof2 == W
5371 || the_insn.fpof2 == DW
5372 || the_insn.fpof2 == QW)
5374 else if (the_insn.fpof2 == UW
5375 || the_insn.fpof2 == UDW
5376 || the_insn.fpof2 == UQW)
5381 else if (the_insn.fpof1 == W
5382 || the_insn.fpof1 == DW
5383 || the_insn.fpof1 == QW)
5385 if (the_insn.fpof2 == SGL
5386 || the_insn.fpof2 == DBL
5387 || the_insn.fpof2 == QUAD)
5392 else if (the_insn.fpof1 == UW
5393 || the_insn.fpof1 == UDW
5394 || the_insn.fpof1 == UQW)
5396 if (the_insn.fpof2 == SGL
5397 || the_insn.fpof2 == DBL
5398 || the_insn.fpof2 == QUAD)
5403 flag |= the_insn.trunc;
5404 INSERT_FIELD_AND_CONTINUE (opcode, flag, 15);
5406 /* Handle a source FP operand format completer. */
5408 flag = pa_parse_fp_format (&s);
5409 the_insn.fpof1 = flag;
5410 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5412 /* Handle a destination FP operand format completer. */
5414 /* pa_parse_format needs the ',' prefix. */
5416 flag = pa_parse_fp_format (&s);
5417 the_insn.fpof2 = flag;
5418 INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
5420 /* Handle a source FP operand format completer at 20. */
5422 flag = pa_parse_fp_format (&s);
5423 the_insn.fpof1 = flag;
5424 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
5426 /* Handle a floating point operand format at 26.
5427 Only allows single and double precision. */
5429 flag = pa_parse_fp_format (&s);
5436 the_insn.fpof1 = flag;
5442 as_bad (_("Invalid Floating Point Operand Format."));
5446 /* Handle all floating point registers. */
5450 /* Float target register. */
5452 if (!pa_parse_number (&s, 3))
5454 /* RSEL should not be set. */
5455 if (pa_number & FP_REG_RSEL)
5457 num = pa_number - FP_REG_BASE;
5458 CHECK_FIELD (num, 31, 0, 0);
5459 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5461 /* Float target register with L/R selection. */
5464 if (!pa_parse_number (&s, 1))
5466 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5467 CHECK_FIELD (num, 31, 0, 0);
5470 /* 0x30 opcodes are FP arithmetic operation opcodes
5471 and need to be turned into 0x38 opcodes. This
5472 is not necessary for loads/stores. */
5473 if (need_pa11_opcode ()
5474 && ((opcode & 0xfc000000) == 0x30000000))
5477 opcode |= (pa_number & FP_REG_RSEL ? 1 << 6 : 0);
5481 /* Float operand 1. */
5484 if (!pa_parse_number (&s, 1))
5486 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5487 CHECK_FIELD (num, 31, 0, 0);
5488 opcode |= num << 21;
5489 if (need_pa11_opcode ())
5491 opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
5497 /* Float operand 1 with L/R selection. */
5501 if (!pa_parse_number (&s, 1))
5503 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5504 CHECK_FIELD (num, 31, 0, 0);
5505 opcode |= num << 21;
5506 opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
5510 /* Float operand 2. */
5513 if (!pa_parse_number (&s, 1))
5515 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5516 CHECK_FIELD (num, 31, 0, 0);
5517 opcode |= num << 16;
5518 if (need_pa11_opcode ())
5520 opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
5526 /* Float operand 2 with L/R selection. */
5529 if (!pa_parse_number (&s, 1))
5531 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5532 CHECK_FIELD (num, 31, 0, 0);
5533 opcode |= num << 16;
5534 opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
5538 /* Float operand 3 for fmpyfadd, fmpynfadd. */
5541 if (!pa_parse_number (&s, 1))
5543 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5544 CHECK_FIELD (num, 31, 0, 0);
5545 opcode |= (num & 0x1c) << 11;
5546 opcode |= (num & 0x03) << 9;
5547 opcode |= (pa_number & FP_REG_RSEL ? 1 << 8 : 0);
5551 /* Float mult operand 1 for fmpyadd, fmpysub */
5554 if (!pa_parse_number (&s, 1))
5556 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5557 CHECK_FIELD (num, 31, 0, 0);
5558 if (the_insn.fpof1 == SGL)
5562 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
5566 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5568 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
5571 /* Float mult operand 2 for fmpyadd, fmpysub */
5574 if (!pa_parse_number (&s, 1))
5576 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5577 CHECK_FIELD (num, 31, 0, 0);
5578 if (the_insn.fpof1 == SGL)
5582 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
5586 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5588 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
5591 /* Float mult target for fmpyadd, fmpysub */
5594 if (!pa_parse_number (&s, 1))
5596 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5597 CHECK_FIELD (num, 31, 0, 0);
5598 if (the_insn.fpof1 == SGL)
5602 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
5606 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5608 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
5611 /* Float add operand 1 for fmpyadd, fmpysub */
5614 if (!pa_parse_number (&s, 1))
5616 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5617 CHECK_FIELD (num, 31, 0, 0);
5618 if (the_insn.fpof1 == SGL)
5622 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
5626 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5628 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
5631 /* Float add target for fmpyadd, fmpysub */
5634 if (!pa_parse_number (&s, 1))
5636 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5637 CHECK_FIELD (num, 31, 0, 0);
5638 if (the_insn.fpof1 == SGL)
5642 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
5646 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
5648 INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
5651 /* Handle L/R register halves like 'x'. */
5655 if (!pa_parse_number (&s, 1))
5657 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5658 CHECK_FIELD (num, 31, 0, 0);
5659 opcode |= num << 16;
5660 if (need_pa11_opcode ())
5662 opcode |= (pa_number & FP_REG_RSEL ? 1 << 1 : 0);
5667 /* Float target register (PA 2.0 wide). */
5669 if (!pa_parse_number (&s, 3))
5671 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
5672 CHECK_FIELD (num, 31, 0, 0);
5673 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
5686 /* If this instruction is specific to a particular architecture,
5687 then set a new architecture. This automatic promotion crud is
5688 for compatibility with HP's old assemblers only. */
5690 && bfd_get_mach (stdoutput) < insn->arch
5691 && !bfd_set_arch_mach (stdoutput, bfd_arch_hppa, insn->arch))
5693 as_warn (_("could not update architecture and machine"));
5698 /* Check if the args matched. */
5701 if (&insn[1] - pa_opcodes < (int) NUMOPCODES
5702 && !strcmp (insn->name, insn[1].name))
5710 as_bad (_("Invalid operands %s"), error_message);
5717 if (immediate_check)
5719 if (pos != -1 && len != -1 && pos < len - 1)
5720 as_warn (_("Immediates %d and %d will give undefined behavior."),
5724 the_insn.opcode = opcode;
5727 /* Assemble a single instruction storing it into a frag. */
5730 md_assemble (char *str)
5734 /* The had better be something to assemble. */
5737 /* If we are within a procedure definition, make sure we've
5738 defined a label for the procedure; handle case where the
5739 label was defined after the .PROC directive.
5741 Note there's not need to diddle with the segment or fragment
5742 for the label symbol in this case. We have already switched
5743 into the new $CODE$ subspace at this point. */
5744 if (within_procedure && last_call_info->start_symbol == NULL)
5746 label_symbol_struct *label_symbol = pa_get_label ();
5750 if (label_symbol->lss_label)
5752 last_call_info->start_symbol = label_symbol->lss_label;
5753 symbol_get_bfdsym (label_symbol->lss_label)->flags
5756 /* Also handle allocation of a fixup to hold the unwind
5757 information when the label appears after the proc/procend. */
5758 if (within_entry_exit)
5763 where = frag_more (0);
5764 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
5765 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5766 NULL, (offsetT) 0, NULL,
5767 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
5772 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
5775 as_bad (_("Missing function name for .PROC"));
5778 /* Assemble the instruction. Results are saved into "the_insn". */
5781 /* Get somewhere to put the assembled instruction. */
5784 /* Output the opcode. */
5785 md_number_to_chars (to, the_insn.opcode, 4);
5787 /* If necessary output more stuff. */
5788 if (the_insn.reloc != R_HPPA_NONE)
5789 fix_new_hppa (frag_now, (to - frag_now->fr_literal), 4, NULL,
5790 (offsetT) 0, &the_insn.exp, the_insn.pcrel,
5791 the_insn.reloc, the_insn.field_selector,
5792 the_insn.format, the_insn.arg_reloc, 0);
5795 dwarf2_emit_insn (4);
5800 /* Handle an alignment directive. Special so that we can update the
5801 alignment of the subspace if necessary. */
5803 pa_align (int bytes)
5805 /* We must have a valid space and subspace. */
5806 pa_check_current_space_and_subspace ();
5808 /* Let the generic gas code do most of the work. */
5809 s_align_bytes (bytes);
5811 /* If bytes is a power of 2, then update the current subspace's
5812 alignment if necessary. */
5813 if (exact_log2 (bytes) != -1)
5814 record_alignment (current_subspace->ssd_seg, exact_log2 (bytes));
5818 /* Handle a .BLOCK type pseudo-op. */
5821 pa_block (int z ATTRIBUTE_UNUSED)
5823 unsigned int temp_size;
5826 /* We must have a valid space and subspace. */
5827 pa_check_current_space_and_subspace ();
5830 temp_size = get_absolute_expression ();
5832 if (temp_size > 0x3FFFFFFF)
5834 as_bad (_("Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff"));
5839 /* Always fill with zeros, that's what the HP assembler does. */
5840 char *p = frag_var (rs_fill, 1, 1, 0, NULL, temp_size, NULL);
5844 pa_undefine_label ();
5845 demand_empty_rest_of_line ();
5848 /* Handle a .begin_brtab and .end_brtab pseudo-op. */
5851 pa_brtab (int begin ATTRIBUTE_UNUSED)
5855 /* The BRTAB relocations are only available in SOM (to denote
5856 the beginning and end of branch tables). */
5857 char *where = frag_more (0);
5859 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5860 NULL, (offsetT) 0, NULL,
5861 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
5865 demand_empty_rest_of_line ();
5868 /* Handle a .begin_try and .end_try pseudo-op. */
5871 pa_try (int begin ATTRIBUTE_UNUSED)
5875 char *where = frag_more (0);
5880 /* The TRY relocations are only available in SOM (to denote
5881 the beginning and end of exception handling regions). */
5883 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5884 NULL, (offsetT) 0, begin ? NULL : &exp,
5885 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
5889 demand_empty_rest_of_line ();
5892 /* Do the dirty work of building a call descriptor which describes
5893 where the caller placed arguments to a function call. */
5896 pa_call_args (struct call_desc *call_desc)
5899 unsigned int temp, arg_reloc;
5901 while (!is_end_of_statement ())
5903 c = get_symbol_name (&name);
5904 /* Process a source argument. */
5905 if ((strncasecmp (name, "argw", 4) == 0))
5907 temp = atoi (name + 4);
5908 (void) restore_line_pointer (c);
5909 input_line_pointer++;
5910 c = get_symbol_name (&name);
5911 arg_reloc = pa_build_arg_reloc (name);
5912 call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
5914 /* Process a return value. */
5915 else if ((strncasecmp (name, "rtnval", 6) == 0))
5917 (void) restore_line_pointer (c);
5918 input_line_pointer++;
5919 c = get_symbol_name (&name);
5920 arg_reloc = pa_build_arg_reloc (name);
5921 call_desc->arg_reloc |= (arg_reloc & 0x3);
5925 as_bad (_("Invalid .CALL argument: %s"), name);
5928 (void) restore_line_pointer (c);
5929 if (!is_end_of_statement ())
5930 input_line_pointer++;
5934 /* Handle a .CALL pseudo-op. This involves storing away information
5935 about where arguments are to be found so the linker can detect
5936 (and correct) argument location mismatches between caller and callee. */
5939 pa_call (int unused ATTRIBUTE_UNUSED)
5942 /* We must have a valid space and subspace. */
5943 pa_check_current_space_and_subspace ();
5946 pa_call_args (&last_call_desc);
5947 demand_empty_rest_of_line ();
5951 /* Build an entry in the UNWIND subspace from the given function
5952 attributes in CALL_INFO. This is not needed for SOM as using
5953 R_ENTRY and R_EXIT relocations allow the linker to handle building
5954 of the unwind spaces. */
5957 pa_build_unwind_subspace (struct call_info *call_info)
5959 asection *seg, *save_seg;
5960 subsegT save_subseg;
5961 unsigned int unwind;
5966 if ((bfd_get_section_flags (stdoutput, now_seg)
5967 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
5968 != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
5971 if (call_info->start_symbol == NULL)
5972 /* This can happen if there were errors earlier on in the assembly. */
5975 /* Replace the start symbol with a local symbol that will be reduced
5976 to a section offset. This avoids problems with weak functions with
5977 multiple definitions, etc. */
5978 name = concat ("L$\001start_", S_GET_NAME (call_info->start_symbol),
5981 /* If we have a .procend preceded by a .exit, then the symbol will have
5982 already been defined. In that case, we don't want another unwind
5984 symbolP = symbol_find (name);
5992 symbolP = symbol_new (name, now_seg,
5993 S_GET_VALUE (call_info->start_symbol),
5994 call_info->start_symbol->sy_frag);
5995 gas_assert (symbolP);
5996 S_CLEAR_EXTERNAL (symbolP);
5997 symbol_table_insert (symbolP);
6000 reloc = R_PARISC_SEGREL32;
6002 save_subseg = now_subseg;
6003 /* Get into the right seg/subseg. This may involve creating
6004 the seg the first time through. Make sure to have the
6005 old seg/subseg so that we can reset things when we are done. */
6006 seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6007 if (seg == ASEC_NULL)
6009 seg = subseg_new (UNWIND_SECTION_NAME, 0);
6010 bfd_set_section_flags (stdoutput, seg,
6011 SEC_READONLY | SEC_HAS_CONTENTS
6012 | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6013 bfd_set_section_alignment (stdoutput, seg, 2);
6016 subseg_set (seg, 0);
6018 /* Get some space to hold relocation information for the unwind
6022 /* Relocation info. for start offset of the function. */
6023 md_number_to_chars (p, 0, 4);
6024 fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6025 symbolP, (offsetT) 0,
6026 (expressionS *) NULL, 0, reloc,
6029 /* Relocation info. for end offset of the function.
6031 Because we allow reductions of 32bit relocations for ELF, this will be
6032 reduced to section_sym + offset which avoids putting the temporary
6033 symbol into the symbol table. It (should) end up giving the same
6034 value as call_info->start_symbol + function size once the linker is
6035 finished with its work. */
6036 md_number_to_chars (p + 4, 0, 4);
6037 fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
6038 call_info->end_symbol, (offsetT) 0,
6039 (expressionS *) NULL, 0, reloc,
6042 /* Dump the descriptor. */
6043 unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6044 md_number_to_chars (p + 8, unwind, 4);
6046 unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6047 md_number_to_chars (p + 12, unwind, 4);
6049 /* Return back to the original segment/subsegment. */
6050 subseg_set (save_seg, save_subseg);
6054 /* Process a .CALLINFO pseudo-op. This information is used later
6055 to build unwind descriptors and maybe one day to support
6056 .ENTER and .LEAVE. */
6059 pa_callinfo (int unused ATTRIBUTE_UNUSED)
6065 /* We must have a valid space and subspace. */
6066 pa_check_current_space_and_subspace ();
6069 /* .CALLINFO must appear within a procedure definition. */
6070 if (!within_procedure)
6071 as_bad (_(".callinfo is not within a procedure definition"));
6073 /* Mark the fact that we found the .CALLINFO for the
6074 current procedure. */
6075 callinfo_found = TRUE;
6077 /* Iterate over the .CALLINFO arguments. */
6078 while (!is_end_of_statement ())
6080 c = get_symbol_name (&name);
6081 /* Frame size specification. */
6082 if ((strncasecmp (name, "frame", 5) == 0))
6084 (void) restore_line_pointer (c);
6085 input_line_pointer++;
6086 temp = get_absolute_expression ();
6087 if ((temp & 0x3) != 0)
6089 as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6093 /* callinfo is in bytes and unwind_desc is in 8 byte units. */
6094 last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6096 /* Entry register (GR, GR and SR) specifications. */
6097 else if ((strncasecmp (name, "entry_gr", 8) == 0))
6099 (void) restore_line_pointer (c);
6100 input_line_pointer++;
6101 temp = get_absolute_expression ();
6102 /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6103 even though %r19 is caller saved. I think this is a bug in
6104 the HP assembler, and we are not going to emulate it. */
6105 if (temp < 3 || temp > 18)
6106 as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6107 last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6109 else if ((strncasecmp (name, "entry_fr", 8) == 0))
6111 (void) restore_line_pointer (c);
6112 input_line_pointer++;
6113 temp = get_absolute_expression ();
6114 /* Similarly the HP assembler takes 31 as the high bound even
6115 though %fr21 is the last callee saved floating point register. */
6116 if (temp < 12 || temp > 21)
6117 as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6118 last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6120 else if ((strncasecmp (name, "entry_sr", 8) == 0))
6122 (void) restore_line_pointer (c);
6123 input_line_pointer++;
6124 temp = get_absolute_expression ();
6126 as_bad (_("Value for ENTRY_SR must be 3\n"));
6128 /* Note whether or not this function performs any calls. */
6129 else if ((strncasecmp (name, "calls", 5) == 0)
6130 || (strncasecmp (name, "caller", 6) == 0))
6132 (void) restore_line_pointer (c);
6134 else if ((strncasecmp (name, "no_calls", 8) == 0))
6136 (void) restore_line_pointer (c);
6138 /* Should RP be saved into the stack. */
6139 else if ((strncasecmp (name, "save_rp", 7) == 0))
6141 (void) restore_line_pointer (c);
6142 last_call_info->ci_unwind.descriptor.save_rp = 1;
6144 /* Likewise for SP. */
6145 else if ((strncasecmp (name, "save_sp", 7) == 0))
6147 (void) restore_line_pointer (c);
6148 last_call_info->ci_unwind.descriptor.save_sp = 1;
6150 /* Is this an unwindable procedure. If so mark it so
6151 in the unwind descriptor. */
6152 else if ((strncasecmp (name, "no_unwind", 9) == 0))
6154 (void) restore_line_pointer (c);
6155 last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6157 /* Is this an interrupt routine. If so mark it in the
6158 unwind descriptor. */
6159 else if ((strncasecmp (name, "hpux_int", 7) == 0))
6161 (void) restore_line_pointer (c);
6162 last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6164 /* Is this a millicode routine. "millicode" isn't in my
6165 assembler manual, but my copy is old. The HP assembler
6166 accepts it, and there's a place in the unwind descriptor
6167 to drop the information, so we'll accept it too. */
6168 else if ((strncasecmp (name, "millicode", 9) == 0))
6170 (void) restore_line_pointer (c);
6171 last_call_info->ci_unwind.descriptor.millicode = 1;
6175 as_bad (_("Invalid .CALLINFO argument: %s"), name);
6176 (void) restore_line_pointer (c);
6179 if (!is_end_of_statement ())
6180 input_line_pointer++;
6183 demand_empty_rest_of_line ();
6186 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
6187 /* Switch to the text space. Like s_text, but delete our
6188 label when finished. */
6191 pa_text (int unused ATTRIBUTE_UNUSED)
6194 current_space = is_defined_space ("$TEXT$");
6196 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6200 pa_undefine_label ();
6203 /* Switch to the data space. As usual delete our label. */
6206 pa_data (int unused ATTRIBUTE_UNUSED)
6209 current_space = is_defined_space ("$PRIVATE$");
6211 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6214 pa_undefine_label ();
6217 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6218 the .comm pseudo-op has the following syntax:
6220 <label> .comm <length>
6222 where <label> is optional and is a symbol whose address will be the start of
6223 a block of memory <length> bytes long. <length> must be an absolute
6224 expression. <length> bytes will be allocated in the current space
6227 Also note the label may not even be on the same line as the .comm.
6229 This difference in syntax means the colon function will be called
6230 on the symbol before we arrive in pa_comm. colon will set a number
6231 of attributes of the symbol that need to be fixed here. In particular
6232 the value, section pointer, fragment pointer, flags, etc. What
6235 This also makes error detection all but impossible. */
6238 pa_comm (int unused ATTRIBUTE_UNUSED)
6242 label_symbol_struct *label_symbol = pa_get_label ();
6245 symbol = label_symbol->lss_label;
6250 size = get_absolute_expression ();
6254 symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
6255 S_SET_VALUE (symbol, size);
6256 S_SET_SEGMENT (symbol, bfd_com_section_ptr);
6257 S_SET_EXTERNAL (symbol);
6259 /* colon() has already set the frag to the current location in the
6260 current subspace; we need to reset the fragment to the zero address
6261 fragment. We also need to reset the segment pointer. */
6262 symbol_set_frag (symbol, &zero_address_frag);
6264 demand_empty_rest_of_line ();
6266 #endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
6268 /* Process a .END pseudo-op. */
6271 pa_end (int unused ATTRIBUTE_UNUSED)
6273 demand_empty_rest_of_line ();
6276 /* Process a .ENTER pseudo-op. This is not supported. */
6279 pa_enter (int unused ATTRIBUTE_UNUSED)
6282 /* We must have a valid space and subspace. */
6283 pa_check_current_space_and_subspace ();
6286 as_bad (_("The .ENTER pseudo-op is not supported"));
6287 demand_empty_rest_of_line ();
6290 /* Process a .ENTRY pseudo-op. .ENTRY marks the beginning of the
6294 pa_entry (int unused ATTRIBUTE_UNUSED)
6297 /* We must have a valid space and subspace. */
6298 pa_check_current_space_and_subspace ();
6301 if (!within_procedure)
6302 as_bad (_("Misplaced .entry. Ignored."));
6305 if (!callinfo_found)
6306 as_bad (_("Missing .callinfo."));
6308 demand_empty_rest_of_line ();
6309 within_entry_exit = TRUE;
6312 /* SOM defers building of unwind descriptors until the link phase.
6313 The assembler is responsible for creating an R_ENTRY relocation
6314 to mark the beginning of a region and hold the unwind bits, and
6315 for creating an R_EXIT relocation to mark the end of the region.
6317 FIXME. ELF should be using the same conventions! The problem
6318 is an unwind requires too much relocation space. Hmmm. Maybe
6319 if we split the unwind bits up between the relocations which
6320 denote the entry and exit points. */
6321 if (last_call_info->start_symbol != NULL)
6326 where = frag_more (0);
6327 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
6328 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6329 NULL, (offsetT) 0, NULL,
6330 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
6335 /* Silly nonsense for pa_equ. The only half-sensible use for this is
6336 being able to subtract two register symbols that specify a range of
6337 registers, to get the size of the range. */
6338 static int fudge_reg_expressions;
6341 hppa_force_reg_syms_absolute (expressionS *resultP,
6342 operatorT op ATTRIBUTE_UNUSED,
6343 expressionS *rightP)
6345 if (fudge_reg_expressions
6346 && rightP->X_op == O_register
6347 && resultP->X_op == O_register)
6349 rightP->X_op = O_constant;
6350 resultP->X_op = O_constant;
6352 return 0; /* Continue normal expr handling. */
6355 /* Handle a .EQU pseudo-op. */
6360 label_symbol_struct *label_symbol = pa_get_label ();
6365 symbol = label_symbol->lss_label;
6369 if (!pa_parse_number (&input_line_pointer, 0))
6370 as_bad (_(".REG expression must be a register"));
6371 S_SET_VALUE (symbol, pa_number);
6372 S_SET_SEGMENT (symbol, reg_section);
6379 fudge_reg_expressions = 1;
6380 seg = expression (&exp);
6381 fudge_reg_expressions = 0;
6382 if (exp.X_op != O_constant
6383 && exp.X_op != O_register)
6385 if (exp.X_op != O_absent)
6386 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6387 exp.X_add_number = 0;
6388 seg = absolute_section;
6390 S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6391 S_SET_SEGMENT (symbol, seg);
6397 as_bad (_(".REG must use a label"));
6399 as_bad (_(".EQU must use a label"));
6402 pa_undefine_label ();
6403 demand_empty_rest_of_line ();
6407 /* Mark the end of a function so that it's possible to compute
6408 the size of the function in elf_hppa_final_processing. */
6411 hppa_elf_mark_end_of_function (void)
6413 /* ELF does not have EXIT relocations. All we do is create a
6414 temporary symbol marking the end of the function. */
6418 if (last_call_info == NULL || last_call_info->start_symbol == NULL)
6420 /* We have already warned about a missing label,
6421 or other problems. */
6425 name = concat ("L$\001end_", S_GET_NAME (last_call_info->start_symbol),
6428 /* If we have a .exit followed by a .procend, then the
6429 symbol will have already been defined. */
6430 symbolP = symbol_find (name);
6433 /* The symbol has already been defined! This can
6434 happen if we have a .exit followed by a .procend.
6436 This is *not* an error. All we want to do is free
6437 the memory we just allocated for the name and continue. */
6442 /* symbol value should be the offset of the
6443 last instruction of the function */
6444 symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
6447 gas_assert (symbolP);
6448 S_CLEAR_EXTERNAL (symbolP);
6449 symbol_table_insert (symbolP);
6453 last_call_info->end_symbol = symbolP;
6455 as_bad (_("Symbol '%s' could not be created."), name);
6459 /* Helper function. Does processing for the end of a function. This
6460 usually involves creating some relocations or building special
6461 symbols to mark the end of the function. */
6468 where = frag_more (0);
6471 /* Mark the end of the function, stuff away the location of the frag
6472 for the end of the function, and finally call pa_build_unwind_subspace
6473 to add an entry in the unwind table. */
6475 hppa_elf_mark_end_of_function ();
6476 pa_build_unwind_subspace (last_call_info);
6478 /* SOM defers building of unwind descriptors until the link phase.
6479 The assembler is responsible for creating an R_ENTRY relocation
6480 to mark the beginning of a region and hold the unwind bits, and
6481 for creating an R_EXIT relocation to mark the end of the region.
6483 FIXME. ELF should be using the same conventions! The problem
6484 is an unwind requires too much relocation space. Hmmm. Maybe
6485 if we split the unwind bits up between the relocations which
6486 denote the entry and exit points. */
6487 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6489 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
6490 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
6494 /* Process a .EXIT pseudo-op. */
6497 pa_exit (int unused ATTRIBUTE_UNUSED)
6500 /* We must have a valid space and subspace. */
6501 pa_check_current_space_and_subspace ();
6504 if (!within_procedure)
6505 as_bad (_(".EXIT must appear within a procedure"));
6508 if (!callinfo_found)
6509 as_bad (_("Missing .callinfo"));
6512 if (!within_entry_exit)
6513 as_bad (_("No .ENTRY for this .EXIT"));
6516 within_entry_exit = FALSE;
6521 demand_empty_rest_of_line ();
6524 /* Helper function to process arguments to a .EXPORT pseudo-op. */
6527 pa_type_args (symbolS *symbolP, int is_export)
6530 unsigned int temp, arg_reloc;
6531 pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
6532 asymbol *bfdsym = symbol_get_bfdsym (symbolP);
6534 if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6536 input_line_pointer += 8;
6537 bfdsym->flags &= ~BSF_FUNCTION;
6538 S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6539 type = SYMBOL_TYPE_ABSOLUTE;
6541 else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6543 input_line_pointer += 4;
6544 /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6545 instead one should be IMPORTing/EXPORTing ENTRY types.
6547 Complain if one tries to EXPORT a CODE type since that's never
6548 done. Both GCC and HP C still try to IMPORT CODE types, so
6549 silently fix them to be ENTRY types. */
6550 if (S_IS_FUNCTION (symbolP))
6553 as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6554 S_GET_NAME (symbolP));
6556 bfdsym->flags |= BSF_FUNCTION;
6557 type = SYMBOL_TYPE_ENTRY;
6561 bfdsym->flags &= ~BSF_FUNCTION;
6562 type = SYMBOL_TYPE_CODE;
6565 else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6567 input_line_pointer += 4;
6568 bfdsym->flags &= ~BSF_FUNCTION;
6569 bfdsym->flags |= BSF_OBJECT;
6570 type = SYMBOL_TYPE_DATA;
6572 else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6574 input_line_pointer += 5;
6575 bfdsym->flags |= BSF_FUNCTION;
6576 type = SYMBOL_TYPE_ENTRY;
6578 else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6580 input_line_pointer += 9;
6581 bfdsym->flags |= BSF_FUNCTION;
6584 elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6585 elfsym->internal_elf_sym.st_info =
6586 ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6590 type = SYMBOL_TYPE_MILLICODE;
6592 else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6594 input_line_pointer += 6;
6595 bfdsym->flags &= ~BSF_FUNCTION;
6596 type = SYMBOL_TYPE_PLABEL;
6598 else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6600 input_line_pointer += 8;
6601 bfdsym->flags |= BSF_FUNCTION;
6602 type = SYMBOL_TYPE_PRI_PROG;
6604 else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6606 input_line_pointer += 8;
6607 bfdsym->flags |= BSF_FUNCTION;
6608 type = SYMBOL_TYPE_SEC_PROG;
6611 /* SOM requires much more information about symbol types
6612 than BFD understands. This is how we get this information
6613 to the SOM BFD backend. */
6614 #ifdef obj_set_symbol_type
6615 obj_set_symbol_type (bfdsym, (int) type);
6620 /* Now that the type of the exported symbol has been handled,
6621 handle any argument relocation information. */
6622 while (!is_end_of_statement ())
6624 if (*input_line_pointer == ',')
6625 input_line_pointer++;
6626 c = get_symbol_name (&name);
6627 /* Argument sources. */
6628 if ((strncasecmp (name, "argw", 4) == 0))
6630 (void) restore_line_pointer (c);
6631 input_line_pointer++;
6632 temp = atoi (name + 4);
6633 c = get_symbol_name (&name);
6634 arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
6635 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6636 symbol_arg_reloc_info (symbolP) |= arg_reloc;
6640 (void) restore_line_pointer (c);
6642 /* The return value. */
6643 else if ((strncasecmp (name, "rtnval", 6)) == 0)
6645 (void) restore_line_pointer (c);
6646 input_line_pointer++;
6647 c = get_symbol_name (&name);
6648 arg_reloc = pa_build_arg_reloc (name);
6649 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6650 symbol_arg_reloc_info (symbolP) |= arg_reloc;
6654 (void) restore_line_pointer (c);
6656 /* Privilege level. */
6657 else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6661 (void) restore_line_pointer (c);
6662 input_line_pointer++;
6663 temp = atoi (input_line_pointer);
6665 ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
6667 c = get_symbol_name (&priv);
6668 (void) restore_line_pointer (c);
6672 as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6673 (void) restore_line_pointer (c);
6676 if (!is_end_of_statement ())
6677 input_line_pointer++;
6681 /* Process a .EXPORT directive. This makes functions external
6682 and provides information such as argument relocation entries
6686 pa_export (int unused ATTRIBUTE_UNUSED)
6691 c = get_symbol_name (&name);
6692 /* Make sure the given symbol exists. */
6693 if ((symbol = symbol_find_or_make (name)) == NULL)
6695 as_bad (_("Cannot define export symbol: %s\n"), name);
6696 restore_line_pointer (c);
6697 input_line_pointer++;
6701 /* OK. Set the external bits and process argument relocations.
6702 For the HP, weak and global are not mutually exclusive.
6703 S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6704 Call S_SET_EXTERNAL to get the other processing. Manually
6705 set BSF_GLOBAL when we get back. */
6706 S_SET_EXTERNAL (symbol);
6707 symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
6708 (void) restore_line_pointer (c);
6709 if (!is_end_of_statement ())
6711 input_line_pointer++;
6712 pa_type_args (symbol, 1);
6716 demand_empty_rest_of_line ();
6719 /* Handle an .IMPORT pseudo-op. Any symbol referenced in a given
6720 assembly file must either be defined in the assembly file, or
6721 explicitly IMPORTED from another. */
6724 pa_import (int unused ATTRIBUTE_UNUSED)
6729 c = get_symbol_name (&name);
6731 symbol = symbol_find (name);
6732 /* Ugh. We might be importing a symbol defined earlier in the file,
6733 in which case all the code below will really screw things up
6734 (set the wrong segment, symbol flags & type, etc). */
6735 if (symbol == NULL || !S_IS_DEFINED (symbol))
6737 symbol = symbol_find_or_make (name);
6738 (void) restore_line_pointer (c);
6740 if (!is_end_of_statement ())
6742 input_line_pointer++;
6743 pa_type_args (symbol, 0);
6747 /* Sigh. To be compatible with the HP assembler and to help
6748 poorly written assembly code, we assign a type based on
6749 the current segment. Note only BSF_FUNCTION really
6750 matters, we do not need to set the full SYMBOL_TYPE_* info. */
6751 if (now_seg == text_section)
6752 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
6754 /* If the section is undefined, then the symbol is undefined
6755 Since this is an import, leave the section undefined. */
6756 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6761 /* The symbol was already defined. Just eat everything up to
6762 the end of the current statement. */
6763 while (!is_end_of_statement ())
6764 input_line_pointer++;
6767 demand_empty_rest_of_line ();
6770 /* Handle a .LABEL pseudo-op. */
6773 pa_label (int unused ATTRIBUTE_UNUSED)
6777 c = get_symbol_name (&name);
6779 if (strlen (name) > 0)
6782 (void) restore_line_pointer (c);
6786 as_warn (_("Missing label name on .LABEL"));
6789 if (!is_end_of_statement ())
6791 as_warn (_("extra .LABEL arguments ignored."));
6792 ignore_rest_of_line ();
6794 demand_empty_rest_of_line ();
6797 /* Handle a .LEAVE pseudo-op. This is not supported yet. */
6800 pa_leave (int unused ATTRIBUTE_UNUSED)
6803 /* We must have a valid space and subspace. */
6804 pa_check_current_space_and_subspace ();
6807 as_bad (_("The .LEAVE pseudo-op is not supported"));
6808 demand_empty_rest_of_line ();
6811 /* Handle a .LEVEL pseudo-op. */
6814 pa_level (int unused ATTRIBUTE_UNUSED)
6818 level = input_line_pointer;
6819 if (strncmp (level, "1.0", 3) == 0)
6821 input_line_pointer += 3;
6822 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6823 as_warn (_("could not set architecture and machine"));
6825 else if (strncmp (level, "1.1", 3) == 0)
6827 input_line_pointer += 3;
6828 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6829 as_warn (_("could not set architecture and machine"));
6831 else if (strncmp (level, "2.0w", 4) == 0)
6833 input_line_pointer += 4;
6834 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6835 as_warn (_("could not set architecture and machine"));
6837 else if (strncmp (level, "2.0", 3) == 0)
6839 input_line_pointer += 3;
6840 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6841 as_warn (_("could not set architecture and machine"));
6845 as_bad (_("Unrecognized .LEVEL argument\n"));
6846 ignore_rest_of_line ();
6848 demand_empty_rest_of_line ();
6851 /* Handle a .ORIGIN pseudo-op. */
6854 pa_origin (int unused ATTRIBUTE_UNUSED)
6857 /* We must have a valid space and subspace. */
6858 pa_check_current_space_and_subspace ();
6862 pa_undefine_label ();
6865 /* Handle a .PARAM pseudo-op. This is much like a .EXPORT, except it
6866 is for static functions. FIXME. Should share more code with .EXPORT. */
6869 pa_param (int unused ATTRIBUTE_UNUSED)
6874 c = get_symbol_name (&name);
6876 if ((symbol = symbol_find_or_make (name)) == NULL)
6878 as_bad (_("Cannot define static symbol: %s\n"), name);
6879 (void) restore_line_pointer (c);
6880 input_line_pointer++;
6884 S_CLEAR_EXTERNAL (symbol);
6885 (void) restore_line_pointer (c);
6886 if (!is_end_of_statement ())
6888 input_line_pointer++;
6889 pa_type_args (symbol, 0);
6893 demand_empty_rest_of_line ();
6896 /* Handle a .PROC pseudo-op. It is used to mark the beginning
6897 of a procedure from a syntactical point of view. */
6900 pa_proc (int unused ATTRIBUTE_UNUSED)
6902 struct call_info *call_info;
6905 /* We must have a valid space and subspace. */
6906 pa_check_current_space_and_subspace ();
6909 if (within_procedure)
6910 as_fatal (_("Nested procedures"));
6912 /* Reset global variables for new procedure. */
6913 callinfo_found = FALSE;
6914 within_procedure = TRUE;
6916 /* Create another call_info structure. */
6917 call_info = XNEW (struct call_info);
6920 as_fatal (_("Cannot allocate unwind descriptor\n"));
6922 memset (call_info, 0, sizeof (struct call_info));
6924 call_info->ci_next = NULL;
6926 if (call_info_root == NULL)
6928 call_info_root = call_info;
6929 last_call_info = call_info;
6933 last_call_info->ci_next = call_info;
6934 last_call_info = call_info;
6937 /* set up defaults on call_info structure */
6939 call_info->ci_unwind.descriptor.cannot_unwind = 0;
6940 call_info->ci_unwind.descriptor.region_desc = 1;
6941 call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
6943 /* If we got a .PROC pseudo-op, we know that the function is defined
6944 locally. Make sure it gets into the symbol table. */
6946 label_symbol_struct *label_symbol = pa_get_label ();
6950 if (label_symbol->lss_label)
6952 last_call_info->start_symbol = label_symbol->lss_label;
6953 symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
6956 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
6959 last_call_info->start_symbol = NULL;
6962 demand_empty_rest_of_line ();
6965 /* Process the syntactical end of a procedure. Make sure all the
6966 appropriate pseudo-ops were found within the procedure. */
6969 pa_procend (int unused ATTRIBUTE_UNUSED)
6972 /* We must have a valid space and subspace. */
6973 pa_check_current_space_and_subspace ();
6976 /* If we are within a procedure definition, make sure we've
6977 defined a label for the procedure; handle case where the
6978 label was defined after the .PROC directive.
6980 Note there's not need to diddle with the segment or fragment
6981 for the label symbol in this case. We have already switched
6982 into the new $CODE$ subspace at this point. */
6983 if (within_procedure && last_call_info->start_symbol == NULL)
6985 label_symbol_struct *label_symbol = pa_get_label ();
6989 if (label_symbol->lss_label)
6991 last_call_info->start_symbol = label_symbol->lss_label;
6992 symbol_get_bfdsym (label_symbol->lss_label)->flags
6995 /* Also handle allocation of a fixup to hold the unwind
6996 information when the label appears after the proc/procend. */
6997 if (within_entry_exit)
7002 where = frag_more (0);
7003 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
7004 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7005 NULL, (offsetT) 0, NULL,
7006 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
7011 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7014 as_bad (_("Missing function name for .PROC"));
7017 if (!within_procedure)
7018 as_bad (_("misplaced .procend"));
7020 if (!callinfo_found)
7021 as_bad (_("Missing .callinfo for this procedure"));
7023 if (within_entry_exit)
7024 as_bad (_("Missing .EXIT for a .ENTRY"));
7027 /* ELF needs to mark the end of each function so that it can compute
7028 the size of the function (apparently it's needed in the symbol table). */
7029 hppa_elf_mark_end_of_function ();
7032 within_procedure = FALSE;
7033 demand_empty_rest_of_line ();
7034 pa_undefine_label ();
7038 /* If VALUE is an exact power of two between zero and 2^31, then
7039 return log2 (VALUE). Else return -1. */
7042 exact_log2 (int value)
7046 while ((1 << shift) != value && shift < 32)
7055 /* Check to make sure we have a valid space and subspace. */
7058 pa_check_current_space_and_subspace (void)
7060 if (current_space == NULL)
7061 as_fatal (_("Not in a space.\n"));
7063 if (current_subspace == NULL)
7064 as_fatal (_("Not in a subspace.\n"));
7067 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7068 then create a new space entry to hold the information specified
7069 by the parameters to the .SPACE directive. */
7071 static sd_chain_struct *
7072 pa_parse_space_stmt (const char *space_name, int create_flag)
7074 char *name, *ptemp, c;
7075 char loadable, defined, private, sort;
7077 asection *seg = NULL;
7078 sd_chain_struct *space;
7080 /* Load default values. */
7086 if (strcmp (space_name, "$TEXT$") == 0)
7088 seg = pa_def_spaces[0].segment;
7089 defined = pa_def_spaces[0].defined;
7090 private = pa_def_spaces[0].private;
7091 sort = pa_def_spaces[0].sort;
7092 spnum = pa_def_spaces[0].spnum;
7094 else if (strcmp (space_name, "$PRIVATE$") == 0)
7096 seg = pa_def_spaces[1].segment;
7097 defined = pa_def_spaces[1].defined;
7098 private = pa_def_spaces[1].private;
7099 sort = pa_def_spaces[1].sort;
7100 spnum = pa_def_spaces[1].spnum;
7103 if (!is_end_of_statement ())
7105 print_errors = FALSE;
7106 ptemp = input_line_pointer + 1;
7107 /* First see if the space was specified as a number rather than
7108 as a name. According to the PA assembly manual the rest of
7109 the line should be ignored. */
7111 pa_parse_number (&ptemp, 0);
7115 input_line_pointer = ptemp;
7119 while (!is_end_of_statement ())
7121 input_line_pointer++;
7122 c = get_symbol_name (&name);
7123 if ((strncasecmp (name, "spnum", 5) == 0))
7125 (void) restore_line_pointer (c);
7126 input_line_pointer++;
7127 spnum = get_absolute_expression ();
7129 else if ((strncasecmp (name, "sort", 4) == 0))
7131 (void) restore_line_pointer (c);
7132 input_line_pointer++;
7133 sort = get_absolute_expression ();
7135 else if ((strncasecmp (name, "unloadable", 10) == 0))
7137 (void) restore_line_pointer (c);
7140 else if ((strncasecmp (name, "notdefined", 10) == 0))
7142 (void) restore_line_pointer (c);
7145 else if ((strncasecmp (name, "private", 7) == 0))
7147 (void) restore_line_pointer (c);
7152 as_bad (_("Invalid .SPACE argument"));
7153 (void) restore_line_pointer (c);
7154 if (!is_end_of_statement ())
7155 input_line_pointer++;
7159 print_errors = TRUE;
7162 if (create_flag && seg == NULL)
7163 seg = subseg_new (space_name, 0);
7165 /* If create_flag is nonzero, then create the new space with
7166 the attributes computed above. Else set the values in
7167 an already existing space -- this can only happen for
7168 the first occurrence of a built-in space. */
7170 space = create_new_space (space_name, spnum, loadable, defined,
7171 private, sort, seg, 1);
7174 space = is_defined_space (space_name);
7175 SPACE_SPNUM (space) = spnum;
7176 SPACE_DEFINED (space) = defined & 1;
7177 SPACE_USER_DEFINED (space) = 1;
7180 #ifdef obj_set_section_attributes
7181 obj_set_section_attributes (seg, defined, private, sort, spnum);
7187 /* Handle a .SPACE pseudo-op; this switches the current space to the
7188 given space, creating the new space if necessary. */
7191 pa_space (int unused ATTRIBUTE_UNUSED)
7193 char *name, c, *space_name, *save_s;
7194 sd_chain_struct *sd_chain;
7196 if (within_procedure)
7198 as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7199 ignore_rest_of_line ();
7203 /* Check for some of the predefined spaces. FIXME: most of the code
7204 below is repeated several times, can we extract the common parts
7205 and place them into a subroutine or something similar? */
7206 /* FIXME Is this (and the next IF stmt) really right?
7207 What if INPUT_LINE_POINTER points to "$TEXT$FOO"? */
7208 if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7210 input_line_pointer += 6;
7211 sd_chain = is_defined_space ("$TEXT$");
7212 if (sd_chain == NULL)
7213 sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7214 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7215 sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7217 current_space = sd_chain;
7218 subseg_set (text_section, sd_chain->sd_last_subseg);
7220 = pa_subsegment_to_subspace (text_section,
7221 sd_chain->sd_last_subseg);
7222 demand_empty_rest_of_line ();
7225 if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7227 input_line_pointer += 9;
7228 sd_chain = is_defined_space ("$PRIVATE$");
7229 if (sd_chain == NULL)
7230 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7231 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7232 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7234 current_space = sd_chain;
7235 subseg_set (data_section, sd_chain->sd_last_subseg);
7237 = pa_subsegment_to_subspace (data_section,
7238 sd_chain->sd_last_subseg);
7239 demand_empty_rest_of_line ();
7242 if (!strncasecmp (input_line_pointer,
7243 GDB_DEBUG_SPACE_NAME,
7244 strlen (GDB_DEBUG_SPACE_NAME)))
7246 input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7247 sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7248 if (sd_chain == NULL)
7249 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7250 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7251 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7253 current_space = sd_chain;
7256 asection *gdb_section
7257 = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7259 subseg_set (gdb_section, sd_chain->sd_last_subseg);
7261 = pa_subsegment_to_subspace (gdb_section,
7262 sd_chain->sd_last_subseg);
7264 demand_empty_rest_of_line ();
7268 /* It could be a space specified by number. */
7270 save_s = input_line_pointer;
7272 pa_parse_number (&input_line_pointer, 0);
7275 if ((sd_chain = pa_find_space_by_number (pa_number)))
7277 current_space = sd_chain;
7279 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7281 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7282 sd_chain->sd_last_subseg);
7283 demand_empty_rest_of_line ();
7288 /* Not a number, attempt to create a new space. */
7290 input_line_pointer = save_s;
7291 c = get_symbol_name (&name);
7292 space_name = xstrdup (name);
7293 (void) restore_line_pointer (c);
7295 sd_chain = pa_parse_space_stmt (space_name, 1);
7296 current_space = sd_chain;
7298 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7299 current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7300 sd_chain->sd_last_subseg);
7301 demand_empty_rest_of_line ();
7305 /* Switch to a new space. (I think). FIXME. */
7308 pa_spnum (int unused ATTRIBUTE_UNUSED)
7313 sd_chain_struct *space;
7315 c = get_symbol_name (&name);
7316 space = is_defined_space (name);
7320 md_number_to_chars (p, SPACE_SPNUM (space), 4);
7323 as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7325 (void) restore_line_pointer (c);
7326 demand_empty_rest_of_line ();
7329 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7330 given subspace, creating the new subspace if necessary.
7332 FIXME. Should mirror pa_space more closely, in particular how
7333 they're broken up into subroutines. */
7336 pa_subspace (int create_new)
7338 char *name, *ss_name, c;
7339 char loadable, code_only, comdat, common, dup_common, zero, sort;
7340 int i, access_ctr, space_index, alignment, quadrant, applicable, flags;
7341 sd_chain_struct *space;
7342 ssd_chain_struct *ssd;
7345 if (current_space == NULL)
7346 as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7348 if (within_procedure)
7350 as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7351 ignore_rest_of_line ();
7355 c = get_symbol_name (&name);
7356 ss_name = xstrdup (name);
7357 (void) restore_line_pointer (c);
7359 /* Load default values. */
7372 space = current_space;
7376 ssd = is_defined_subspace (ss_name);
7377 /* Allow user to override the builtin attributes of subspaces. But
7378 only allow the attributes to be changed once! */
7379 if (ssd && SUBSPACE_DEFINED (ssd))
7381 subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7382 current_subspace = ssd;
7383 if (!is_end_of_statement ())
7384 as_warn (_("Parameters of an existing subspace can\'t be modified"));
7385 demand_empty_rest_of_line ();
7390 /* A new subspace. Load default values if it matches one of
7391 the builtin subspaces. */
7393 while (pa_def_subspaces[i].name)
7395 if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7397 loadable = pa_def_subspaces[i].loadable;
7398 comdat = pa_def_subspaces[i].comdat;
7399 common = pa_def_subspaces[i].common;
7400 dup_common = pa_def_subspaces[i].dup_common;
7401 code_only = pa_def_subspaces[i].code_only;
7402 zero = pa_def_subspaces[i].zero;
7403 space_index = pa_def_subspaces[i].space_index;
7404 alignment = pa_def_subspaces[i].alignment;
7405 quadrant = pa_def_subspaces[i].quadrant;
7406 access_ctr = pa_def_subspaces[i].access;
7407 sort = pa_def_subspaces[i].sort;
7414 /* We should be working with a new subspace now. Fill in
7415 any information as specified by the user. */
7416 if (!is_end_of_statement ())
7418 input_line_pointer++;
7419 while (!is_end_of_statement ())
7421 c = get_symbol_name (&name);
7422 if ((strncasecmp (name, "quad", 4) == 0))
7424 (void) restore_line_pointer (c);
7425 input_line_pointer++;
7426 quadrant = get_absolute_expression ();
7428 else if ((strncasecmp (name, "align", 5) == 0))
7430 (void) restore_line_pointer (c);
7431 input_line_pointer++;
7432 alignment = get_absolute_expression ();
7433 if (exact_log2 (alignment) == -1)
7435 as_bad (_("Alignment must be a power of 2"));
7439 else if ((strncasecmp (name, "access", 6) == 0))
7441 (void) restore_line_pointer (c);
7442 input_line_pointer++;
7443 access_ctr = get_absolute_expression ();
7445 else if ((strncasecmp (name, "sort", 4) == 0))
7447 (void) restore_line_pointer (c);
7448 input_line_pointer++;
7449 sort = get_absolute_expression ();
7451 else if ((strncasecmp (name, "code_only", 9) == 0))
7453 (void) restore_line_pointer (c);
7456 else if ((strncasecmp (name, "unloadable", 10) == 0))
7458 (void) restore_line_pointer (c);
7461 else if ((strncasecmp (name, "comdat", 6) == 0))
7463 (void) restore_line_pointer (c);
7466 else if ((strncasecmp (name, "common", 6) == 0))
7468 (void) restore_line_pointer (c);
7471 else if ((strncasecmp (name, "dup_comm", 8) == 0))
7473 (void) restore_line_pointer (c);
7476 else if ((strncasecmp (name, "zero", 4) == 0))
7478 (void) restore_line_pointer (c);
7481 else if ((strncasecmp (name, "first", 5) == 0))
7482 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7484 as_bad (_("Invalid .SUBSPACE argument"));
7486 if (!is_end_of_statement ())
7487 input_line_pointer++;
7491 /* Compute a reasonable set of BFD flags based on the information
7492 in the .subspace directive. */
7493 applicable = bfd_applicable_section_flags (stdoutput);
7496 flags |= (SEC_ALLOC | SEC_LOAD);
7500 /* These flags are used to implement various flavors of initialized
7501 common. The SOM linker discards duplicate subspaces when they
7502 have the same "key" symbol name. This support is more like
7503 GNU linkonce than BFD common. Further, pc-relative relocations
7504 are converted to section relative relocations in BFD common
7505 sections. This complicates the handling of relocations in
7506 common sections containing text and isn't currently supported
7507 correctly in the SOM BFD backend. */
7508 if (comdat || common || dup_common)
7509 flags |= SEC_LINK_ONCE;
7511 flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7513 /* This is a zero-filled subspace (eg BSS). */
7515 flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7517 applicable &= flags;
7519 /* If this is an existing subspace, then we want to use the
7520 segment already associated with the subspace.
7522 FIXME NOW! ELF BFD doesn't appear to be ready to deal with
7523 lots of sections. It might be a problem in the PA ELF
7524 code, I do not know yet. For now avoid creating anything
7525 but the "standard" sections for ELF. */
7527 section = subseg_force_new (ss_name, 0);
7529 section = ssd->ssd_seg;
7531 section = subseg_new (ss_name, 0);
7534 seg_info (section)->bss = 1;
7536 /* Now set the flags. */
7537 bfd_set_section_flags (stdoutput, section, applicable);
7539 /* Record any alignment request for this section. */
7540 record_alignment (section, exact_log2 (alignment));
7542 /* Set the starting offset for this section. */
7543 bfd_set_section_vma (stdoutput, section,
7544 pa_subspace_start (space, quadrant));
7546 /* Now that all the flags are set, update an existing subspace,
7547 or create a new one. */
7550 current_subspace = update_subspace (space, ss_name, loadable,
7551 code_only, comdat, common,
7552 dup_common, sort, zero, access_ctr,
7553 space_index, alignment, quadrant,
7556 current_subspace = create_new_subspace (space, ss_name, loadable,
7557 code_only, comdat, common,
7558 dup_common, zero, sort,
7559 access_ctr, space_index,
7560 alignment, quadrant, section);
7562 demand_empty_rest_of_line ();
7563 current_subspace->ssd_seg = section;
7564 subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7566 SUBSPACE_DEFINED (current_subspace) = 1;
7569 /* Create default space and subspace dictionaries. */
7572 pa_spaces_begin (void)
7576 space_dict_root = NULL;
7577 space_dict_last = NULL;
7580 while (pa_def_spaces[i].name)
7584 /* Pick the right name to use for the new section. */
7585 name = pa_def_spaces[i].name;
7587 pa_def_spaces[i].segment = subseg_new (name, 0);
7588 create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7589 pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7590 pa_def_spaces[i].private, pa_def_spaces[i].sort,
7591 pa_def_spaces[i].segment, 0);
7596 while (pa_def_subspaces[i].name)
7599 int applicable, subsegment;
7600 asection *segment = NULL;
7601 sd_chain_struct *space;
7603 /* Pick the right name for the new section and pick the right
7604 subsegment number. */
7605 name = pa_def_subspaces[i].name;
7608 /* Create the new section. */
7609 segment = subseg_new (name, subsegment);
7611 /* For SOM we want to replace the standard .text, .data, and .bss
7612 sections with our own. We also want to set BFD flags for
7613 all the built-in subspaces. */
7614 if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
7616 text_section = segment;
7617 applicable = bfd_applicable_section_flags (stdoutput);
7618 bfd_set_section_flags (stdoutput, segment,
7619 applicable & (SEC_ALLOC | SEC_LOAD
7620 | SEC_RELOC | SEC_CODE
7622 | SEC_HAS_CONTENTS));
7624 else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
7626 data_section = segment;
7627 applicable = bfd_applicable_section_flags (stdoutput);
7628 bfd_set_section_flags (stdoutput, segment,
7629 applicable & (SEC_ALLOC | SEC_LOAD
7631 | SEC_HAS_CONTENTS));
7634 else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
7636 bss_section = segment;
7637 applicable = bfd_applicable_section_flags (stdoutput);
7638 bfd_set_section_flags (stdoutput, segment,
7639 applicable & SEC_ALLOC);
7641 else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
7643 applicable = bfd_applicable_section_flags (stdoutput);
7644 bfd_set_section_flags (stdoutput, segment,
7645 applicable & (SEC_ALLOC | SEC_LOAD
7648 | SEC_HAS_CONTENTS));
7650 else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
7652 applicable = bfd_applicable_section_flags (stdoutput);
7653 bfd_set_section_flags (stdoutput, segment,
7654 applicable & (SEC_ALLOC | SEC_LOAD
7657 | SEC_HAS_CONTENTS));
7659 else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
7661 applicable = bfd_applicable_section_flags (stdoutput);
7662 bfd_set_section_flags (stdoutput, segment,
7663 applicable & (SEC_ALLOC | SEC_LOAD
7666 | SEC_HAS_CONTENTS));
7669 /* Find the space associated with this subspace. */
7670 space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7671 def_space_index].segment);
7674 as_fatal (_("Internal error: Unable to find containing space for %s."),
7675 pa_def_subspaces[i].name);
7678 create_new_subspace (space, name,
7679 pa_def_subspaces[i].loadable,
7680 pa_def_subspaces[i].code_only,
7681 pa_def_subspaces[i].comdat,
7682 pa_def_subspaces[i].common,
7683 pa_def_subspaces[i].dup_common,
7684 pa_def_subspaces[i].zero,
7685 pa_def_subspaces[i].sort,
7686 pa_def_subspaces[i].access,
7687 pa_def_subspaces[i].space_index,
7688 pa_def_subspaces[i].alignment,
7689 pa_def_subspaces[i].quadrant,
7695 /* Create a new space NAME, with the appropriate flags as defined
7696 by the given parameters. */
7698 static sd_chain_struct *
7699 create_new_space (const char *name,
7701 int loadable ATTRIBUTE_UNUSED,
7708 sd_chain_struct *chain_entry;
7710 chain_entry = XNEW (sd_chain_struct);
7711 SPACE_NAME (chain_entry) = xstrdup (name);
7712 SPACE_DEFINED (chain_entry) = defined;
7713 SPACE_USER_DEFINED (chain_entry) = user_defined;
7714 SPACE_SPNUM (chain_entry) = spnum;
7716 chain_entry->sd_seg = seg;
7717 chain_entry->sd_last_subseg = -1;
7718 chain_entry->sd_subspaces = NULL;
7719 chain_entry->sd_next = NULL;
7721 /* Find spot for the new space based on its sort key. */
7722 if (!space_dict_last)
7723 space_dict_last = chain_entry;
7725 if (space_dict_root == NULL)
7726 space_dict_root = chain_entry;
7729 sd_chain_struct *chain_pointer;
7730 sd_chain_struct *prev_chain_pointer;
7732 chain_pointer = space_dict_root;
7733 prev_chain_pointer = NULL;
7735 while (chain_pointer)
7737 prev_chain_pointer = chain_pointer;
7738 chain_pointer = chain_pointer->sd_next;
7741 /* At this point we've found the correct place to add the new
7742 entry. So add it and update the linked lists as appropriate. */
7743 if (prev_chain_pointer)
7745 chain_entry->sd_next = chain_pointer;
7746 prev_chain_pointer->sd_next = chain_entry;
7750 space_dict_root = chain_entry;
7751 chain_entry->sd_next = chain_pointer;
7754 if (chain_entry->sd_next == NULL)
7755 space_dict_last = chain_entry;
7758 /* This is here to catch predefined spaces which do not get
7759 modified by the user's input. Another call is found at
7760 the bottom of pa_parse_space_stmt to handle cases where
7761 the user modifies a predefined space. */
7762 #ifdef obj_set_section_attributes
7763 obj_set_section_attributes (seg, defined, private, sort, spnum);
7769 /* Create a new subspace NAME, with the appropriate flags as defined
7770 by the given parameters.
7772 Add the new subspace to the subspace dictionary chain in numerical
7773 order as defined by the SORT entries. */
7775 static ssd_chain_struct *
7776 create_new_subspace (sd_chain_struct *space,
7778 int loadable ATTRIBUTE_UNUSED,
7779 int code_only ATTRIBUTE_UNUSED,
7783 int is_zero ATTRIBUTE_UNUSED,
7786 int space_index ATTRIBUTE_UNUSED,
7787 int alignment ATTRIBUTE_UNUSED,
7791 ssd_chain_struct *chain_entry;
7793 chain_entry = XNEW (ssd_chain_struct);
7794 SUBSPACE_NAME (chain_entry) = xstrdup (name);
7796 /* Initialize subspace_defined. When we hit a .subspace directive
7797 we'll set it to 1 which "locks-in" the subspace attributes. */
7798 SUBSPACE_DEFINED (chain_entry) = 0;
7800 chain_entry->ssd_subseg = 0;
7801 chain_entry->ssd_seg = seg;
7802 chain_entry->ssd_next = NULL;
7804 /* Find spot for the new subspace based on its sort key. */
7805 if (space->sd_subspaces == NULL)
7806 space->sd_subspaces = chain_entry;
7809 ssd_chain_struct *chain_pointer;
7810 ssd_chain_struct *prev_chain_pointer;
7812 chain_pointer = space->sd_subspaces;
7813 prev_chain_pointer = NULL;
7815 while (chain_pointer)
7817 prev_chain_pointer = chain_pointer;
7818 chain_pointer = chain_pointer->ssd_next;
7821 /* Now we have somewhere to put the new entry. Insert it and update
7823 if (prev_chain_pointer)
7825 chain_entry->ssd_next = chain_pointer;
7826 prev_chain_pointer->ssd_next = chain_entry;
7830 space->sd_subspaces = chain_entry;
7831 chain_entry->ssd_next = chain_pointer;
7835 #ifdef obj_set_subsection_attributes
7836 obj_set_subsection_attributes (seg, space->sd_seg, access_ctr, sort,
7837 quadrant, comdat, common, dup_common);
7843 /* Update the information for the given subspace based upon the
7844 various arguments. Return the modified subspace chain entry. */
7846 static ssd_chain_struct *
7847 update_subspace (sd_chain_struct *space,
7849 int loadable ATTRIBUTE_UNUSED,
7850 int code_only ATTRIBUTE_UNUSED,
7855 int zero ATTRIBUTE_UNUSED,
7857 int space_index ATTRIBUTE_UNUSED,
7858 int alignment ATTRIBUTE_UNUSED,
7862 ssd_chain_struct *chain_entry;
7864 chain_entry = is_defined_subspace (name);
7866 #ifdef obj_set_subsection_attributes
7867 obj_set_subsection_attributes (section, space->sd_seg, access_ctr, sort,
7868 quadrant, comdat, common, dup_common);
7874 /* Return the space chain entry for the space with the name NAME or
7875 NULL if no such space exists. */
7877 static sd_chain_struct *
7878 is_defined_space (const char *name)
7880 sd_chain_struct *chain_pointer;
7882 for (chain_pointer = space_dict_root;
7884 chain_pointer = chain_pointer->sd_next)
7885 if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
7886 return chain_pointer;
7888 /* No mapping from segment to space was found. Return NULL. */
7892 /* Find and return the space associated with the given seg. If no mapping
7893 from the given seg to a space is found, then return NULL.
7895 Unlike subspaces, the number of spaces is not expected to grow much,
7896 so a linear exhaustive search is OK here. */
7898 static sd_chain_struct *
7899 pa_segment_to_space (asection *seg)
7901 sd_chain_struct *space_chain;
7903 /* Walk through each space looking for the correct mapping. */
7904 for (space_chain = space_dict_root;
7906 space_chain = space_chain->sd_next)
7907 if (space_chain->sd_seg == seg)
7910 /* Mapping was not found. Return NULL. */
7914 /* Return the first space chain entry for the subspace with the name
7915 NAME or NULL if no such subspace exists.
7917 When there are multiple subspaces with the same name, switching to
7918 the first (i.e., default) subspace is preferable in most situations.
7919 For example, it wouldn't be desirable to merge COMDAT data with non
7922 Uses a linear search through all the spaces and subspaces, this may
7923 not be appropriate if we ever being placing each function in its
7926 static ssd_chain_struct *
7927 is_defined_subspace (const char *name)
7929 sd_chain_struct *space_chain;
7930 ssd_chain_struct *subspace_chain;
7932 /* Walk through each space. */
7933 for (space_chain = space_dict_root;
7935 space_chain = space_chain->sd_next)
7937 /* Walk through each subspace looking for a name which matches. */
7938 for (subspace_chain = space_chain->sd_subspaces;
7940 subspace_chain = subspace_chain->ssd_next)
7941 if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
7942 return subspace_chain;
7945 /* Subspace wasn't found. Return NULL. */
7949 /* Find and return the subspace associated with the given seg. If no
7950 mapping from the given seg to a subspace is found, then return NULL.
7952 If we ever put each procedure/function within its own subspace
7953 (to make life easier on the compiler and linker), then this will have
7954 to become more efficient. */
7956 static ssd_chain_struct *
7957 pa_subsegment_to_subspace (asection *seg, subsegT subseg)
7959 sd_chain_struct *space_chain;
7960 ssd_chain_struct *subspace_chain;
7962 /* Walk through each space. */
7963 for (space_chain = space_dict_root;
7965 space_chain = space_chain->sd_next)
7967 if (space_chain->sd_seg == seg)
7969 /* Walk through each subspace within each space looking for
7970 the correct mapping. */
7971 for (subspace_chain = space_chain->sd_subspaces;
7973 subspace_chain = subspace_chain->ssd_next)
7974 if (subspace_chain->ssd_subseg == (int) subseg)
7975 return subspace_chain;
7979 /* No mapping from subsegment to subspace found. Return NULL. */
7983 /* Given a number, try and find a space with the name number.
7985 Return a pointer to a space dictionary chain entry for the space
7986 that was found or NULL on failure. */
7988 static sd_chain_struct *
7989 pa_find_space_by_number (int number)
7991 sd_chain_struct *space_chain;
7993 for (space_chain = space_dict_root;
7995 space_chain = space_chain->sd_next)
7997 if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8001 /* No appropriate space found. Return NULL. */
8005 /* Return the starting address for the given subspace. If the starting
8006 address is unknown then return zero. */
8009 pa_subspace_start (sd_chain_struct *space, int quadrant)
8011 /* FIXME. Assumes everyone puts read/write data at 0x4000000, this
8012 is not correct for the PA OSF1 port. */
8013 if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8015 else if (space->sd_seg == data_section && quadrant == 1)
8023 /* Helper function for pa_stringer. Used to find the end of
8027 pa_stringer_aux (char *s)
8029 unsigned int c = *s & CHAR_MASK;
8042 /* Handle a .STRING type pseudo-op. */
8045 pa_stringer (int append_zero)
8047 char *s, num_buf[4];
8051 /* Preprocess the string to handle PA-specific escape sequences.
8052 For example, \xDD where DD is a hexadecimal number should be
8053 changed to \OOO where OOO is an octal number. */
8056 /* We must have a valid space and subspace. */
8057 pa_check_current_space_and_subspace ();
8060 /* Skip the opening quote. */
8061 s = input_line_pointer + 1;
8063 while (is_a_char (c = pa_stringer_aux (s++)))
8070 /* Handle \x<num>. */
8073 unsigned int number;
8078 /* Get past the 'x'. */
8080 for (num_digit = 0, number = 0, dg = *s;
8082 && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
8083 || (dg >= 'A' && dg <= 'F'));
8087 number = number * 16 + dg - '0';
8088 else if (dg >= 'a' && dg <= 'f')
8089 number = number * 16 + dg - 'a' + 10;
8091 number = number * 16 + dg - 'A' + 10;
8101 sprintf (num_buf, "%02o", number);
8104 sprintf (num_buf, "%03o", number);
8107 for (i = 0; i <= num_digit; i++)
8108 s_start[i] = num_buf[i];
8112 /* This might be a "\"", skip over the escaped char. */
8119 stringer (8 + append_zero);
8120 pa_undefine_label ();
8123 /* Handle a .VERSION pseudo-op. */
8126 pa_version (int unused ATTRIBUTE_UNUSED)
8129 pa_undefine_label ();
8134 /* Handle a .COMPILER pseudo-op. */
8137 pa_compiler (int unused ATTRIBUTE_UNUSED)
8139 obj_som_compiler (0);
8140 pa_undefine_label ();
8145 /* Handle a .COPYRIGHT pseudo-op. */
8148 pa_copyright (int unused ATTRIBUTE_UNUSED)
8151 pa_undefine_label ();
8154 /* Just like a normal cons, but when finished we have to undefine
8155 the latest space label. */
8158 pa_cons (int nbytes)
8161 pa_undefine_label ();
8164 /* Like float_cons, but we need to undefine our label. */
8167 pa_float_cons (int float_type)
8169 float_cons (float_type);
8170 pa_undefine_label ();
8173 /* Like s_fill, but delete our label when finished. */
8176 pa_fill (int unused ATTRIBUTE_UNUSED)
8179 /* We must have a valid space and subspace. */
8180 pa_check_current_space_and_subspace ();
8184 pa_undefine_label ();
8187 /* Like lcomm, but delete our label when finished. */
8190 pa_lcomm (int needs_align)
8193 /* We must have a valid space and subspace. */
8194 pa_check_current_space_and_subspace ();
8197 s_lcomm (needs_align);
8198 pa_undefine_label ();
8201 /* Like lsym, but delete our label when finished. */
8204 pa_lsym (int unused ATTRIBUTE_UNUSED)
8207 /* We must have a valid space and subspace. */
8208 pa_check_current_space_and_subspace ();
8212 pa_undefine_label ();
8215 /* This function is called once, at assembler startup time. It should
8216 set up all the tables, etc. that the MD part of the assembler will need. */
8221 const char *retval = NULL;
8225 last_call_info = NULL;
8226 call_info_root = NULL;
8228 /* Set the default machine type. */
8229 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, DEFAULT_LEVEL))
8230 as_warn (_("could not set architecture and machine"));
8232 /* Folding of text and data segments fails miserably on the PA.
8233 Warn user and disable "-R" option. */
8234 if (flag_readonly_data_in_text)
8236 as_warn (_("-R option not supported on this target."));
8237 flag_readonly_data_in_text = 0;
8244 op_hash = hash_new ();
8246 while (i < NUMOPCODES)
8248 const char *name = pa_opcodes[i].name;
8250 retval = hash_insert (op_hash, name, (struct pa_opcode *) &pa_opcodes[i]);
8251 if (retval != NULL && *retval != '\0')
8253 as_fatal (_("Internal error: can't hash `%s': %s\n"), name, retval);
8259 if ((pa_opcodes[i].match & pa_opcodes[i].mask)
8260 != pa_opcodes[i].match)
8262 fprintf (stderr, _("internal error: losing opcode: `%s' \"%s\"\n"),
8263 pa_opcodes[i].name, pa_opcodes[i].args);
8268 while (i < NUMOPCODES && !strcmp (pa_opcodes[i].name, name));
8272 as_fatal (_("Broken assembler. No assembly attempted."));
8275 /* SOM will change text_section. To make sure we never put
8276 anything into the old one switch to the new one now. */
8277 subseg_set (text_section, 0);
8281 dummy_symbol = symbol_find_or_make ("L$dummy");
8282 S_SET_SEGMENT (dummy_symbol, text_section);
8283 /* Force the symbol to be converted to a real symbol. */
8284 symbol_get_bfdsym (dummy_symbol)->flags |= BSF_KEEP;
8288 /* On the PA relocations which involve function symbols must not be
8289 adjusted. This so that the linker can know when/how to create argument
8290 relocation stubs for indirect calls and calls to static functions.
8292 "T" field selectors create DLT relative fixups for accessing
8293 globals and statics in PIC code; each DLT relative fixup creates
8294 an entry in the DLT table. The entries contain the address of
8295 the final target (eg accessing "foo" would create a DLT entry
8296 with the address of "foo").
8298 Unfortunately, the HP linker doesn't take into account any addend
8299 when generating the DLT; so accessing $LIT$+8 puts the address of
8300 $LIT$ into the DLT rather than the address of $LIT$+8.
8302 The end result is we can't perform relocation symbol reductions for
8303 any fixup which creates entries in the DLT (eg they use "T" field
8306 ??? Reject reductions involving symbols with external scope; such
8307 reductions make life a living hell for object file editors. */
8310 hppa_fix_adjustable (fixS *fixp)
8315 struct hppa_fix_struct *hppa_fix;
8317 hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8320 /* LR/RR selectors are implicitly used for a number of different relocation
8321 types. We must ensure that none of these types are adjusted (see below)
8322 even if they occur with a different selector. */
8323 code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8324 hppa_fix->fx_r_format,
8325 hppa_fix->fx_r_field);
8329 /* Relocation types which use e_lrsel. */
8330 case R_PARISC_DIR21L:
8331 case R_PARISC_DLTREL21L:
8332 case R_PARISC_DPREL21L:
8333 case R_PARISC_PLTOFF21L:
8335 /* Relocation types which use e_rrsel. */
8336 case R_PARISC_DIR14R:
8337 case R_PARISC_DIR14DR:
8338 case R_PARISC_DIR14WR:
8339 case R_PARISC_DIR17R:
8340 case R_PARISC_DLTREL14R:
8341 case R_PARISC_DLTREL14DR:
8342 case R_PARISC_DLTREL14WR:
8343 case R_PARISC_DPREL14R:
8344 case R_PARISC_DPREL14DR:
8345 case R_PARISC_DPREL14WR:
8346 case R_PARISC_PLTOFF14R:
8347 case R_PARISC_PLTOFF14DR:
8348 case R_PARISC_PLTOFF14WR:
8350 /* Other types that we reject for reduction. */
8351 case R_PARISC_GNU_VTENTRY:
8352 case R_PARISC_GNU_VTINHERIT:
8359 /* Reject reductions of symbols in sym1-sym2 expressions when
8360 the fixup will occur in a CODE subspace.
8362 XXX FIXME: Long term we probably want to reject all of these;
8363 for example reducing in the debug section would lose if we ever
8364 supported using the optimizing hp linker. */
8367 && (hppa_fix->segment->flags & SEC_CODE))
8370 /* We can't adjust any relocs that use LR% and RR% field selectors.
8372 If a symbol is reduced to a section symbol, the assembler will
8373 adjust the addend unless the symbol happens to reside right at
8374 the start of the section. Additionally, the linker has no choice
8375 but to manipulate the addends when coalescing input sections for
8376 "ld -r". Since an LR% field selector is defined to round the
8377 addend, we can't change the addend without risking that a LR% and
8378 it's corresponding (possible multiple) RR% field will no longer
8379 sum to the right value.
8382 . ldil LR%foo+0,%r21
8383 . ldw RR%foo+0(%r21),%r26
8384 . ldw RR%foo+4(%r21),%r25
8386 If foo is at address 4092 (decimal) in section `sect', then after
8387 reducing to the section symbol we get
8388 . LR%sect+4092 == (L%sect)+0
8389 . RR%sect+4092 == (R%sect)+4092
8390 . RR%sect+4096 == (R%sect)-4096
8391 and the last address loses because rounding the addend to 8k
8392 multiples takes us up to 8192 with an offset of -4096.
8394 In cases where the LR% expression is identical to the RR% one we
8395 will never have a problem, but is so happens that gcc rounds
8396 addends involved in LR% field selectors to work around a HP
8397 linker bug. ie. We often have addresses like the last case
8398 above where the LR% expression is offset from the RR% one. */
8400 if (hppa_fix->fx_r_field == e_lrsel
8401 || hppa_fix->fx_r_field == e_rrsel
8402 || hppa_fix->fx_r_field == e_nlrsel)
8405 /* Reject reductions of symbols in DLT relative relocs,
8406 relocations with plabels. */
8407 if (hppa_fix->fx_r_field == e_tsel
8408 || hppa_fix->fx_r_field == e_ltsel
8409 || hppa_fix->fx_r_field == e_rtsel
8410 || hppa_fix->fx_r_field == e_psel
8411 || hppa_fix->fx_r_field == e_rpsel
8412 || hppa_fix->fx_r_field == e_lpsel)
8415 /* Reject absolute calls (jumps). */
8416 if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8419 /* Reject reductions of function symbols. */
8420 if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8426 /* Return nonzero if the fixup in FIXP will require a relocation,
8427 even it if appears that the fixup could be completely handled
8431 hppa_force_relocation (struct fix *fixp)
8433 struct hppa_fix_struct *hppa_fixp;
8435 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8437 if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8438 || fixp->fx_r_type == (int) R_HPPA_EXIT
8439 || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8440 || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8441 || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8442 || fixp->fx_r_type == (int) R_HPPA_END_TRY
8443 || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8444 && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8448 if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8449 || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8453 gas_assert (fixp->fx_addsy != NULL);
8455 /* Ensure we emit a relocation for global symbols so that dynamic
8457 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
8460 /* It is necessary to force PC-relative calls/jumps to have a relocation
8461 entry if they're going to need either an argument relocation or long
8464 && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8465 hppa_fixp->fx_arg_reloc))
8468 /* Now check to see if we're going to need a long-branch stub. */
8469 if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8471 long pc = md_pcrel_from (fixp);
8472 valueT distance, min_stub_distance;
8474 distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8476 /* Distance to the closest possible stub. This will detect most
8477 but not all circumstances where a stub will not work. */
8478 min_stub_distance = pc + 16;
8480 if (last_call_info != NULL)
8481 min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
8484 if ((distance + 8388608 >= 16777216
8485 && min_stub_distance <= 8388608)
8486 || (hppa_fixp->fx_r_format == 17
8487 && distance + 262144 >= 524288
8488 && min_stub_distance <= 262144)
8489 || (hppa_fixp->fx_r_format == 12
8490 && distance + 8192 >= 16384
8491 && min_stub_distance <= 8192)
8496 if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
8499 /* No need (yet) to force another relocations to be emitted. */
8503 /* Now for some ELF specific code. FIXME. */
8505 /* For ELF, this function serves one purpose: to setup the st_size
8506 field of STT_FUNC symbols. To do this, we need to scan the
8507 call_info structure list, determining st_size in by taking the
8508 difference in the address of the beginning/end marker symbols. */
8511 elf_hppa_final_processing (void)
8513 struct call_info *call_info_pointer;
8515 for (call_info_pointer = call_info_root;
8517 call_info_pointer = call_info_pointer->ci_next)
8519 elf_symbol_type *esym
8520 = ((elf_symbol_type *)
8521 symbol_get_bfdsym (call_info_pointer->start_symbol));
8522 esym->internal_elf_sym.st_size =
8523 S_GET_VALUE (call_info_pointer->end_symbol)
8524 - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8529 pa_vtable_entry (int ignore ATTRIBUTE_UNUSED)
8531 struct fix *new_fix;
8533 new_fix = obj_elf_get_vtable_entry ();
8537 struct hppa_fix_struct * hppa_fix = XOBNEW (¬es, struct hppa_fix_struct);
8539 hppa_fix->fx_r_type = R_HPPA;
8540 hppa_fix->fx_r_field = e_fsel;
8541 hppa_fix->fx_r_format = 32;
8542 hppa_fix->fx_arg_reloc = 0;
8543 hppa_fix->segment = now_seg;
8544 new_fix->tc_fix_data = (void *) hppa_fix;
8545 new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8550 pa_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
8552 struct fix *new_fix;
8554 new_fix = obj_elf_get_vtable_inherit ();
8558 struct hppa_fix_struct * hppa_fix = XOBNEW (¬es, struct hppa_fix_struct);
8560 hppa_fix->fx_r_type = R_HPPA;
8561 hppa_fix->fx_r_field = e_fsel;
8562 hppa_fix->fx_r_format = 32;
8563 hppa_fix->fx_arg_reloc = 0;
8564 hppa_fix->segment = now_seg;
8565 new_fix->tc_fix_data = (void *) hppa_fix;
8566 new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8571 /* Table of pseudo ops for the PA. FIXME -- how many of these
8572 are now redundant with the overall GAS and the object file
8573 dependent tables? */
8574 const pseudo_typeS md_pseudo_table[] =
8576 /* align pseudo-ops on the PA specify the actual alignment requested,
8577 not the log2 of the requested alignment. */
8579 {"align", pa_align, 8},
8582 {"align", s_align_bytes, 8},
8584 {"begin_brtab", pa_brtab, 1},
8585 {"begin_try", pa_try, 1},
8586 {"block", pa_block, 1},
8587 {"blockz", pa_block, 0},
8588 {"byte", pa_cons, 1},
8589 {"call", pa_call, 0},
8590 {"callinfo", pa_callinfo, 0},
8591 #if defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))
8592 {"code", obj_elf_text, 0},
8594 {"code", pa_text, 0},
8595 {"comm", pa_comm, 0},
8598 {"compiler", pa_compiler, 0},
8600 {"copyright", pa_copyright, 0},
8601 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8602 {"data", pa_data, 0},
8604 {"double", pa_float_cons, 'd'},
8605 {"dword", pa_cons, 8},
8607 {"end_brtab", pa_brtab, 0},
8608 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8609 {"end_try", pa_try, 0},
8611 {"enter", pa_enter, 0},
8612 {"entry", pa_entry, 0},
8614 {"exit", pa_exit, 0},
8615 {"export", pa_export, 0},
8616 {"fill", pa_fill, 0},
8617 {"float", pa_float_cons, 'f'},
8618 {"half", pa_cons, 2},
8619 {"import", pa_import, 0},
8620 {"int", pa_cons, 4},
8621 {"label", pa_label, 0},
8622 {"lcomm", pa_lcomm, 0},
8623 {"leave", pa_leave, 0},
8624 {"level", pa_level, 0},
8625 {"long", pa_cons, 4},
8626 {"lsym", pa_lsym, 0},
8628 {"nsubspa", pa_subspace, 1},
8630 {"octa", pa_cons, 16},
8631 {"org", pa_origin, 0},
8632 {"origin", pa_origin, 0},
8633 {"param", pa_param, 0},
8634 {"proc", pa_proc, 0},
8635 {"procend", pa_procend, 0},
8636 {"quad", pa_cons, 8},
8638 {"short", pa_cons, 2},
8639 {"single", pa_float_cons, 'f'},
8641 {"space", pa_space, 0},
8642 {"spnum", pa_spnum, 0},
8644 {"string", pa_stringer, 0},
8645 {"stringz", pa_stringer, 1},
8647 {"subspa", pa_subspace, 0},
8649 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
8650 {"text", pa_text, 0},
8652 {"version", pa_version, 0},
8654 {"vtable_entry", pa_vtable_entry, 0},
8655 {"vtable_inherit", pa_vtable_inherit, 0},
8657 {"word", pa_cons, 4},
8663 hppa_cfi_frame_initial_instructions (void)
8665 cfi_add_CFA_def_cfa (30, 0);
8669 hppa_regname_to_dw2regnum (char *regname)
8671 unsigned int regnum = -1;
8675 static struct { const char *name; int dw2regnum; } regnames[] =
8677 { "sp", 30 }, { "rp", 2 },
8680 for (i = 0; i < ARRAY_SIZE (regnames); ++i)
8681 if (strcmp (regnames[i].name, regname) == 0)
8682 return regnames[i].dw2regnum;
8684 if (regname[0] == 'r')
8687 regnum = strtoul (p, &q, 10);
8688 if (p == q || *q || regnum >= 32)
8691 else if (regname[0] == 'f' && regname[1] == 'r')
8694 regnum = strtoul (p, &q, 10);
8695 #if TARGET_ARCH_SIZE == 64
8696 if (p == q || *q || regnum <= 4 || regnum >= 32)
8701 || (*q && ((*q != 'L' && *q != 'R') || *(q + 1)))
8702 || regnum <= 4 || regnum >= 32)
8704 regnum = (regnum - 4) * 2 + 32;