1 /* tc-hppa.c -- Assemble for the PA
2 Copyright 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* HP PA-RISC support was contributed by the Center for Software Science
23 at the University of Utah. */
28 #include "safe-ctype.h"
31 #include "bfd/libhppa.h"
33 /* Be careful, this file includes data *declarations*. */
34 #include "opcode/hppa.h"
36 #if defined (OBJ_ELF) && defined (OBJ_SOM)
37 error only one of OBJ_ELF
and OBJ_SOM can be defined
40 /* If we are using ELF, then we probably can support dwarf2 debug
41 records. Furthermore, if we are supporting dwarf2 debug records,
42 then we want to use the assembler support for compact line numbers. */
44 #include "dwarf2dbg.h"
46 /* A "convient" place to put object file dependencies which do
47 not need to be seen outside of tc-hppa.c. */
49 /* Object file formats specify relocation types. */
50 typedef enum elf_hppa_reloc_type reloc_type
;
52 /* Object file formats specify BFD symbol types. */
53 typedef elf_symbol_type obj_symbol_type
;
54 #define symbol_arg_reloc_info(sym)\
55 (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.hppa_arg_reloc)
57 #if TARGET_ARCH_SIZE == 64
58 /* How to generate a relocation. */
59 #define hppa_gen_reloc_type _bfd_elf64_hppa_gen_reloc_type
60 #define elf_hppa_reloc_final_type elf64_hppa_reloc_final_type
62 #define hppa_gen_reloc_type _bfd_elf32_hppa_gen_reloc_type
63 #define elf_hppa_reloc_final_type elf32_hppa_reloc_final_type
66 /* ELF objects can have versions, but apparently do not have anywhere
67 to store a copyright string. */
68 #define obj_version obj_elf_version
69 #define obj_copyright obj_elf_version
71 #define UNWIND_SECTION_NAME ".PARISC.unwind"
75 /* Names of various debugging spaces/subspaces. */
76 #define GDB_DEBUG_SPACE_NAME "$GDB_DEBUG$"
77 #define GDB_STRINGS_SUBSPACE_NAME "$GDB_STRINGS$"
78 #define GDB_SYMBOLS_SUBSPACE_NAME "$GDB_SYMBOLS$"
79 #define UNWIND_SECTION_NAME "$UNWIND$"
81 /* Object file formats specify relocation types. */
82 typedef int reloc_type
;
84 /* SOM objects can have both a version string and a copyright string. */
85 #define obj_version obj_som_version
86 #define obj_copyright obj_som_copyright
88 /* How to generate a relocation. */
89 #define hppa_gen_reloc_type hppa_som_gen_reloc_type
91 /* Object file formats specify BFD symbol types. */
92 typedef som_symbol_type obj_symbol_type
;
93 #define symbol_arg_reloc_info(sym)\
94 (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.ap.hppa_arg_reloc)
96 /* This apparently isn't in older versions of hpux reloc.h. */
98 #define R_DLT_REL 0x78
110 #if TARGET_ARCH_SIZE == 64
111 #define DEFAULT_LEVEL 25
113 #define DEFAULT_LEVEL 10
116 /* Various structures and types used internally in tc-hppa.c. */
118 /* Unwind table and descriptor. FIXME: Sync this with GDB version. */
122 unsigned int cannot_unwind
:1;
123 unsigned int millicode
:1;
124 unsigned int millicode_save_rest
:1;
125 unsigned int region_desc
:2;
126 unsigned int save_sr
:2;
127 unsigned int entry_fr
:4;
128 unsigned int entry_gr
:5;
129 unsigned int args_stored
:1;
130 unsigned int call_fr
:5;
131 unsigned int call_gr
:5;
132 unsigned int save_sp
:1;
133 unsigned int save_rp
:1;
134 unsigned int save_rp_in_frame
:1;
135 unsigned int extn_ptr_defined
:1;
136 unsigned int cleanup_defined
:1;
138 unsigned int hpe_interrupt_marker
:1;
139 unsigned int hpux_interrupt_marker
:1;
140 unsigned int reserved
:3;
141 unsigned int frame_size
:27;
144 /* We can't rely on compilers placing bitfields in any particular
145 place, so use these macros when dumping unwind descriptors to
147 #define UNWIND_LOW32(U) \
148 (((U)->cannot_unwind << 31) \
149 | ((U)->millicode << 30) \
150 | ((U)->millicode_save_rest << 29) \
151 | ((U)->region_desc << 27) \
152 | ((U)->save_sr << 25) \
153 | ((U)->entry_fr << 21) \
154 | ((U)->entry_gr << 16) \
155 | ((U)->args_stored << 15) \
156 | ((U)->call_fr << 10) \
157 | ((U)->call_gr << 5) \
158 | ((U)->save_sp << 4) \
159 | ((U)->save_rp << 3) \
160 | ((U)->save_rp_in_frame << 2) \
161 | ((U)->extn_ptr_defined << 1) \
162 | ((U)->cleanup_defined << 0))
164 #define UNWIND_HIGH32(U) \
165 (((U)->hpe_interrupt_marker << 31) \
166 | ((U)->hpux_interrupt_marker << 30) \
167 | ((U)->frame_size << 0))
171 /* Starting and ending offsets of the region described by
173 unsigned int start_offset
;
174 unsigned int end_offset
;
175 struct unwind_desc descriptor
;
178 /* This structure is used by the .callinfo, .enter, .leave pseudo-ops to
179 control the entry and exit code they generate. It is also used in
180 creation of the correct stack unwind descriptors.
182 NOTE: GAS does not support .enter and .leave for the generation of
183 prologues and epilogues. FIXME.
185 The fields in structure roughly correspond to the arguments available on the
186 .callinfo pseudo-op. */
190 /* The unwind descriptor being built. */
191 struct unwind_table ci_unwind
;
193 /* Name of this function. */
194 symbolS
*start_symbol
;
196 /* (temporary) symbol used to mark the end of this function. */
199 /* Next entry in the chain. */
200 struct call_info
*ci_next
;
203 /* Operand formats for FP instructions. Note not all FP instructions
204 allow all four formats to be used (for example fmpysub only allows
208 SGL
, DBL
, ILLEGAL_FMT
, QUAD
, W
, UW
, DW
, UDW
, QW
, UQW
212 /* This fully describes the symbol types which may be attached to
213 an EXPORT or IMPORT directive. Only SOM uses this formation
214 (ELF has no need for it). */
218 SYMBOL_TYPE_ABSOLUTE
,
222 SYMBOL_TYPE_MILLICODE
,
224 SYMBOL_TYPE_PRI_PROG
,
225 SYMBOL_TYPE_SEC_PROG
,
229 /* This structure contains information needed to assemble
230 individual instructions. */
233 /* Holds the opcode after parsing by pa_ip. */
234 unsigned long opcode
;
236 /* Holds an expression associated with the current instruction. */
239 /* Does this instruction use PC-relative addressing. */
242 /* Floating point formats for operand1 and operand2. */
243 fp_operand_format fpof1
;
244 fp_operand_format fpof2
;
246 /* Whether or not we saw a truncation request on an fcnv insn. */
249 /* Holds the field selector for this instruction
250 (for example L%, LR%, etc). */
253 /* Holds any argument relocation bits associated with this
254 instruction. (instruction should be some sort of call). */
255 unsigned int arg_reloc
;
257 /* The format specification for this instruction. */
260 /* The relocation (if any) associated with this instruction. */
264 /* PA-89 floating point registers are arranged like this:
266 +--------------+--------------+
267 | 0 or 16L | 16 or 16R |
268 +--------------+--------------+
269 | 1 or 17L | 17 or 17R |
270 +--------------+--------------+
278 +--------------+--------------+
279 | 14 or 30L | 30 or 30R |
280 +--------------+--------------+
281 | 15 or 31L | 31 or 31R |
282 +--------------+--------------+ */
284 /* Additional information needed to build argument relocation stubs. */
287 /* The argument relocation specification. */
288 unsigned int arg_reloc
;
290 /* Number of arguments. */
291 unsigned int arg_count
;
295 /* This structure defines an entry in the subspace dictionary
298 struct subspace_dictionary_chain
300 /* Nonzero if this space has been defined by the user code. */
301 unsigned int ssd_defined
;
303 /* Name of this subspace. */
306 /* GAS segment and subsegment associated with this subspace. */
310 /* Next space in the subspace dictionary chain. */
311 struct subspace_dictionary_chain
*ssd_next
;
314 typedef struct subspace_dictionary_chain ssd_chain_struct
;
316 /* This structure defines an entry in the subspace dictionary
319 struct space_dictionary_chain
321 /* Nonzero if this space has been defined by the user code or
322 as a default space. */
323 unsigned int sd_defined
;
325 /* Nonzero if this spaces has been defined by the user code. */
326 unsigned int sd_user_defined
;
328 /* The space number (or index). */
329 unsigned int sd_spnum
;
331 /* The name of this subspace. */
334 /* GAS segment to which this subspace corresponds. */
337 /* Current subsegment number being used. */
340 /* The chain of subspaces contained within this space. */
341 ssd_chain_struct
*sd_subspaces
;
343 /* The next entry in the space dictionary chain. */
344 struct space_dictionary_chain
*sd_next
;
347 typedef struct space_dictionary_chain sd_chain_struct
;
349 /* This structure defines attributes of the default subspace
350 dictionary entries. */
352 struct default_subspace_dict
354 /* Name of the subspace. */
357 /* FIXME. Is this still needed? */
360 /* Nonzero if this subspace is loadable. */
363 /* Nonzero if this subspace contains only code. */
366 /* Nonzero if this is a common subspace. */
369 /* Nonzero if this is a common subspace which allows symbols
370 to be multiply defined. */
373 /* Nonzero if this subspace should be zero filled. */
376 /* Sort key for this subspace. */
379 /* Access control bits for this subspace. Can represent RWX access
380 as well as privilege level changes for gateways. */
383 /* Index of containing space. */
386 /* Alignment (in bytes) of this subspace. */
389 /* Quadrant within space where this subspace should be loaded. */
392 /* An index into the default spaces array. */
395 /* Subsegment associated with this subspace. */
399 /* This structure defines attributes of the default space
400 dictionary entries. */
402 struct default_space_dict
404 /* Name of the space. */
407 /* Space number. It is possible to identify spaces within
408 assembly code numerically! */
411 /* Nonzero if this space is loadable. */
414 /* Nonzero if this space is "defined". FIXME is still needed */
417 /* Nonzero if this space can not be shared. */
420 /* Sort key for this space. */
423 /* Segment associated with this space. */
428 /* Structure for previous label tracking. Needed so that alignments,
429 callinfo declarations, etc can be easily attached to a particular
431 typedef struct label_symbol_struct
433 struct symbol
*lss_label
;
435 sd_chain_struct
*lss_space
;
440 struct label_symbol_struct
*lss_next
;
444 /* Extra information needed to perform fixups (relocations) on the PA. */
445 struct hppa_fix_struct
447 /* The field selector. */
448 enum hppa_reloc_field_selector_type_alt fx_r_field
;
453 /* Format of fixup. */
456 /* Argument relocation bits. */
457 unsigned int fx_arg_reloc
;
459 /* The segment this fixup appears in. */
463 /* Structure to hold information about predefined registers. */
471 /* This structure defines the mapping from a FP condition string
472 to a condition number which can be recorded in an instruction. */
479 /* This structure defines a mapping from a field selector
480 string to a field selector type. */
481 struct selector_entry
487 /* Prototypes for functions local to tc-hppa.c. */
490 static void pa_check_current_space_and_subspace
PARAMS ((void));
493 #if !(defined (OBJ_ELF) && defined (TE_LINUX))
494 static void pa_text
PARAMS ((int));
495 static void pa_data
PARAMS ((int));
496 static void pa_comm
PARAMS ((int));
498 static fp_operand_format pa_parse_fp_format
PARAMS ((char **s
));
499 static void pa_cons
PARAMS ((int));
500 static void pa_float_cons
PARAMS ((int));
501 static void pa_fill
PARAMS ((int));
502 static void pa_lcomm
PARAMS ((int));
503 static void pa_lsym
PARAMS ((int));
504 static void pa_stringer
PARAMS ((int));
505 static void pa_version
PARAMS ((int));
506 static int pa_parse_fp_cmp_cond
PARAMS ((char **));
507 static int get_expression
PARAMS ((char *));
508 static int pa_get_absolute_expression
PARAMS ((struct pa_it
*, char **));
509 static int evaluate_absolute
PARAMS ((struct pa_it
*));
510 static unsigned int pa_build_arg_reloc
PARAMS ((char *));
511 static unsigned int pa_align_arg_reloc
PARAMS ((unsigned int, unsigned int));
512 static int pa_parse_nullif
PARAMS ((char **));
513 static int pa_parse_nonneg_cmpsub_cmpltr
PARAMS ((char **));
514 static int pa_parse_neg_cmpsub_cmpltr
PARAMS ((char **));
515 static int pa_parse_neg_add_cmpltr
PARAMS ((char **));
516 static int pa_parse_nonneg_add_cmpltr
PARAMS ((char **));
517 static int pa_parse_cmpb_64_cmpltr
PARAMS ((char **));
518 static int pa_parse_cmpib_64_cmpltr
PARAMS ((char **));
519 static int pa_parse_addb_64_cmpltr
PARAMS ((char **));
520 static void pa_block
PARAMS ((int));
521 static void pa_brtab
PARAMS ((int));
522 static void pa_try
PARAMS ((int));
523 static void pa_call
PARAMS ((int));
524 static void pa_call_args
PARAMS ((struct call_desc
*));
525 static void pa_callinfo
PARAMS ((int));
526 static void pa_copyright
PARAMS ((int));
527 static void pa_end
PARAMS ((int));
528 static void pa_enter
PARAMS ((int));
529 static void pa_entry
PARAMS ((int));
530 static void pa_equ
PARAMS ((int));
531 static void pa_exit
PARAMS ((int));
532 static void pa_export
PARAMS ((int));
533 static void pa_type_args
PARAMS ((symbolS
*, int));
534 static void pa_import
PARAMS ((int));
535 static void pa_label
PARAMS ((int));
536 static void pa_leave
PARAMS ((int));
537 static void pa_level
PARAMS ((int));
538 static void pa_origin
PARAMS ((int));
539 static void pa_proc
PARAMS ((int));
540 static void pa_procend
PARAMS ((int));
541 static void pa_param
PARAMS ((int));
542 static void pa_undefine_label
PARAMS ((void));
543 static int need_pa11_opcode
PARAMS ((void));
544 static int pa_parse_number
PARAMS ((char **, int));
545 static label_symbol_struct
*pa_get_label
PARAMS ((void));
547 static int log2
PARAMS ((int));
548 static void pa_compiler
PARAMS ((int));
549 static void pa_align
PARAMS ((int));
550 static void pa_space
PARAMS ((int));
551 static void pa_spnum
PARAMS ((int));
552 static void pa_subspace
PARAMS ((int));
553 static sd_chain_struct
*create_new_space
PARAMS ((char *, int, int,
556 static ssd_chain_struct
*create_new_subspace
PARAMS ((sd_chain_struct
*,
561 static ssd_chain_struct
*update_subspace
PARAMS ((sd_chain_struct
*,
562 char *, int, int, int,
566 static sd_chain_struct
*is_defined_space
PARAMS ((char *));
567 static ssd_chain_struct
*is_defined_subspace
PARAMS ((char *));
568 static sd_chain_struct
*pa_segment_to_space
PARAMS ((asection
*));
569 static ssd_chain_struct
*pa_subsegment_to_subspace
PARAMS ((asection
*,
571 static sd_chain_struct
*pa_find_space_by_number
PARAMS ((int));
572 static unsigned int pa_subspace_start
PARAMS ((sd_chain_struct
*, int));
573 static sd_chain_struct
*pa_parse_space_stmt
PARAMS ((char *, int));
574 static int pa_next_subseg
PARAMS ((sd_chain_struct
*));
575 static void pa_spaces_begin
PARAMS ((void));
577 static void pa_ip
PARAMS ((char *));
578 static void fix_new_hppa
PARAMS ((fragS
*, int, int, symbolS
*,
579 offsetT
, expressionS
*, int,
580 bfd_reloc_code_real_type
,
581 enum hppa_reloc_field_selector_type_alt
,
582 int, unsigned int, int));
583 static int is_end_of_statement
PARAMS ((void));
584 static int reg_name_search
PARAMS ((char *));
585 static int pa_chk_field_selector
PARAMS ((char **));
586 static int is_same_frag
PARAMS ((fragS
*, fragS
*));
587 static void process_exit
PARAMS ((void));
588 static unsigned int pa_stringer_aux
PARAMS ((char *));
589 static fp_operand_format pa_parse_fp_cnv_format
PARAMS ((char **s
));
590 static int pa_parse_ftest_gfx_completer
PARAMS ((char **));
593 static void hppa_elf_mark_end_of_function
PARAMS ((void));
594 static void pa_build_unwind_subspace
PARAMS ((struct call_info
*));
595 static void pa_vtable_entry
PARAMS ((int));
596 static void pa_vtable_inherit
PARAMS ((int));
599 /* File and gloally scoped variable declarations. */
602 /* Root and final entry in the space chain. */
603 static sd_chain_struct
*space_dict_root
;
604 static sd_chain_struct
*space_dict_last
;
606 /* The current space and subspace. */
607 static sd_chain_struct
*current_space
;
608 static ssd_chain_struct
*current_subspace
;
611 /* Root of the call_info chain. */
612 static struct call_info
*call_info_root
;
614 /* The last call_info (for functions) structure
615 seen so it can be associated with fixups and
617 static struct call_info
*last_call_info
;
619 /* The last call description (for actual calls). */
620 static struct call_desc last_call_desc
;
622 /* handle of the OPCODE hash table */
623 static struct hash_control
*op_hash
= NULL
;
625 /* Table of pseudo ops for the PA. FIXME -- how many of these
626 are now redundant with the overall GAS and the object file
628 const pseudo_typeS md_pseudo_table
[] =
630 /* align pseudo-ops on the PA specify the actual alignment requested,
631 not the log2 of the requested alignment. */
633 {"align", pa_align
, 8},
636 {"align", s_align_bytes
, 8},
638 {"begin_brtab", pa_brtab
, 1},
639 {"begin_try", pa_try
, 1},
640 {"block", pa_block
, 1},
641 {"blockz", pa_block
, 0},
642 {"byte", pa_cons
, 1},
643 {"call", pa_call
, 0},
644 {"callinfo", pa_callinfo
, 0},
645 #if defined (OBJ_ELF) && defined (TE_LINUX)
646 {"code", obj_elf_text
, 0},
648 {"code", pa_text
, 0},
649 {"comm", pa_comm
, 0},
652 {"compiler", pa_compiler
, 0},
654 {"copyright", pa_copyright
, 0},
655 #if !(defined (OBJ_ELF) && defined (TE_LINUX))
656 {"data", pa_data
, 0},
658 {"double", pa_float_cons
, 'd'},
659 {"dword", pa_cons
, 8},
661 {"end_brtab", pa_brtab
, 0},
662 #if !(defined (OBJ_ELF) && defined (TE_LINUX))
663 {"end_try", pa_try
, 0},
665 {"enter", pa_enter
, 0},
666 {"entry", pa_entry
, 0},
668 {"exit", pa_exit
, 0},
669 {"export", pa_export
, 0},
671 {"file", (void (*) PARAMS ((int))) dwarf2_directive_file
, 0 },
673 {"fill", pa_fill
, 0},
674 {"float", pa_float_cons
, 'f'},
675 {"half", pa_cons
, 2},
676 {"import", pa_import
, 0},
678 {"label", pa_label
, 0},
679 {"lcomm", pa_lcomm
, 0},
680 {"leave", pa_leave
, 0},
681 {"level", pa_level
, 0},
683 {"loc", dwarf2_directive_loc
, 0 },
685 {"long", pa_cons
, 4},
686 {"lsym", pa_lsym
, 0},
688 {"nsubspa", pa_subspace
, 1},
690 {"octa", pa_cons
, 16},
691 {"org", pa_origin
, 0},
692 {"origin", pa_origin
, 0},
693 {"param", pa_param
, 0},
694 {"proc", pa_proc
, 0},
695 {"procend", pa_procend
, 0},
696 {"quad", pa_cons
, 8},
698 {"short", pa_cons
, 2},
699 {"single", pa_float_cons
, 'f'},
701 {"space", pa_space
, 0},
702 {"spnum", pa_spnum
, 0},
704 {"string", pa_stringer
, 0},
705 {"stringz", pa_stringer
, 1},
707 {"subspa", pa_subspace
, 0},
709 #if !(defined (OBJ_ELF) && defined (TE_LINUX))
710 {"text", pa_text
, 0},
712 {"version", pa_version
, 0},
714 {"vtable_entry", pa_vtable_entry
, 0},
715 {"vtable_inherit", pa_vtable_inherit
, 0},
717 {"word", pa_cons
, 4},
721 /* This array holds the chars that only start a comment at the beginning of
722 a line. If the line seems to have the form '# 123 filename'
723 .line and .file directives will appear in the pre-processed output.
725 Note that input_file.c hand checks for '#' at the beginning of the
726 first line of the input file. This is because the compiler outputs
727 #NO_APP at the beginning of its output.
729 Also note that C style comments will always work. */
730 const char line_comment_chars
[] = "#";
732 /* This array holds the chars that always start a comment. If the
733 pre-processor is disabled, these aren't very useful. */
734 const char comment_chars
[] = ";";
736 /* This array holds the characters which act as line separators. */
737 const char line_separator_chars
[] = "!";
739 /* Chars that can be used to separate mant from exp in floating point nums. */
740 const char EXP_CHARS
[] = "eE";
742 /* Chars that mean this number is a floating point constant.
743 As in 0f12.456 or 0d1.2345e12.
745 Be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
746 changed in read.c. Ideally it shouldn't hae to know abou it at
747 all, but nothing is ideal around here. */
748 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
750 static struct pa_it the_insn
;
752 /* Points to the end of an expression just parsed by get_expressoin
753 and friends. FIXME. This shouldn't be handled with a file-global
755 static char *expr_end
;
757 /* Nonzero if a .callinfo appeared within the current procedure. */
758 static int callinfo_found
;
760 /* Nonzero if the assembler is currently within a .entry/.exit pair. */
761 static int within_entry_exit
;
763 /* Nonzero if the assembler is currently within a procedure definition. */
764 static int within_procedure
;
766 /* Handle on structure which keep track of the last symbol
767 seen in each subspace. */
768 static label_symbol_struct
*label_symbols_rootp
= NULL
;
770 /* Holds the last field selector. */
771 static int hppa_field_selector
;
773 /* Nonzero when strict syntax checking is enabled. Zero otherwise.
775 Each opcode in the table has a flag which indicates whether or not
776 strict syntax checking should be enabled for that instruction. */
777 static int strict
= 0;
779 /* pa_parse_number returns values in `pa_number'. Mostly
780 pa_parse_number is used to return a register number, with floating
781 point registers being numbered from FP_REG_BASE upwards.
782 The bit specified with FP_REG_RSEL is set if the floating point
783 register has a `r' suffix. */
784 #define FP_REG_BASE 64
785 #define FP_REG_RSEL 128
786 static int pa_number
;
789 /* A dummy bfd symbol so that all relocations have symbols of some kind. */
790 static symbolS
*dummy_symbol
;
793 /* Nonzero if errors are to be printed. */
794 static int print_errors
= 1;
796 /* List of registers that are pre-defined:
798 Each general register has one predefined name of the form
799 %r<REGNUM> which has the value <REGNUM>.
801 Space and control registers are handled in a similar manner,
802 but use %sr<REGNUM> and %cr<REGNUM> as their predefined names.
804 Likewise for the floating point registers, but of the form
805 %fr<REGNUM>. Floating point registers have additional predefined
806 names with 'L' and 'R' suffixes (e.g. %fr19L, %fr19R) which
807 again have the value <REGNUM>.
809 Many registers also have synonyms:
811 %r26 - %r23 have %arg0 - %arg3 as synonyms
812 %r28 - %r29 have %ret0 - %ret1 as synonyms
813 %r30 has %sp as a synonym
814 %r27 has %dp as a synonym
815 %r2 has %rp as a synonym
817 Almost every control register has a synonym; they are not listed
820 The table is sorted. Suitable for searching by a binary search. */
822 static const struct pd_reg pre_defined_registers
[] =
856 {"%fr0", 0 + FP_REG_BASE
},
857 {"%fr0l", 0 + FP_REG_BASE
},
858 {"%fr0r", 0 + FP_REG_BASE
+ FP_REG_RSEL
},
859 {"%fr1", 1 + FP_REG_BASE
},
860 {"%fr10", 10 + FP_REG_BASE
},
861 {"%fr10l", 10 + FP_REG_BASE
},
862 {"%fr10r", 10 + FP_REG_BASE
+ FP_REG_RSEL
},
863 {"%fr11", 11 + FP_REG_BASE
},
864 {"%fr11l", 11 + FP_REG_BASE
},
865 {"%fr11r", 11 + FP_REG_BASE
+ FP_REG_RSEL
},
866 {"%fr12", 12 + FP_REG_BASE
},
867 {"%fr12l", 12 + FP_REG_BASE
},
868 {"%fr12r", 12 + FP_REG_BASE
+ FP_REG_RSEL
},
869 {"%fr13", 13 + FP_REG_BASE
},
870 {"%fr13l", 13 + FP_REG_BASE
},
871 {"%fr13r", 13 + FP_REG_BASE
+ FP_REG_RSEL
},
872 {"%fr14", 14 + FP_REG_BASE
},
873 {"%fr14l", 14 + FP_REG_BASE
},
874 {"%fr14r", 14 + FP_REG_BASE
+ FP_REG_RSEL
},
875 {"%fr15", 15 + FP_REG_BASE
},
876 {"%fr15l", 15 + FP_REG_BASE
},
877 {"%fr15r", 15 + FP_REG_BASE
+ FP_REG_RSEL
},
878 {"%fr16", 16 + FP_REG_BASE
},
879 {"%fr16l", 16 + FP_REG_BASE
},
880 {"%fr16r", 16 + FP_REG_BASE
+ FP_REG_RSEL
},
881 {"%fr17", 17 + FP_REG_BASE
},
882 {"%fr17l", 17 + FP_REG_BASE
},
883 {"%fr17r", 17 + FP_REG_BASE
+ FP_REG_RSEL
},
884 {"%fr18", 18 + FP_REG_BASE
},
885 {"%fr18l", 18 + FP_REG_BASE
},
886 {"%fr18r", 18 + FP_REG_BASE
+ FP_REG_RSEL
},
887 {"%fr19", 19 + FP_REG_BASE
},
888 {"%fr19l", 19 + FP_REG_BASE
},
889 {"%fr19r", 19 + FP_REG_BASE
+ FP_REG_RSEL
},
890 {"%fr1l", 1 + FP_REG_BASE
},
891 {"%fr1r", 1 + FP_REG_BASE
+ FP_REG_RSEL
},
892 {"%fr2", 2 + FP_REG_BASE
},
893 {"%fr20", 20 + FP_REG_BASE
},
894 {"%fr20l", 20 + FP_REG_BASE
},
895 {"%fr20r", 20 + FP_REG_BASE
+ FP_REG_RSEL
},
896 {"%fr21", 21 + FP_REG_BASE
},
897 {"%fr21l", 21 + FP_REG_BASE
},
898 {"%fr21r", 21 + FP_REG_BASE
+ FP_REG_RSEL
},
899 {"%fr22", 22 + FP_REG_BASE
},
900 {"%fr22l", 22 + FP_REG_BASE
},
901 {"%fr22r", 22 + FP_REG_BASE
+ FP_REG_RSEL
},
902 {"%fr23", 23 + FP_REG_BASE
},
903 {"%fr23l", 23 + FP_REG_BASE
},
904 {"%fr23r", 23 + FP_REG_BASE
+ FP_REG_RSEL
},
905 {"%fr24", 24 + FP_REG_BASE
},
906 {"%fr24l", 24 + FP_REG_BASE
},
907 {"%fr24r", 24 + FP_REG_BASE
+ FP_REG_RSEL
},
908 {"%fr25", 25 + FP_REG_BASE
},
909 {"%fr25l", 25 + FP_REG_BASE
},
910 {"%fr25r", 25 + FP_REG_BASE
+ FP_REG_RSEL
},
911 {"%fr26", 26 + FP_REG_BASE
},
912 {"%fr26l", 26 + FP_REG_BASE
},
913 {"%fr26r", 26 + FP_REG_BASE
+ FP_REG_RSEL
},
914 {"%fr27", 27 + FP_REG_BASE
},
915 {"%fr27l", 27 + FP_REG_BASE
},
916 {"%fr27r", 27 + FP_REG_BASE
+ FP_REG_RSEL
},
917 {"%fr28", 28 + FP_REG_BASE
},
918 {"%fr28l", 28 + FP_REG_BASE
},
919 {"%fr28r", 28 + FP_REG_BASE
+ FP_REG_RSEL
},
920 {"%fr29", 29 + FP_REG_BASE
},
921 {"%fr29l", 29 + FP_REG_BASE
},
922 {"%fr29r", 29 + FP_REG_BASE
+ FP_REG_RSEL
},
923 {"%fr2l", 2 + FP_REG_BASE
},
924 {"%fr2r", 2 + FP_REG_BASE
+ FP_REG_RSEL
},
925 {"%fr3", 3 + FP_REG_BASE
},
926 {"%fr30", 30 + FP_REG_BASE
},
927 {"%fr30l", 30 + FP_REG_BASE
},
928 {"%fr30r", 30 + FP_REG_BASE
+ FP_REG_RSEL
},
929 {"%fr31", 31 + FP_REG_BASE
},
930 {"%fr31l", 31 + FP_REG_BASE
},
931 {"%fr31r", 31 + FP_REG_BASE
+ FP_REG_RSEL
},
932 {"%fr3l", 3 + FP_REG_BASE
},
933 {"%fr3r", 3 + FP_REG_BASE
+ FP_REG_RSEL
},
934 {"%fr4", 4 + FP_REG_BASE
},
935 {"%fr4l", 4 + FP_REG_BASE
},
936 {"%fr4r", 4 + FP_REG_BASE
+ FP_REG_RSEL
},
937 {"%fr5", 5 + FP_REG_BASE
},
938 {"%fr5l", 5 + FP_REG_BASE
},
939 {"%fr5r", 5 + FP_REG_BASE
+ FP_REG_RSEL
},
940 {"%fr6", 6 + FP_REG_BASE
},
941 {"%fr6l", 6 + FP_REG_BASE
},
942 {"%fr6r", 6 + FP_REG_BASE
+ FP_REG_RSEL
},
943 {"%fr7", 7 + FP_REG_BASE
},
944 {"%fr7l", 7 + FP_REG_BASE
},
945 {"%fr7r", 7 + FP_REG_BASE
+ FP_REG_RSEL
},
946 {"%fr8", 8 + FP_REG_BASE
},
947 {"%fr8l", 8 + FP_REG_BASE
},
948 {"%fr8r", 8 + FP_REG_BASE
+ FP_REG_RSEL
},
949 {"%fr9", 9 + FP_REG_BASE
},
950 {"%fr9l", 9 + FP_REG_BASE
},
951 {"%fr9r", 9 + FP_REG_BASE
+ FP_REG_RSEL
},
959 #if TARGET_ARCH_SIZE == 64
1027 /* This table is sorted by order of the length of the string. This is
1028 so we check for <> before we check for <. If we had a <> and checked
1029 for < first, we would get a false match. */
1030 static const struct fp_cond_map fp_cond_map
[] =
1066 static const struct selector_entry selector_table
[] =
1091 /* default space and subspace dictionaries */
1093 #define GDB_SYMBOLS GDB_SYMBOLS_SUBSPACE_NAME
1094 #define GDB_STRINGS GDB_STRINGS_SUBSPACE_NAME
1096 /* pre-defined subsegments (subspaces) for the HPPA. */
1097 #define SUBSEG_CODE 0
1098 #define SUBSEG_LIT 1
1099 #define SUBSEG_MILLI 2
1100 #define SUBSEG_DATA 0
1101 #define SUBSEG_BSS 2
1102 #define SUBSEG_UNWIND 3
1103 #define SUBSEG_GDB_STRINGS 0
1104 #define SUBSEG_GDB_SYMBOLS 1
1106 static struct default_subspace_dict pa_def_subspaces
[] =
1108 {"$CODE$", 1, 1, 1, 0, 0, 0, 24, 0x2c, 0, 8, 0, 0, SUBSEG_CODE
},
1109 {"$DATA$", 1, 1, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, SUBSEG_DATA
},
1110 {"$LIT$", 1, 1, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, SUBSEG_LIT
},
1111 {"$MILLICODE$", 1, 1, 0, 0, 0, 0, 8, 0x2c, 0, 8, 0, 0, SUBSEG_MILLI
},
1112 {"$BSS$", 1, 1, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, SUBSEG_BSS
},
1113 {NULL
, 0, 1, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
1116 static struct default_space_dict pa_def_spaces
[] =
1118 {"$TEXT$", 0, 1, 1, 0, 8, ASEC_NULL
},
1119 {"$PRIVATE$", 1, 1, 1, 1, 16, ASEC_NULL
},
1120 {NULL
, 0, 0, 0, 0, 0, ASEC_NULL
}
1123 /* Misc local definitions used by the assembler. */
1125 /* These macros are used to maintain spaces/subspaces. */
1126 #define SPACE_DEFINED(space_chain) (space_chain)->sd_defined
1127 #define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
1128 #define SPACE_SPNUM(space_chain) (space_chain)->sd_spnum
1129 #define SPACE_NAME(space_chain) (space_chain)->sd_name
1131 #define SUBSPACE_DEFINED(ss_chain) (ss_chain)->ssd_defined
1132 #define SUBSPACE_NAME(ss_chain) (ss_chain)->ssd_name
1135 /* Return nonzero if the string pointed to by S potentially represents
1136 a right or left half of a FP register */
1137 #define IS_R_SELECT(S) (*(S) == 'R' || *(S) == 'r')
1138 #define IS_L_SELECT(S) (*(S) == 'L' || *(S) == 'l')
1140 /* Insert FIELD into OPCODE starting at bit START. Continue pa_ip
1141 main loop after insertion. */
1143 #define INSERT_FIELD_AND_CONTINUE(OPCODE, FIELD, START) \
1145 ((OPCODE) |= (FIELD) << (START)); \
1149 /* Simple range checking for FIELD againt HIGH and LOW bounds.
1150 IGNORE is used to suppress the error message. */
1152 #define CHECK_FIELD(FIELD, HIGH, LOW, IGNORE) \
1154 if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1157 as_bad (_("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1163 /* Variant of CHECK_FIELD for use in md_apply_fix3 and other places where
1164 the current file and line number are not valid. */
1166 #define CHECK_FIELD_WHERE(FIELD, HIGH, LOW, FILENAME, LINE) \
1168 if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1170 as_bad_where ((FILENAME), (LINE), \
1171 _("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1177 /* Simple alignment checking for FIELD againt ALIGN (a power of two).
1178 IGNORE is used to suppress the error message. */
1180 #define CHECK_ALIGN(FIELD, ALIGN, IGNORE) \
1182 if ((FIELD) & ((ALIGN) - 1)) \
1185 as_bad (_("Field not properly aligned [%d] (%d)."), (ALIGN), \
1191 #define is_DP_relative(exp) \
1192 ((exp).X_op == O_subtract \
1193 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$global$") == 0)
1195 #define is_PC_relative(exp) \
1196 ((exp).X_op == O_subtract \
1197 && strcmp (S_GET_NAME ((exp).X_op_symbol), "$PIC_pcrel$0") == 0)
1199 /* We need some complex handling for stabs (sym1 - sym2). Luckily, we'll
1200 always be able to reduce the expression to a constant, so we don't
1201 need real complex handling yet. */
1202 #define is_complex(exp) \
1203 ((exp).X_op != O_constant && (exp).X_op != O_symbol)
1205 /* Actual functions to implement the PA specific code for the assembler. */
1207 /* Called before writing the object file. Make sure entry/exit and
1208 proc/procend pairs match. */
1213 if (within_entry_exit
)
1214 as_fatal (_("Missing .exit\n"));
1216 if (within_procedure
)
1217 as_fatal (_("Missing .procend\n"));
1220 /* Returns a pointer to the label_symbol_struct for the current space.
1221 or NULL if no label_symbol_struct exists for the current space. */
1223 static label_symbol_struct
*
1226 label_symbol_struct
*label_chain
;
1228 for (label_chain
= label_symbols_rootp
;
1230 label_chain
= label_chain
->lss_next
)
1233 if (current_space
== label_chain
->lss_space
&& label_chain
->lss_label
)
1237 if (now_seg
== label_chain
->lss_segment
&& label_chain
->lss_label
)
1245 /* Defines a label for the current space. If one is already defined,
1246 this function will replace it with the new label. */
1249 pa_define_label (symbol
)
1252 label_symbol_struct
*label_chain
= pa_get_label ();
1255 label_chain
->lss_label
= symbol
;
1258 /* Create a new label entry and add it to the head of the chain. */
1260 = (label_symbol_struct
*) xmalloc (sizeof (label_symbol_struct
));
1261 label_chain
->lss_label
= symbol
;
1263 label_chain
->lss_space
= current_space
;
1266 label_chain
->lss_segment
= now_seg
;
1268 label_chain
->lss_next
= NULL
;
1270 if (label_symbols_rootp
)
1271 label_chain
->lss_next
= label_symbols_rootp
;
1273 label_symbols_rootp
= label_chain
;
1277 /* Removes a label definition for the current space.
1278 If there is no label_symbol_struct entry, then no action is taken. */
1281 pa_undefine_label ()
1283 label_symbol_struct
*label_chain
;
1284 label_symbol_struct
*prev_label_chain
= NULL
;
1286 for (label_chain
= label_symbols_rootp
;
1288 label_chain
= label_chain
->lss_next
)
1292 && current_space
== label_chain
->lss_space
&& label_chain
->lss_label
1295 && now_seg
== label_chain
->lss_segment
&& label_chain
->lss_label
1299 /* Remove the label from the chain and free its memory. */
1300 if (prev_label_chain
)
1301 prev_label_chain
->lss_next
= label_chain
->lss_next
;
1303 label_symbols_rootp
= label_chain
->lss_next
;
1308 prev_label_chain
= label_chain
;
1312 /* An HPPA-specific version of fix_new. This is required because the HPPA
1313 code needs to keep track of some extra stuff. Each call to fix_new_hppa
1314 results in the creation of an instance of an hppa_fix_struct. An
1315 hppa_fix_struct stores the extra information along with a pointer to the
1316 original fixS. This is attached to the original fixup via the
1317 tc_fix_data field. */
1320 fix_new_hppa (frag
, where
, size
, add_symbol
, offset
, exp
, pcrel
,
1321 r_type
, r_field
, r_format
, arg_reloc
, unwind_bits
)
1325 symbolS
*add_symbol
;
1329 bfd_reloc_code_real_type r_type
;
1330 enum hppa_reloc_field_selector_type_alt r_field
;
1332 unsigned int arg_reloc
;
1333 int unwind_bits ATTRIBUTE_UNUSED
;
1337 struct hppa_fix_struct
*hppa_fix
= (struct hppa_fix_struct
*)
1338 obstack_alloc (¬es
, sizeof (struct hppa_fix_struct
));
1341 new_fix
= fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
1343 new_fix
= fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
);
1344 new_fix
->tc_fix_data
= (void *) hppa_fix
;
1345 hppa_fix
->fx_r_type
= r_type
;
1346 hppa_fix
->fx_r_field
= r_field
;
1347 hppa_fix
->fx_r_format
= r_format
;
1348 hppa_fix
->fx_arg_reloc
= arg_reloc
;
1349 hppa_fix
->segment
= now_seg
;
1351 if (r_type
== R_ENTRY
|| r_type
== R_EXIT
)
1352 new_fix
->fx_offset
= unwind_bits
;
1355 /* foo-$global$ is used to access non-automatic storage. $global$
1356 is really just a marker and has served its purpose, so eliminate
1357 it now so as not to confuse write.c. Ditto for $PIC_pcrel$0. */
1358 if (new_fix
->fx_subsy
1359 && (strcmp (S_GET_NAME (new_fix
->fx_subsy
), "$global$") == 0
1360 || strcmp (S_GET_NAME (new_fix
->fx_subsy
), "$PIC_pcrel$0") == 0))
1361 new_fix
->fx_subsy
= NULL
;
1364 /* Parse a .byte, .word, .long expression for the HPPA. Called by
1365 cons via the TC_PARSE_CONS_EXPRESSION macro. */
1368 parse_cons_expression_hppa (exp
)
1371 hppa_field_selector
= pa_chk_field_selector (&input_line_pointer
);
1375 /* This fix_new is called by cons via TC_CONS_FIX_NEW.
1376 hppa_field_selector is set by the parse_cons_expression_hppa. */
1379 cons_fix_new_hppa (frag
, where
, size
, exp
)
1385 unsigned int rel_type
;
1387 /* Get a base relocation type. */
1388 if (is_DP_relative (*exp
))
1389 rel_type
= R_HPPA_GOTOFF
;
1390 else if (is_complex (*exp
))
1391 rel_type
= R_HPPA_COMPLEX
;
1395 if (hppa_field_selector
!= e_psel
&& hppa_field_selector
!= e_fsel
)
1397 as_warn (_("Invalid field selector. Assuming F%%."));
1398 hppa_field_selector
= e_fsel
;
1401 fix_new_hppa (frag
, where
, size
,
1402 (symbolS
*) NULL
, (offsetT
) 0, exp
, 0, rel_type
,
1403 hppa_field_selector
, size
* 8, 0, 0);
1405 /* Reset field selector to its default state. */
1406 hppa_field_selector
= 0;
1409 /* This function is called once, at assembler startup time. It should
1410 set up all the tables, etc. that the MD part of the assembler will need. */
1415 const char *retval
= NULL
;
1419 last_call_info
= NULL
;
1420 call_info_root
= NULL
;
1422 /* Set the default machine type. */
1423 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, DEFAULT_LEVEL
))
1424 as_warn (_("could not set architecture and machine"));
1426 /* Folding of text and data segments fails miserably on the PA.
1427 Warn user and disable "-R" option. */
1428 if (flag_readonly_data_in_text
)
1430 as_warn (_("-R option not supported on this target."));
1431 flag_readonly_data_in_text
= 0;
1438 op_hash
= hash_new ();
1440 while (i
< NUMOPCODES
)
1442 const char *name
= pa_opcodes
[i
].name
;
1443 retval
= hash_insert (op_hash
, name
, (struct pa_opcode
*) &pa_opcodes
[i
]);
1444 if (retval
!= NULL
&& *retval
!= '\0')
1446 as_fatal (_("Internal error: can't hash `%s': %s\n"), name
, retval
);
1451 if ((pa_opcodes
[i
].match
& pa_opcodes
[i
].mask
)
1452 != pa_opcodes
[i
].match
)
1454 fprintf (stderr
, _("internal error: losing opcode: `%s' \"%s\"\n"),
1455 pa_opcodes
[i
].name
, pa_opcodes
[i
].args
);
1460 while (i
< NUMOPCODES
&& !strcmp (pa_opcodes
[i
].name
, name
));
1464 as_fatal (_("Broken assembler. No assembly attempted."));
1467 /* SOM will change text_section. To make sure we never put
1468 anything into the old one switch to the new one now. */
1469 subseg_set (text_section
, 0);
1473 dummy_symbol
= symbol_find_or_make ("L$dummy");
1474 S_SET_SEGMENT (dummy_symbol
, text_section
);
1475 /* Force the symbol to be converted to a real symbol. */
1476 (void) symbol_get_bfdsym (dummy_symbol
);
1480 /* Assemble a single instruction storing it into a frag. */
1487 /* The had better be something to assemble. */
1490 /* If we are within a procedure definition, make sure we've
1491 defined a label for the procedure; handle case where the
1492 label was defined after the .PROC directive.
1494 Note there's not need to diddle with the segment or fragment
1495 for the label symbol in this case. We have already switched
1496 into the new $CODE$ subspace at this point. */
1497 if (within_procedure
&& last_call_info
->start_symbol
== NULL
)
1499 label_symbol_struct
*label_symbol
= pa_get_label ();
1503 if (label_symbol
->lss_label
)
1505 last_call_info
->start_symbol
= label_symbol
->lss_label
;
1506 symbol_get_bfdsym (label_symbol
->lss_label
)->flags
1509 /* Also handle allocation of a fixup to hold the unwind
1510 information when the label appears after the proc/procend. */
1511 if (within_entry_exit
)
1516 where
= frag_more (0);
1517 u
= UNWIND_LOW32 (&last_call_info
->ci_unwind
.descriptor
);
1518 fix_new_hppa (frag_now
, where
- frag_now
->fr_literal
, 0,
1519 NULL
, (offsetT
) 0, NULL
,
1520 0, R_HPPA_ENTRY
, e_fsel
, 0, 0, u
);
1525 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
1528 as_bad (_("Missing function name for .PROC"));
1531 /* Assemble the instruction. Results are saved into "the_insn". */
1534 /* Get somewhere to put the assembled instrution. */
1537 /* Output the opcode. */
1538 md_number_to_chars (to
, the_insn
.opcode
, 4);
1540 /* If necessary output more stuff. */
1541 if (the_insn
.reloc
!= R_HPPA_NONE
)
1542 fix_new_hppa (frag_now
, (to
- frag_now
->fr_literal
), 4, NULL
,
1543 (offsetT
) 0, &the_insn
.exp
, the_insn
.pcrel
,
1544 the_insn
.reloc
, the_insn
.field_selector
,
1545 the_insn
.format
, the_insn
.arg_reloc
, 0);
1548 dwarf2_emit_insn (4);
1552 /* Do the real work for assembling a single instruction. Store results
1553 into the global "the_insn" variable. */
1559 char *error_message
= "";
1560 char *s
, c
, *argstart
, *name
, *save_s
;
1564 int cmpltr
, nullif
, flag
, cond
, num
;
1565 unsigned long opcode
;
1566 struct pa_opcode
*insn
;
1569 /* We must have a valid space and subspace. */
1570 pa_check_current_space_and_subspace ();
1573 /* Convert everything up to the first whitespace character into lower
1575 for (s
= str
; *s
!= ' ' && *s
!= '\t' && *s
!= '\n' && *s
!= '\0'; s
++)
1578 /* Skip to something interesting. */
1580 ISUPPER (*s
) || ISLOWER (*s
) || (*s
>= '0' && *s
<= '3');
1600 as_fatal (_("Unknown opcode: `%s'"), str
);
1603 /* Look up the opcode in the has table. */
1604 if ((insn
= (struct pa_opcode
*) hash_find (op_hash
, str
)) == NULL
)
1606 as_bad ("Unknown opcode: `%s'", str
);
1615 /* Mark the location where arguments for the instruction start, then
1616 start processing them. */
1620 /* Do some initialization. */
1621 opcode
= insn
->match
;
1622 strict
= (insn
->flags
& FLAG_STRICT
);
1623 memset (&the_insn
, 0, sizeof (the_insn
));
1625 the_insn
.reloc
= R_HPPA_NONE
;
1627 /* If this instruction is specific to a particular architecture,
1628 then set a new architecture. */
1629 /* But do not automatically promote to pa2.0. The automatic promotion
1630 crud is for compatability with HP's old assemblers only. */
1632 && bfd_get_mach (stdoutput
) < insn
->arch
)
1634 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, insn
->arch
))
1635 as_warn (_("could not update architecture and machine"));
1637 else if (bfd_get_mach (stdoutput
) < insn
->arch
)
1643 /* Build the opcode, checking as we go to make
1644 sure that the operands match. */
1645 for (args
= insn
->args
;; ++args
)
1647 /* Absorb white space in instruction. */
1648 while (*s
== ' ' || *s
== '\t')
1654 /* End of arguments. */
1670 /* These must match exactly. */
1679 /* Handle a 5 bit register or control register field at 10. */
1682 if (!pa_parse_number (&s
, 0))
1685 CHECK_FIELD (num
, 31, 0, 0);
1686 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 21);
1688 /* Handle %sar or %cr11. No bits get set, we just verify that it
1691 /* Skip whitespace before register. */
1692 while (*s
== ' ' || *s
== '\t')
1695 if (!strncasecmp (s
, "%sar", 4))
1700 else if (!strncasecmp (s
, "%cr11", 5))
1707 /* Handle a 5 bit register field at 15. */
1709 if (!pa_parse_number (&s
, 0))
1712 CHECK_FIELD (num
, 31, 0, 0);
1713 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 16);
1715 /* Handle a 5 bit register field at 31. */
1717 if (!pa_parse_number (&s
, 0))
1720 CHECK_FIELD (num
, 31, 0, 0);
1721 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
1723 /* Handle a 5 bit register field at 10 and 15. */
1725 if (!pa_parse_number (&s
, 0))
1728 CHECK_FIELD (num
, 31, 0, 0);
1729 opcode
|= num
<< 16;
1730 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 21);
1732 /* Handle a 5 bit field length at 31. */
1734 num
= pa_get_absolute_expression (&the_insn
, &s
);
1735 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
1738 CHECK_FIELD (num
, 32, 1, 0);
1739 INSERT_FIELD_AND_CONTINUE (opcode
, 32 - num
, 0);
1741 /* Handle a 5 bit immediate at 15. */
1743 num
= pa_get_absolute_expression (&the_insn
, &s
);
1744 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
1747 /* When in strict mode, we want to just reject this
1748 match instead of giving an out of range error. */
1749 CHECK_FIELD (num
, 15, -16, strict
);
1750 num
= low_sign_unext (num
, 5);
1751 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 16);
1753 /* Handle a 5 bit immediate at 31. */
1755 num
= pa_get_absolute_expression (&the_insn
, &s
);
1756 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
1759 /* When in strict mode, we want to just reject this
1760 match instead of giving an out of range error. */
1761 CHECK_FIELD (num
, 15, -16, strict
);
1762 num
= low_sign_unext (num
, 5);
1763 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
1765 /* Handle an unsigned 5 bit immediate at 31. */
1767 num
= pa_get_absolute_expression (&the_insn
, &s
);
1768 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
1771 CHECK_FIELD (num
, 31, 0, strict
);
1772 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
1774 /* Handle an unsigned 5 bit immediate at 15. */
1776 num
= pa_get_absolute_expression (&the_insn
, &s
);
1777 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
1780 CHECK_FIELD (num
, 31, 0, strict
);
1781 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 16);
1783 /* Handle an unsigned 10 bit immediate at 15. */
1785 num
= pa_get_absolute_expression (&the_insn
, &s
);
1786 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
1789 CHECK_FIELD (num
, 1023, 0, strict
);
1790 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 16);
1792 /* Handle a 2 bit space identifier at 17. */
1794 if (!pa_parse_number (&s
, 0))
1797 CHECK_FIELD (num
, 3, 0, 1);
1798 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 14);
1800 /* Handle a 3 bit space identifier at 18. */
1802 if (!pa_parse_number (&s
, 0))
1805 CHECK_FIELD (num
, 7, 0, 1);
1806 opcode
|= re_assemble_3 (num
);
1809 /* Handle all completers. */
1814 /* Handle a completer for an indexing load or store. */
1821 while (*s
== ',' && i
< 2)
1824 if (strncasecmp (s
, "sm", 2) == 0)
1831 else if (strncasecmp (s
, "m", 1) == 0)
1833 else if ((strncasecmp (s
, "s ", 2) == 0)
1834 || (strncasecmp (s
, "s,", 2) == 0))
1836 /* When in strict mode this is a match failure. */
1843 as_bad (_("Invalid Indexed Load Completer."));
1848 as_bad (_("Invalid Indexed Load Completer Syntax."));
1850 INSERT_FIELD_AND_CONTINUE (opcode
, uu
, 13);
1853 /* Handle a short load/store completer. */
1866 if (strncasecmp (s
, "ma", 2) == 0)
1872 else if (strncasecmp (s
, "mb", 2) == 0)
1879 /* When in strict mode, pass through for cache op. */
1880 if (!found
&& strict
)
1885 as_bad (_("Invalid Short Load/Store Completer."));
1889 /* If we did not get a ma/mb completer, then we do not
1890 consider this a positive match for 'ce'. */
1891 else if (*args
== 'e')
1894 /* 'J', 'm', 'M' and 'q' are the same, except for where they
1895 encode the before/after field. */
1896 if (*args
== 'm' || *args
== 'M')
1899 INSERT_FIELD_AND_CONTINUE (opcode
, a
, 13);
1901 else if (*args
== 'q')
1904 INSERT_FIELD_AND_CONTINUE (opcode
, a
, 2);
1906 else if (*args
== 'J')
1908 /* M bit is explicit in the major opcode. */
1909 INSERT_FIELD_AND_CONTINUE (opcode
, a
, 2);
1911 else if (*args
== 'e')
1913 /* Stash the ma/mb flag temporarily in the
1914 instruction. We will use (and remove it)
1915 later when handling 'J', 'K', '<' & '>'. */
1921 /* Handle a stbys completer. */
1928 while (*s
== ',' && i
< 2)
1931 if (strncasecmp (s
, "m", 1) == 0)
1933 else if ((strncasecmp (s
, "b ", 2) == 0)
1934 || (strncasecmp (s
, "b,", 2) == 0))
1936 else if (strncasecmp (s
, "e", 1) == 0)
1938 /* When in strict mode this is a match failure. */
1945 as_bad (_("Invalid Store Bytes Short Completer"));
1950 as_bad (_("Invalid Store Bytes Short Completer"));
1952 INSERT_FIELD_AND_CONTINUE (opcode
, a
, 13);
1955 /* Handle load cache hint completer. */
1958 if (!strncmp (s
, ",sl", 3))
1963 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 10);
1965 /* Handle store cache hint completer. */
1968 if (!strncmp (s
, ",sl", 3))
1973 else if (!strncmp (s
, ",bc", 3))
1978 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 10);
1980 /* Handle load and clear cache hint completer. */
1983 if (!strncmp (s
, ",co", 3))
1988 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 10);
1990 /* Handle load ordering completer. */
1992 if (strncmp (s
, ",o", 2) != 0)
1997 /* Handle a branch gate completer. */
1999 if (strncasecmp (s
, ",gate", 5) != 0)
2004 /* Handle a branch link and push completer. */
2006 if (strncasecmp (s
, ",l,push", 7) != 0)
2011 /* Handle a branch link completer. */
2013 if (strncasecmp (s
, ",l", 2) != 0)
2018 /* Handle a branch pop completer. */
2020 if (strncasecmp (s
, ",pop", 4) != 0)
2025 /* Handle a local processor completer. */
2027 if (strncasecmp (s
, ",l", 2) != 0)
2032 /* Handle a PROBE read/write completer. */
2035 if (!strncasecmp (s
, ",w", 2))
2040 else if (!strncasecmp (s
, ",r", 2))
2046 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 6);
2048 /* Handle MFCTL wide completer. */
2050 if (strncasecmp (s
, ",w", 2) != 0)
2055 /* Handle an RFI restore completer. */
2058 if (!strncasecmp (s
, ",r", 2))
2064 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 5);
2066 /* Handle a system control completer. */
2068 if (*s
== ',' && (*(s
+ 1) == 'm' || *(s
+ 1) == 'M'))
2076 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 5);
2078 /* Handle intermediate/final completer for DCOR. */
2081 if (!strncasecmp (s
, ",i", 2))
2087 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 6);
2089 /* Handle zero/sign extension completer. */
2092 if (!strncasecmp (s
, ",z", 2))
2098 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 10);
2100 /* Handle add completer. */
2103 if (!strncasecmp (s
, ",l", 2))
2108 else if (!strncasecmp (s
, ",tsv", 4))
2114 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 10);
2116 /* Handle 64 bit carry for ADD. */
2119 if (!strncasecmp (s
, ",dc,tsv", 7) ||
2120 !strncasecmp (s
, ",tsv,dc", 7))
2125 else if (!strncasecmp (s
, ",dc", 3))
2133 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
2135 /* Handle 32 bit carry for ADD. */
2138 if (!strncasecmp (s
, ",c,tsv", 6) ||
2139 !strncasecmp (s
, ",tsv,c", 6))
2144 else if (!strncasecmp (s
, ",c", 2))
2152 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
2154 /* Handle trap on signed overflow. */
2157 if (!strncasecmp (s
, ",tsv", 4))
2163 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
2165 /* Handle trap on condition and overflow. */
2168 if (!strncasecmp (s
, ",tc,tsv", 7) ||
2169 !strncasecmp (s
, ",tsv,tc", 7))
2174 else if (!strncasecmp (s
, ",tc", 3))
2182 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
2184 /* Handle 64 bit borrow for SUB. */
2187 if (!strncasecmp (s
, ",db,tsv", 7) ||
2188 !strncasecmp (s
, ",tsv,db", 7))
2193 else if (!strncasecmp (s
, ",db", 3))
2201 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
2203 /* Handle 32 bit borrow for SUB. */
2206 if (!strncasecmp (s
, ",b,tsv", 6) ||
2207 !strncasecmp (s
, ",tsv,b", 6))
2212 else if (!strncasecmp (s
, ",b", 2))
2220 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
2222 /* Handle trap condition completer for UADDCM. */
2225 if (!strncasecmp (s
, ",tc", 3))
2231 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 6);
2233 /* Handle signed/unsigned at 21. */
2237 if (strncasecmp (s
, ",s", 2) == 0)
2242 else if (strncasecmp (s
, ",u", 2) == 0)
2248 INSERT_FIELD_AND_CONTINUE (opcode
, sign
, 10);
2251 /* Handle left/right combination at 17:18. */
2261 as_bad (_("Invalid left/right combination completer"));
2264 INSERT_FIELD_AND_CONTINUE (opcode
, lr
, 13);
2267 as_bad (_("Invalid left/right combination completer"));
2270 /* Handle saturation at 24:25. */
2274 if (strncasecmp (s
, ",ss", 3) == 0)
2279 else if (strncasecmp (s
, ",us", 3) == 0)
2285 INSERT_FIELD_AND_CONTINUE (opcode
, sat
, 6);
2288 /* Handle permutation completer. */
2316 as_bad (_("Invalid permutation completer"));
2318 opcode
|= perm
<< permloc
[i
];
2323 as_bad (_("Invalid permutation completer"));
2331 /* Handle all conditions. */
2337 /* Handle FP compare conditions. */
2339 cond
= pa_parse_fp_cmp_cond (&s
);
2340 INSERT_FIELD_AND_CONTINUE (opcode
, cond
, 0);
2342 /* Handle an add condition. */
2351 /* 64 bit conditions. */
2364 while (*s
!= ',' && *s
!= ' ' && *s
!= '\t')
2368 if (strcmp (name
, "=") == 0)
2370 else if (strcmp (name
, "<") == 0)
2372 else if (strcmp (name
, "<=") == 0)
2374 else if (strcasecmp (name
, "nuv") == 0)
2376 else if (strcasecmp (name
, "znv") == 0)
2378 else if (strcasecmp (name
, "sv") == 0)
2380 else if (strcasecmp (name
, "od") == 0)
2382 else if (strcasecmp (name
, "tr") == 0)
2387 else if (strcmp (name
, "<>") == 0)
2392 else if (strcmp (name
, ">=") == 0)
2397 else if (strcmp (name
, ">") == 0)
2402 else if (strcasecmp (name
, "uv") == 0)
2407 else if (strcasecmp (name
, "vnz") == 0)
2412 else if (strcasecmp (name
, "nsv") == 0)
2417 else if (strcasecmp (name
, "ev") == 0)
2422 /* ",*" is a valid condition. */
2423 else if (*args
== 'a')
2424 as_bad (_("Invalid Add Condition: %s"), name
);
2427 opcode
|= cmpltr
<< 13;
2428 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 12);
2430 /* Handle non-negated add and branch condition. */
2432 cmpltr
= pa_parse_nonneg_add_cmpltr (&s
);
2435 as_bad (_("Invalid Add and Branch Condition"));
2438 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 13);
2440 /* Handle 64 bit wide-mode add and branch condition. */
2442 cmpltr
= pa_parse_addb_64_cmpltr (&s
);
2445 as_bad (_("Invalid Add and Branch Condition"));
2450 /* Negated condition requires an opcode change. */
2451 opcode
|= (cmpltr
& 8) << 24;
2453 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
& 7, 13);
2455 /* Handle a negated or non-negated add and branch
2459 cmpltr
= pa_parse_nonneg_add_cmpltr (&s
);
2463 cmpltr
= pa_parse_neg_add_cmpltr (&s
);
2466 as_bad (_("Invalid Compare/Subtract Condition"));
2471 /* Negated condition requires an opcode change. */
2475 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 13);
2477 /* Handle branch on bit conditions. */
2495 if (strncmp (s
, "<", 1) == 0)
2500 else if (strncmp (s
, ">=", 2) == 0)
2506 as_bad (_("Invalid Bit Branch Condition: %c"), *s
);
2508 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 15);
2510 /* Handle a compare/subtract condition. */
2519 /* 64 bit conditions. */
2532 while (*s
!= ',' && *s
!= ' ' && *s
!= '\t')
2536 if (strcmp (name
, "=") == 0)
2538 else if (strcmp (name
, "<") == 0)
2540 else if (strcmp (name
, "<=") == 0)
2542 else if (strcasecmp (name
, "<<") == 0)
2544 else if (strcasecmp (name
, "<<=") == 0)
2546 else if (strcasecmp (name
, "sv") == 0)
2548 else if (strcasecmp (name
, "od") == 0)
2550 else if (strcasecmp (name
, "tr") == 0)
2555 else if (strcmp (name
, "<>") == 0)
2560 else if (strcmp (name
, ">=") == 0)
2565 else if (strcmp (name
, ">") == 0)
2570 else if (strcasecmp (name
, ">>=") == 0)
2575 else if (strcasecmp (name
, ">>") == 0)
2580 else if (strcasecmp (name
, "nsv") == 0)
2585 else if (strcasecmp (name
, "ev") == 0)
2590 /* ",*" is a valid condition. */
2591 else if (*args
!= 'S')
2592 as_bad (_("Invalid Compare/Subtract Condition: %s"),
2596 opcode
|= cmpltr
<< 13;
2597 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 12);
2599 /* Handle a non-negated compare condition. */
2601 cmpltr
= pa_parse_nonneg_cmpsub_cmpltr (&s
);
2604 as_bad (_("Invalid Compare/Subtract Condition"));
2607 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 13);
2609 /* Handle a 32 bit compare and branch condition. */
2612 cmpltr
= pa_parse_nonneg_cmpsub_cmpltr (&s
);
2616 cmpltr
= pa_parse_neg_cmpsub_cmpltr (&s
);
2619 as_bad (_("Invalid Compare and Branch Condition"));
2624 /* Negated condition requires an opcode change. */
2629 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 13);
2631 /* Handle a 64 bit compare and branch condition. */
2633 cmpltr
= pa_parse_cmpb_64_cmpltr (&s
);
2636 /* Negated condition requires an opcode change. */
2637 opcode
|= (cmpltr
& 8) << 26;
2640 /* Not a 64 bit cond. Give 32 bit a chance. */
2643 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
& 7, 13);
2645 /* Handle a 64 bit cmpib condition. */
2647 cmpltr
= pa_parse_cmpib_64_cmpltr (&s
);
2649 /* Not a 64 bit cond. Give 32 bit a chance. */
2652 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 13);
2654 /* Handle a logical instruction condition. */
2663 /* 64 bit conditions. */
2675 while (*s
!= ',' && *s
!= ' ' && *s
!= '\t')
2680 if (strcmp (name
, "=") == 0)
2682 else if (strcmp (name
, "<") == 0)
2684 else if (strcmp (name
, "<=") == 0)
2686 else if (strcasecmp (name
, "od") == 0)
2688 else if (strcasecmp (name
, "tr") == 0)
2693 else if (strcmp (name
, "<>") == 0)
2698 else if (strcmp (name
, ">=") == 0)
2703 else if (strcmp (name
, ">") == 0)
2708 else if (strcasecmp (name
, "ev") == 0)
2713 /* ",*" is a valid condition. */
2714 else if (*args
!= 'L')
2715 as_bad (_("Invalid Logical Instruction Condition."));
2718 opcode
|= cmpltr
<< 13;
2719 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 12);
2721 /* Handle a shift/extract/deposit condition. */
2730 /* 64 bit conditions. */
2742 while (*s
!= ',' && *s
!= ' ' && *s
!= '\t')
2746 if (strcmp (name
, "=") == 0)
2748 else if (strcmp (name
, "<") == 0)
2750 else if (strcasecmp (name
, "od") == 0)
2752 else if (strcasecmp (name
, "tr") == 0)
2754 else if (strcmp (name
, "<>") == 0)
2756 else if (strcmp (name
, ">=") == 0)
2758 else if (strcasecmp (name
, "ev") == 0)
2760 /* Handle movb,n. Put things back the way they were.
2761 This includes moving s back to where it started. */
2762 else if (strcasecmp (name
, "n") == 0 && *args
== 'y')
2768 /* ",*" is a valid condition. */
2769 else if (*args
!= 'X')
2770 as_bad (_("Invalid Shift/Extract/Deposit Condition."));
2773 INSERT_FIELD_AND_CONTINUE (opcode
, cmpltr
, 13);
2775 /* Handle a unit instruction condition. */
2784 /* 64 bit conditions. */
2795 if (strncasecmp (s
, "sbz", 3) == 0)
2800 else if (strncasecmp (s
, "shz", 3) == 0)
2805 else if (strncasecmp (s
, "sdc", 3) == 0)
2810 else if (strncasecmp (s
, "sbc", 3) == 0)
2815 else if (strncasecmp (s
, "shc", 3) == 0)
2820 else if (strncasecmp (s
, "tr", 2) == 0)
2826 else if (strncasecmp (s
, "nbz", 3) == 0)
2832 else if (strncasecmp (s
, "nhz", 3) == 0)
2838 else if (strncasecmp (s
, "ndc", 3) == 0)
2844 else if (strncasecmp (s
, "nbc", 3) == 0)
2850 else if (strncasecmp (s
, "nhc", 3) == 0)
2856 else if (strncasecmp (s
, "swz", 3) == 0)
2862 else if (strncasecmp (s
, "swc", 3) == 0)
2868 else if (strncasecmp (s
, "nwz", 3) == 0)
2874 else if (strncasecmp (s
, "nwc", 3) == 0)
2880 /* ",*" is a valid condition. */
2881 else if (*args
!= 'U')
2882 as_bad (_("Invalid Unit Instruction Condition."));
2884 opcode
|= cmpltr
<< 13;
2885 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 12);
2893 /* Handle a nullification completer for branch instructions. */
2895 nullif
= pa_parse_nullif (&s
);
2896 INSERT_FIELD_AND_CONTINUE (opcode
, nullif
, 1);
2898 /* Handle a nullification completer for copr and spop insns. */
2900 nullif
= pa_parse_nullif (&s
);
2901 INSERT_FIELD_AND_CONTINUE (opcode
, nullif
, 5);
2903 /* Handle ,%r2 completer for new syntax branches. */
2905 if (*s
== ',' && strncasecmp (s
+ 1, "%r2", 3) == 0)
2907 else if (*s
== ',' && strncasecmp (s
+ 1, "%rp", 3) == 0)
2913 /* Handle 3 bit entry into the fp compare array. Valid values
2914 are 0..6 inclusive. */
2918 if (the_insn
.exp
.X_op
== O_constant
)
2920 num
= evaluate_absolute (&the_insn
);
2921 CHECK_FIELD (num
, 6, 0, 0);
2923 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 13);
2928 /* Handle 3 bit entry into the fp compare array. Valid values
2929 are 0..6 inclusive. */
2932 if (the_insn
.exp
.X_op
== O_constant
)
2935 num
= evaluate_absolute (&the_insn
);
2936 CHECK_FIELD (num
, 6, 0, 0);
2937 num
= (num
+ 1) ^ 1;
2938 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 13);
2943 /* Handle graphics test completers for ftest */
2946 num
= pa_parse_ftest_gfx_completer (&s
);
2947 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
2950 /* Handle a 11 bit immediate at 31. */
2952 the_insn
.field_selector
= pa_chk_field_selector (&s
);
2955 if (the_insn
.exp
.X_op
== O_constant
)
2957 num
= evaluate_absolute (&the_insn
);
2958 CHECK_FIELD (num
, 1023, -1024, 0);
2959 num
= low_sign_unext (num
, 11);
2960 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
2964 if (is_DP_relative (the_insn
.exp
))
2965 the_insn
.reloc
= R_HPPA_GOTOFF
;
2966 else if (is_PC_relative (the_insn
.exp
))
2967 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
2969 the_insn
.reloc
= R_HPPA
;
2970 the_insn
.format
= 11;
2974 /* Handle a 14 bit immediate at 31. */
2976 the_insn
.field_selector
= pa_chk_field_selector (&s
);
2979 if (the_insn
.exp
.X_op
== O_constant
)
2983 /* XXX the completer stored away tidbits of information
2984 for us to extract. We need a cleaner way to do this.
2985 Now that we have lots of letters again, it would be
2986 good to rethink this. */
2989 num
= evaluate_absolute (&the_insn
);
2990 if (mb
!= (num
< 0))
2992 CHECK_FIELD (num
, 8191, -8192, 0);
2993 num
= low_sign_unext (num
, 14);
2994 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
2998 /* Handle a 14 bit immediate at 31. */
3000 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3003 if (the_insn
.exp
.X_op
== O_constant
)
3009 num
= evaluate_absolute (&the_insn
);
3010 if (mb
== (num
< 0))
3014 CHECK_FIELD (num
, 8191, -8192, 0);
3015 num
= low_sign_unext (num
, 14);
3016 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3020 /* Handle a 16 bit immediate at 31. */
3022 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3025 if (the_insn
.exp
.X_op
== O_constant
)
3031 num
= evaluate_absolute (&the_insn
);
3032 if (mb
!= (num
< 0))
3034 CHECK_FIELD (num
, 32767, -32768, 0);
3035 num
= re_assemble_16 (num
);
3036 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3040 /* Handle a 16 bit immediate at 31. */
3042 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3045 if (the_insn
.exp
.X_op
== O_constant
)
3051 num
= evaluate_absolute (&the_insn
);
3052 if (mb
== (num
< 0))
3056 CHECK_FIELD (num
, 32767, -32768, 0);
3057 num
= re_assemble_16 (num
);
3058 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3062 /* Handle 14 bit immediate, shifted left three times. */
3064 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3067 if (the_insn
.exp
.X_op
== O_constant
)
3069 num
= evaluate_absolute (&the_insn
);
3072 CHECK_FIELD (num
, 8191, -8192, 0);
3077 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 4);
3081 if (is_DP_relative (the_insn
.exp
))
3082 the_insn
.reloc
= R_HPPA_GOTOFF
;
3083 else if (is_PC_relative (the_insn
.exp
))
3084 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3086 the_insn
.reloc
= R_HPPA
;
3087 the_insn
.format
= 14;
3092 /* Handle 14 bit immediate, shifted left twice. */
3094 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3097 if (the_insn
.exp
.X_op
== O_constant
)
3099 num
= evaluate_absolute (&the_insn
);
3102 CHECK_FIELD (num
, 8191, -8192, 0);
3107 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 3);
3111 if (is_DP_relative (the_insn
.exp
))
3112 the_insn
.reloc
= R_HPPA_GOTOFF
;
3113 else if (is_PC_relative (the_insn
.exp
))
3114 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3116 the_insn
.reloc
= R_HPPA
;
3117 the_insn
.format
= 14;
3121 /* Handle a 14 bit immediate at 31. */
3123 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3126 if (the_insn
.exp
.X_op
== O_constant
)
3128 num
= evaluate_absolute (&the_insn
);
3129 CHECK_FIELD (num
, 8191, -8192, 0);
3130 num
= low_sign_unext (num
, 14);
3131 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3135 if (is_DP_relative (the_insn
.exp
))
3136 the_insn
.reloc
= R_HPPA_GOTOFF
;
3137 else if (is_PC_relative (the_insn
.exp
))
3138 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3140 the_insn
.reloc
= R_HPPA
;
3141 the_insn
.format
= 14;
3145 /* Handle a 21 bit immediate at 31. */
3147 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3150 if (the_insn
.exp
.X_op
== O_constant
)
3152 num
= evaluate_absolute (&the_insn
);
3153 CHECK_FIELD (num
>> 11, 1048575, -1048576, 0);
3154 opcode
|= re_assemble_21 (num
);
3159 if (is_DP_relative (the_insn
.exp
))
3160 the_insn
.reloc
= R_HPPA_GOTOFF
;
3161 else if (is_PC_relative (the_insn
.exp
))
3162 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3164 the_insn
.reloc
= R_HPPA
;
3165 the_insn
.format
= 21;
3169 /* Handle a 16 bit immediate at 31 (PA 2.0 wide mode only). */
3171 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3174 if (the_insn
.exp
.X_op
== O_constant
)
3176 num
= evaluate_absolute (&the_insn
);
3177 CHECK_FIELD (num
, 32767, -32768, 0);
3178 opcode
|= re_assemble_16 (num
);
3183 /* ??? Is this valid for wide mode? */
3184 if (is_DP_relative (the_insn
.exp
))
3185 the_insn
.reloc
= R_HPPA_GOTOFF
;
3186 else if (is_PC_relative (the_insn
.exp
))
3187 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3189 the_insn
.reloc
= R_HPPA
;
3190 the_insn
.format
= 14;
3194 /* Handle a word-aligned 16-bit imm. at 31 (PA2.0 wide). */
3196 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3199 if (the_insn
.exp
.X_op
== O_constant
)
3201 num
= evaluate_absolute (&the_insn
);
3202 CHECK_FIELD (num
, 32767, -32768, 0);
3203 CHECK_ALIGN (num
, 4, 0);
3204 opcode
|= re_assemble_16 (num
);
3209 /* ??? Is this valid for wide mode? */
3210 if (is_DP_relative (the_insn
.exp
))
3211 the_insn
.reloc
= R_HPPA_GOTOFF
;
3212 else if (is_PC_relative (the_insn
.exp
))
3213 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3215 the_insn
.reloc
= R_HPPA
;
3216 the_insn
.format
= 14;
3220 /* Handle a dword-aligned 16-bit imm. at 31 (PA2.0 wide). */
3222 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3225 if (the_insn
.exp
.X_op
== O_constant
)
3227 num
= evaluate_absolute (&the_insn
);
3228 CHECK_FIELD (num
, 32767, -32768, 0);
3229 CHECK_ALIGN (num
, 8, 0);
3230 opcode
|= re_assemble_16 (num
);
3235 /* ??? Is this valid for wide mode? */
3236 if (is_DP_relative (the_insn
.exp
))
3237 the_insn
.reloc
= R_HPPA_GOTOFF
;
3238 else if (is_PC_relative (the_insn
.exp
))
3239 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3241 the_insn
.reloc
= R_HPPA
;
3242 the_insn
.format
= 14;
3246 /* Handle a 12 bit branch displacement. */
3248 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3252 if (!the_insn
.exp
.X_add_symbol
3253 || !strcmp (S_GET_NAME (the_insn
.exp
.X_add_symbol
),
3256 num
= evaluate_absolute (&the_insn
);
3259 as_bad (_("Branch to unaligned address"));
3262 if (the_insn
.exp
.X_add_symbol
)
3264 CHECK_FIELD (num
, 8191, -8192, 0);
3265 opcode
|= re_assemble_12 (num
>> 2);
3270 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3271 the_insn
.format
= 12;
3272 the_insn
.arg_reloc
= last_call_desc
.arg_reloc
;
3273 memset (&last_call_desc
, 0, sizeof (struct call_desc
));
3278 /* Handle a 17 bit branch displacement. */
3280 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3284 if (!the_insn
.exp
.X_add_symbol
3285 || !strcmp (S_GET_NAME (the_insn
.exp
.X_add_symbol
),
3288 num
= evaluate_absolute (&the_insn
);
3291 as_bad (_("Branch to unaligned address"));
3294 if (the_insn
.exp
.X_add_symbol
)
3296 CHECK_FIELD (num
, 262143, -262144, 0);
3297 opcode
|= re_assemble_17 (num
>> 2);
3302 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3303 the_insn
.format
= 17;
3304 the_insn
.arg_reloc
= last_call_desc
.arg_reloc
;
3305 memset (&last_call_desc
, 0, sizeof (struct call_desc
));
3309 /* Handle a 22 bit branch displacement. */
3311 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3315 if (!the_insn
.exp
.X_add_symbol
3316 || !strcmp (S_GET_NAME (the_insn
.exp
.X_add_symbol
),
3319 num
= evaluate_absolute (&the_insn
);
3322 as_bad (_("Branch to unaligned address"));
3325 if (the_insn
.exp
.X_add_symbol
)
3327 CHECK_FIELD (num
, 8388607, -8388608, 0);
3328 opcode
|= re_assemble_22 (num
>> 2);
3332 the_insn
.reloc
= R_HPPA_PCREL_CALL
;
3333 the_insn
.format
= 22;
3334 the_insn
.arg_reloc
= last_call_desc
.arg_reloc
;
3335 memset (&last_call_desc
, 0, sizeof (struct call_desc
));
3339 /* Handle an absolute 17 bit branch target. */
3341 the_insn
.field_selector
= pa_chk_field_selector (&s
);
3345 if (!the_insn
.exp
.X_add_symbol
3346 || !strcmp (S_GET_NAME (the_insn
.exp
.X_add_symbol
),
3349 num
= evaluate_absolute (&the_insn
);
3352 as_bad (_("Branch to unaligned address"));
3355 if (the_insn
.exp
.X_add_symbol
)
3357 CHECK_FIELD (num
, 262143, -262144, 0);
3358 opcode
|= re_assemble_17 (num
>> 2);
3363 the_insn
.reloc
= R_HPPA_ABS_CALL
;
3364 the_insn
.format
= 17;
3365 the_insn
.arg_reloc
= last_call_desc
.arg_reloc
;
3366 memset (&last_call_desc
, 0, sizeof (struct call_desc
));
3370 /* Handle '%r1' implicit operand of addil instruction. */
3372 if (*s
== ',' && *(s
+ 1) == '%' && *(s
+ 3) == '1'
3373 && (*(s
+ 2) == 'r' || *(s
+ 2) == 'R'))
3381 /* Handle '%sr0,%r31' implicit operand of be,l instruction. */
3383 if (strncasecmp (s
, "%sr0,%r31", 9) != 0)
3388 /* Handle immediate value of 0 for ordered load/store instructions. */
3395 /* Handle a 2 bit shift count at 25. */
3397 num
= pa_get_absolute_expression (&the_insn
, &s
);
3398 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3401 CHECK_FIELD (num
, 3, 1, strict
);
3402 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 6);
3404 /* Handle a 4 bit shift count at 25. */
3406 num
= pa_get_absolute_expression (&the_insn
, &s
);
3407 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3410 CHECK_FIELD (num
, 15, 0, strict
);
3411 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 6);
3413 /* Handle a 5 bit shift count at 26. */
3415 num
= pa_get_absolute_expression (&the_insn
, &s
);
3416 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3419 CHECK_FIELD (num
, 31, 0, strict
);
3420 INSERT_FIELD_AND_CONTINUE (opcode
, 31 - num
, 5);
3422 /* Handle a 6 bit shift count at 20,22:26. */
3424 num
= pa_get_absolute_expression (&the_insn
, &s
);
3425 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3428 CHECK_FIELD (num
, 63, 0, strict
);
3430 opcode
|= (num
& 0x20) << 6;
3431 INSERT_FIELD_AND_CONTINUE (opcode
, num
& 0x1f, 5);
3433 /* Handle a 6 bit field length at 23,27:31. */
3436 num
= pa_get_absolute_expression (&the_insn
, &s
);
3437 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3440 CHECK_FIELD (num
, 64, 1, strict
);
3442 opcode
|= (num
& 0x20) << 3;
3443 num
= 31 - (num
& 0x1f);
3444 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3446 /* Handle a 6 bit field length at 19,27:31. */
3448 num
= pa_get_absolute_expression (&the_insn
, &s
);
3449 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3452 CHECK_FIELD (num
, 64, 1, strict
);
3454 opcode
|= (num
& 0x20) << 7;
3455 num
= 31 - (num
& 0x1f);
3456 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3458 /* Handle a 5 bit bit position at 26. */
3460 num
= pa_get_absolute_expression (&the_insn
, &s
);
3461 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3464 CHECK_FIELD (num
, 31, 0, strict
);
3465 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 5);
3467 /* Handle a 6 bit bit position at 20,22:26. */
3469 num
= pa_get_absolute_expression (&the_insn
, &s
);
3470 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3473 CHECK_FIELD (num
, 63, 0, strict
);
3474 opcode
|= (num
& 0x20) << 6;
3475 INSERT_FIELD_AND_CONTINUE (opcode
, num
& 0x1f, 5);
3477 /* Handle a 5 bit immediate at 10 with 'd' as the complement
3478 of the high bit of the immediate. */
3480 num
= pa_get_absolute_expression (&the_insn
, &s
);
3481 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3484 CHECK_FIELD (num
, 63, 0, strict
);
3488 opcode
|= (1 << 13);
3489 INSERT_FIELD_AND_CONTINUE (opcode
, num
& 0x1f, 21);
3491 /* Handle a 5 bit immediate at 10. */
3493 num
= pa_get_absolute_expression (&the_insn
, &s
);
3494 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3497 CHECK_FIELD (num
, 31, 0, strict
);
3498 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 21);
3500 /* Handle a 9 bit immediate at 28. */
3502 num
= pa_get_absolute_expression (&the_insn
, &s
);
3503 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3506 CHECK_FIELD (num
, 511, 1, strict
);
3507 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 3);
3509 /* Handle a 13 bit immediate at 18. */
3511 num
= pa_get_absolute_expression (&the_insn
, &s
);
3512 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3515 CHECK_FIELD (num
, 8191, 0, strict
);
3516 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 13);
3518 /* Handle a 26 bit immediate at 31. */
3520 num
= pa_get_absolute_expression (&the_insn
, &s
);
3521 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3524 CHECK_FIELD (num
, 67108863, 0, strict
);
3525 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3527 /* Handle a 3 bit SFU identifier at 25. */
3530 as_bad (_("Invalid SFU identifier"));
3531 num
= pa_get_absolute_expression (&the_insn
, &s
);
3532 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3535 CHECK_FIELD (num
, 7, 0, strict
);
3536 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 6);
3538 /* Handle a 20 bit SOP field for spop0. */
3540 num
= pa_get_absolute_expression (&the_insn
, &s
);
3541 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3544 CHECK_FIELD (num
, 1048575, 0, strict
);
3545 num
= (num
& 0x1f) | ((num
& 0x000fffe0) << 6);
3546 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3548 /* Handle a 15bit SOP field for spop1. */
3550 num
= pa_get_absolute_expression (&the_insn
, &s
);
3551 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3554 CHECK_FIELD (num
, 32767, 0, strict
);
3555 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 11);
3557 /* Handle a 10bit SOP field for spop3. */
3559 num
= pa_get_absolute_expression (&the_insn
, &s
);
3560 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3563 CHECK_FIELD (num
, 1023, 0, strict
);
3564 num
= (num
& 0x1f) | ((num
& 0x000003e0) << 6);
3565 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3567 /* Handle a 15 bit SOP field for spop2. */
3569 num
= pa_get_absolute_expression (&the_insn
, &s
);
3570 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3573 CHECK_FIELD (num
, 32767, 0, strict
);
3574 num
= (num
& 0x1f) | ((num
& 0x00007fe0) << 6);
3575 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3577 /* Handle a 3-bit co-processor ID field. */
3580 as_bad (_("Invalid COPR identifier"));
3581 num
= pa_get_absolute_expression (&the_insn
, &s
);
3582 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3585 CHECK_FIELD (num
, 7, 0, strict
);
3586 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 6);
3588 /* Handle a 22bit SOP field for copr. */
3590 num
= pa_get_absolute_expression (&the_insn
, &s
);
3591 if (strict
&& the_insn
.exp
.X_op
!= O_constant
)
3594 CHECK_FIELD (num
, 4194303, 0, strict
);
3595 num
= (num
& 0x1f) | ((num
& 0x003fffe0) << 4);
3596 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3598 /* Handle a source FP operand format completer. */
3600 if (*s
== ',' && *(s
+1) == 't')
3607 flag
= pa_parse_fp_cnv_format (&s
);
3608 the_insn
.fpof1
= flag
;
3609 if (flag
== W
|| flag
== UW
)
3611 if (flag
== DW
|| flag
== UDW
)
3613 if (flag
== QW
|| flag
== UQW
)
3615 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
3617 /* Handle a destination FP operand format completer. */
3619 /* pa_parse_format needs the ',' prefix. */
3621 flag
= pa_parse_fp_cnv_format (&s
);
3622 the_insn
.fpof2
= flag
;
3623 if (flag
== W
|| flag
== UW
)
3625 if (flag
== DW
|| flag
== UDW
)
3627 if (flag
== QW
|| flag
== UQW
)
3629 opcode
|= flag
<< 13;
3630 if (the_insn
.fpof1
== SGL
3631 || the_insn
.fpof1
== DBL
3632 || the_insn
.fpof1
== QUAD
)
3634 if (the_insn
.fpof2
== SGL
3635 || the_insn
.fpof2
== DBL
3636 || the_insn
.fpof2
== QUAD
)
3638 else if (the_insn
.fpof2
== W
3639 || the_insn
.fpof2
== DW
3640 || the_insn
.fpof2
== QW
)
3642 else if (the_insn
.fpof2
== UW
3643 || the_insn
.fpof2
== UDW
3644 || the_insn
.fpof2
== UQW
)
3649 else if (the_insn
.fpof1
== W
3650 || the_insn
.fpof1
== DW
3651 || the_insn
.fpof1
== QW
)
3653 if (the_insn
.fpof2
== SGL
3654 || the_insn
.fpof2
== DBL
3655 || the_insn
.fpof2
== QUAD
)
3660 else if (the_insn
.fpof1
== UW
3661 || the_insn
.fpof1
== UDW
3662 || the_insn
.fpof1
== UQW
)
3664 if (the_insn
.fpof2
== SGL
3665 || the_insn
.fpof2
== DBL
3666 || the_insn
.fpof2
== QUAD
)
3671 flag
|= the_insn
.trunc
;
3672 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 15);
3674 /* Handle a source FP operand format completer. */
3676 flag
= pa_parse_fp_format (&s
);
3677 the_insn
.fpof1
= flag
;
3678 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
3680 /* Handle a destination FP operand format completer. */
3682 /* pa_parse_format needs the ',' prefix. */
3684 flag
= pa_parse_fp_format (&s
);
3685 the_insn
.fpof2
= flag
;
3686 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 13);
3688 /* Handle a source FP operand format completer at 20. */
3690 flag
= pa_parse_fp_format (&s
);
3691 the_insn
.fpof1
= flag
;
3692 INSERT_FIELD_AND_CONTINUE (opcode
, flag
, 11);
3694 /* Handle a floating point operand format at 26.
3695 Only allows single and double precision. */
3697 flag
= pa_parse_fp_format (&s
);
3703 the_insn
.fpof1
= flag
;
3709 as_bad (_("Invalid Floating Point Operand Format."));
3713 /* Handle all floating point registers. */
3717 /* Float target register. */
3719 if (!pa_parse_number (&s
, 3))
3721 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3722 CHECK_FIELD (num
, 31, 0, 0);
3723 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3725 /* Float target register with L/R selection. */
3728 if (!pa_parse_number (&s
, 1))
3730 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3731 CHECK_FIELD (num
, 31, 0, 0);
3734 /* 0x30 opcodes are FP arithmetic operation opcodes
3735 and need to be turned into 0x38 opcodes. This
3736 is not necessary for loads/stores. */
3737 if (need_pa11_opcode ()
3738 && ((opcode
& 0xfc000000) == 0x30000000))
3741 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 6 : 0);
3745 /* Float operand 1. */
3748 if (!pa_parse_number (&s
, 1))
3750 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3751 CHECK_FIELD (num
, 31, 0, 0);
3752 opcode
|= num
<< 21;
3753 if (need_pa11_opcode ())
3755 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 7 : 0);
3761 /* Float operand 1 with L/R selection. */
3765 if (!pa_parse_number (&s
, 1))
3767 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3768 CHECK_FIELD (num
, 31, 0, 0);
3769 opcode
|= num
<< 21;
3770 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 7 : 0);
3774 /* Float operand 2. */
3777 if (!pa_parse_number (&s
, 1))
3779 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3780 CHECK_FIELD (num
, 31, 0, 0);
3781 opcode
|= num
<< 16;
3782 if (need_pa11_opcode ())
3784 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 12 : 0);
3790 /* Float operand 2 with L/R selection. */
3793 if (!pa_parse_number (&s
, 1))
3795 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3796 CHECK_FIELD (num
, 31, 0, 0);
3797 opcode
|= num
<< 16;
3798 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 12 : 0);
3802 /* Float operand 3 for fmpyfadd, fmpynfadd. */
3805 if (!pa_parse_number (&s
, 1))
3807 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3808 CHECK_FIELD (num
, 31, 0, 0);
3809 opcode
|= (num
& 0x1c) << 11;
3810 opcode
|= (num
& 0x03) << 9;
3811 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 8 : 0);
3815 /* Float mult operand 1 for fmpyadd, fmpysub */
3818 if (!pa_parse_number (&s
, 1))
3820 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3821 CHECK_FIELD (num
, 31, 0, 0);
3822 if (the_insn
.fpof1
== SGL
)
3826 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3830 num
|= (pa_number
& FP_REG_RSEL
? 1 << 4 : 0);
3832 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 21);
3835 /* Float mult operand 2 for fmpyadd, fmpysub */
3838 if (!pa_parse_number (&s
, 1))
3840 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3841 CHECK_FIELD (num
, 31, 0, 0);
3842 if (the_insn
.fpof1
== SGL
)
3846 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3850 num
|= (pa_number
& FP_REG_RSEL
? 1 << 4 : 0);
3852 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 16);
3855 /* Float mult target for fmpyadd, fmpysub */
3858 if (!pa_parse_number (&s
, 1))
3860 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3861 CHECK_FIELD (num
, 31, 0, 0);
3862 if (the_insn
.fpof1
== SGL
)
3866 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3870 num
|= (pa_number
& FP_REG_RSEL
? 1 << 4 : 0);
3872 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 0);
3875 /* Float add operand 1 for fmpyadd, fmpysub */
3878 if (!pa_parse_number (&s
, 1))
3880 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3881 CHECK_FIELD (num
, 31, 0, 0);
3882 if (the_insn
.fpof1
== SGL
)
3886 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3890 num
|= (pa_number
& FP_REG_RSEL
? 1 << 4 : 0);
3892 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 6);
3895 /* Float add target for fmpyadd, fmpysub */
3898 if (!pa_parse_number (&s
, 1))
3900 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3901 CHECK_FIELD (num
, 31, 0, 0);
3902 if (the_insn
.fpof1
== SGL
)
3906 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3910 num
|= (pa_number
& FP_REG_RSEL
? 1 << 4 : 0);
3912 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 11);
3915 /* Handle L/R register halves like 'x'. */
3919 if (!pa_parse_number (&s
, 1))
3921 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3922 CHECK_FIELD (num
, 31, 0, 0);
3923 opcode
|= num
<< 16;
3924 if (need_pa11_opcode ())
3926 opcode
|= (pa_number
& FP_REG_RSEL
? 1 << 1 : 0);
3931 /* Float target register (PA 2.0 wide). */
3933 if (!pa_parse_number (&s
, 3))
3935 num
= (pa_number
& ~FP_REG_RSEL
) - FP_REG_BASE
;
3936 CHECK_FIELD (num
, 31, 0, 0);
3937 INSERT_FIELD_AND_CONTINUE (opcode
, num
, 16);
3951 /* Check if the args matched. */
3954 if (&insn
[1] - pa_opcodes
< (int) NUMOPCODES
3955 && !strcmp (insn
->name
, insn
[1].name
))
3963 as_bad (_("Invalid operands %s"), error_message
);
3970 the_insn
.opcode
= opcode
;
3973 /* Turn a string in input_line_pointer into a floating point constant of type
3974 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
3975 emitted is stored in *sizeP . An error message or NULL is returned. */
3977 #define MAX_LITTLENUMS 6
3980 md_atof (type
, litP
, sizeP
)
3986 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
3987 LITTLENUM_TYPE
*wordP
;
4019 return _("Bad call to MD_ATOF()");
4021 t
= atof_ieee (input_line_pointer
, type
, words
);
4023 input_line_pointer
= t
;
4024 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
4025 for (wordP
= words
; prec
--;)
4027 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
4028 litP
+= sizeof (LITTLENUM_TYPE
);
4033 /* Write out big-endian. */
4036 md_number_to_chars (buf
, val
, n
)
4041 number_to_chars_bigendian (buf
, val
, n
);
4044 /* Translate internal representation of relocation info to BFD target
4048 tc_gen_reloc (section
, fixp
)
4053 struct hppa_fix_struct
*hppa_fixp
;
4054 static arelent
*no_relocs
= NULL
;
4061 hppa_fixp
= (struct hppa_fix_struct
*) fixp
->tc_fix_data
;
4062 if (fixp
->fx_addsy
== 0)
4065 assert (hppa_fixp
!= 0);
4066 assert (section
!= 0);
4068 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
4070 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4071 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
4072 codes
= hppa_gen_reloc_type (stdoutput
,
4074 hppa_fixp
->fx_r_format
,
4075 hppa_fixp
->fx_r_field
,
4076 fixp
->fx_subsy
!= NULL
,
4077 symbol_get_bfdsym (fixp
->fx_addsy
));
4081 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, _("Cannot handle fixup"));
4085 for (n_relocs
= 0; codes
[n_relocs
]; n_relocs
++)
4088 relocs
= (arelent
**) xmalloc (sizeof (arelent
*) * n_relocs
+ 1);
4089 reloc
= (arelent
*) xmalloc (sizeof (arelent
) * n_relocs
);
4090 for (i
= 0; i
< n_relocs
; i
++)
4091 relocs
[i
] = &reloc
[i
];
4093 relocs
[n_relocs
] = NULL
;
4096 switch (fixp
->fx_r_type
)
4099 assert (n_relocs
== 1);
4103 /* Now, do any processing that is dependent on the relocation type. */
4106 case R_PARISC_DLTREL21L
:
4107 case R_PARISC_DLTREL14R
:
4108 case R_PARISC_DLTREL14F
:
4109 case R_PARISC_PLABEL32
:
4110 case R_PARISC_PLABEL21L
:
4111 case R_PARISC_PLABEL14R
:
4112 /* For plabel relocations, the addend of the
4113 relocation should be either 0 (no static link) or 2
4114 (static link required). This adjustment is done in
4115 bfd/elf32-hppa.c:elf32_hppa_relocate_section.
4117 We also slam a zero addend into the DLT relative relocs;
4118 it doesn't make a lot of sense to use any addend since
4119 it gets you a different (eg unknown) DLT entry. */
4123 #ifdef ELF_ARG_RELOC
4124 case R_PARISC_PCREL17R
:
4125 case R_PARISC_PCREL17F
:
4126 case R_PARISC_PCREL17C
:
4127 case R_PARISC_DIR17R
:
4128 case R_PARISC_DIR17F
:
4129 case R_PARISC_PCREL21L
:
4130 case R_PARISC_DIR21L
:
4131 reloc
->addend
= HPPA_R_ADDEND (hppa_fixp
->fx_arg_reloc
,
4136 case R_PARISC_DIR32
:
4137 /* Facilitate hand-crafted unwind info. */
4138 if (strcmp (section
->name
, UNWIND_SECTION_NAME
) == 0)
4139 code
= R_PARISC_SEGREL32
;
4143 reloc
->addend
= fixp
->fx_offset
;
4147 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4148 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
4149 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
,
4150 (bfd_reloc_code_real_type
) code
);
4151 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4153 assert (reloc
->howto
&& (unsigned int) code
== reloc
->howto
->type
);
4158 /* Walk over reach relocation returned by the BFD backend. */
4159 for (i
= 0; i
< n_relocs
; i
++)
4163 relocs
[i
]->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4164 *relocs
[i
]->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
4166 bfd_reloc_type_lookup (stdoutput
,
4167 (bfd_reloc_code_real_type
) code
);
4168 relocs
[i
]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4173 /* The only time we ever use a R_COMP2 fixup is for the difference
4174 of two symbols. With that in mind we fill in all four
4175 relocs now and break out of the loop. */
4177 relocs
[0]->sym_ptr_ptr
= (asymbol
**) &(bfd_abs_symbol
);
4179 bfd_reloc_type_lookup (stdoutput
,
4180 (bfd_reloc_code_real_type
) *codes
[0]);
4181 relocs
[0]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4182 relocs
[0]->addend
= 0;
4183 relocs
[1]->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4184 *relocs
[1]->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
4186 bfd_reloc_type_lookup (stdoutput
,
4187 (bfd_reloc_code_real_type
) *codes
[1]);
4188 relocs
[1]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4189 relocs
[1]->addend
= 0;
4190 relocs
[2]->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4191 *relocs
[2]->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_subsy
);
4193 bfd_reloc_type_lookup (stdoutput
,
4194 (bfd_reloc_code_real_type
) *codes
[2]);
4195 relocs
[2]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4196 relocs
[2]->addend
= 0;
4197 relocs
[3]->sym_ptr_ptr
= (asymbol
**) &(bfd_abs_symbol
);
4199 bfd_reloc_type_lookup (stdoutput
,
4200 (bfd_reloc_code_real_type
) *codes
[3]);
4201 relocs
[3]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4202 relocs
[3]->addend
= 0;
4203 relocs
[4]->sym_ptr_ptr
= (asymbol
**) &(bfd_abs_symbol
);
4205 bfd_reloc_type_lookup (stdoutput
,
4206 (bfd_reloc_code_real_type
) *codes
[4]);
4207 relocs
[4]->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4208 relocs
[4]->addend
= 0;
4212 relocs
[i
]->addend
= HPPA_R_ADDEND (hppa_fixp
->fx_arg_reloc
, 0);
4218 /* For plabel relocations, the addend of the
4219 relocation should be either 0 (no static link) or 2
4220 (static link required).
4222 FIXME: We always assume no static link!
4224 We also slam a zero addend into the DLT relative relocs;
4225 it doesn't make a lot of sense to use any addend since
4226 it gets you a different (eg unknown) DLT entry. */
4227 relocs
[i
]->addend
= 0;
4242 /* There is no symbol or addend associated with these fixups. */
4243 relocs
[i
]->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4244 *relocs
[i
]->sym_ptr_ptr
= symbol_get_bfdsym (dummy_symbol
);
4245 relocs
[i
]->addend
= 0;
4251 /* There is no symbol associated with these fixups. */
4252 relocs
[i
]->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4253 *relocs
[i
]->sym_ptr_ptr
= symbol_get_bfdsym (dummy_symbol
);
4254 relocs
[i
]->addend
= fixp
->fx_offset
;
4258 relocs
[i
]->addend
= fixp
->fx_offset
;
4268 /* Process any machine dependent frag types. */
4271 md_convert_frag (abfd
, sec
, fragP
)
4272 register bfd
*abfd ATTRIBUTE_UNUSED
;
4273 register asection
*sec ATTRIBUTE_UNUSED
;
4274 register fragS
*fragP
;
4276 unsigned int address
;
4278 if (fragP
->fr_type
== rs_machine_dependent
)
4280 switch ((int) fragP
->fr_subtype
)
4283 fragP
->fr_type
= rs_fill
;
4284 know (fragP
->fr_var
== 1);
4285 know (fragP
->fr_next
);
4286 address
= fragP
->fr_address
+ fragP
->fr_fix
;
4287 if (address
% fragP
->fr_offset
)
4290 fragP
->fr_next
->fr_address
4295 fragP
->fr_offset
= 0;
4301 /* Round up a section size to the appropriate boundary. */
4304 md_section_align (segment
, size
)
4308 int align
= bfd_get_section_alignment (stdoutput
, segment
);
4309 int align2
= (1 << align
) - 1;
4311 return (size
+ align2
) & ~align2
;
4314 /* Return the approximate size of a frag before relaxation has occurred. */
4316 md_estimate_size_before_relax (fragP
, segment
)
4317 register fragS
*fragP
;
4318 asection
*segment ATTRIBUTE_UNUSED
;
4324 while ((fragP
->fr_fix
+ size
) % fragP
->fr_offset
)
4331 # ifdef WARN_COMMENTS
4332 const char *md_shortopts
= "Vc";
4334 const char *md_shortopts
= "V";
4337 # ifdef WARN_COMMENTS
4338 const char *md_shortopts
= "c";
4340 const char *md_shortopts
= "";
4344 struct option md_longopts
[] = {
4345 #ifdef WARN_COMMENTS
4346 {"warn-comment", no_argument
, NULL
, 'c'},
4348 {NULL
, no_argument
, NULL
, 0}
4350 size_t md_longopts_size
= sizeof (md_longopts
);
4353 md_parse_option (c
, arg
)
4354 int c ATTRIBUTE_UNUSED
;
4355 char *arg ATTRIBUTE_UNUSED
;
4364 print_version_id ();
4367 #ifdef WARN_COMMENTS
4378 md_show_usage (stream
)
4379 FILE *stream ATTRIBUTE_UNUSED
;
4382 fprintf (stream
, _("\
4385 #ifdef WARN_COMMENTS
4386 fprintf (stream
, _("\
4387 -c print a warning if a comment is found\n"));
4391 /* We have no need to default values of symbols. */
4394 md_undefined_symbol (name
)
4395 char *name ATTRIBUTE_UNUSED
;
4400 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
4401 #define nonzero_dibits(x) \
4402 ((x) | (((x) & 0x55555555) << 1) | (((x) & 0xAAAAAAAA) >> 1))
4403 #define arg_reloc_stub_needed(CALLER, CALLEE) \
4404 (((CALLER) ^ (CALLEE)) & nonzero_dibits (CALLER) & nonzero_dibits (CALLEE))
4406 #define arg_reloc_stub_needed(CALLER, CALLEE) 0
4409 /* Apply a fixup to an instruction. */
4412 md_apply_fix3 (fixP
, valP
, seg
)
4415 segT seg ATTRIBUTE_UNUSED
;
4418 struct hppa_fix_struct
*hppa_fixP
;
4422 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
4425 /* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
4426 never be "applied" (they are just markers). Likewise for
4427 R_HPPA_BEGIN_BRTAB and R_HPPA_END_BRTAB. */
4429 if (fixP
->fx_r_type
== R_HPPA_ENTRY
4430 || fixP
->fx_r_type
== R_HPPA_EXIT
4431 || fixP
->fx_r_type
== R_HPPA_BEGIN_BRTAB
4432 || fixP
->fx_r_type
== R_HPPA_END_BRTAB
4433 || fixP
->fx_r_type
== R_HPPA_BEGIN_TRY
)
4436 /* Disgusting. We must set fx_offset ourselves -- R_HPPA_END_TRY
4437 fixups are considered not adjustable, which in turn causes
4438 adjust_reloc_syms to not set fx_offset. Ugh. */
4439 if (fixP
->fx_r_type
== R_HPPA_END_TRY
)
4441 fixP
->fx_offset
= * valP
;
4446 if (fixP
->fx_r_type
== (int) R_PARISC_GNU_VTENTRY
4447 || fixP
->fx_r_type
== (int) R_PARISC_GNU_VTINHERIT
)
4451 /* There should have been an HPPA specific fixup associated
4452 with the GAS fixup. */
4453 hppa_fixP
= (struct hppa_fix_struct
*) fixP
->tc_fix_data
;
4454 if (hppa_fixP
== NULL
)
4456 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4457 _("no hppa_fixup entry for fixup type 0x%x"),
4462 buf
= (unsigned char *) (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
);
4463 insn
= bfd_get_32 (stdoutput
, buf
);
4464 fmt
= bfd_hppa_insn2fmt (stdoutput
, insn
);
4466 /* If there is a symbol associated with this fixup, then it's something
4467 which will need a SOM relocation (except for some PC-relative relocs).
4468 In such cases we should treat the "val" or "addend" as zero since it
4469 will be added in as needed from fx_offset in tc_gen_reloc. */
4470 if ((fixP
->fx_addsy
!= NULL
4471 || fixP
->fx_r_type
== (int) R_HPPA_NONE
)
4476 new_val
= ((fmt
== 12 || fmt
== 17 || fmt
== 22) ? 8 : 0);
4478 /* These field selectors imply that we do not want an addend. */
4479 else if (hppa_fixP
->fx_r_field
== e_psel
4480 || hppa_fixP
->fx_r_field
== e_rpsel
4481 || hppa_fixP
->fx_r_field
== e_lpsel
4482 || hppa_fixP
->fx_r_field
== e_tsel
4483 || hppa_fixP
->fx_r_field
== e_rtsel
4484 || hppa_fixP
->fx_r_field
== e_ltsel
)
4485 new_val
= ((fmt
== 12 || fmt
== 17 || fmt
== 22) ? 8 : 0);
4488 new_val
= hppa_field_adjust (* valP
, 0, hppa_fixP
->fx_r_field
);
4490 /* Handle pc-relative exceptions from above. */
4491 if ((fmt
== 12 || fmt
== 17 || fmt
== 22)
4494 && !arg_reloc_stub_needed (symbol_arg_reloc_info (fixP
->fx_addsy
),
4495 hppa_fixP
->fx_arg_reloc
)
4497 && (* valP
- 8 + 8192 < 16384
4498 || (fmt
== 17 && * valP
- 8 + 262144 < 524288)
4499 || (fmt
== 22 && * valP
- 8 + 8388608 < 16777216))
4502 && (* valP
- 8 + 262144 < 524288
4503 || (fmt
== 22 && * valP
- 8 + 8388608 < 16777216))
4505 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
4506 && !S_IS_WEAK (fixP
->fx_addsy
)
4507 && S_GET_SEGMENT (fixP
->fx_addsy
) == hppa_fixP
->segment
4509 && S_GET_SEGMENT (fixP
->fx_subsy
) != hppa_fixP
->segment
))
4511 new_val
= hppa_field_adjust (* valP
, 0, hppa_fixP
->fx_r_field
);
4517 CHECK_FIELD_WHERE (new_val
, 8191, -8192,
4518 fixP
->fx_file
, fixP
->fx_line
);
4521 insn
= (insn
& ~ 0x3ff1) | (((val
& 0x1ff8) << 1)
4522 | ((val
& 0x2000) >> 13));
4525 CHECK_FIELD_WHERE (new_val
, 8191, -8192,
4526 fixP
->fx_file
, fixP
->fx_line
);
4529 insn
= (insn
& ~ 0x3ff9) | (((val
& 0x1ffc) << 1)
4530 | ((val
& 0x2000) >> 13));
4532 /* Handle all opcodes with the 'j' operand type. */
4534 CHECK_FIELD_WHERE (new_val
, 8191, -8192,
4535 fixP
->fx_file
, fixP
->fx_line
);
4538 insn
= ((insn
& ~ 0x3fff) | low_sign_unext (val
, 14));
4541 /* Handle all opcodes with the 'k' operand type. */
4543 CHECK_FIELD_WHERE (new_val
, 1048575, -1048576,
4544 fixP
->fx_file
, fixP
->fx_line
);
4547 insn
= (insn
& ~ 0x1fffff) | re_assemble_21 (val
);
4550 /* Handle all the opcodes with the 'i' operand type. */
4552 CHECK_FIELD_WHERE (new_val
, 1023, -1024,
4553 fixP
->fx_file
, fixP
->fx_line
);
4556 insn
= (insn
& ~ 0x7ff) | low_sign_unext (val
, 11);
4559 /* Handle all the opcodes with the 'w' operand type. */
4561 CHECK_FIELD_WHERE (new_val
- 8, 8191, -8192,
4562 fixP
->fx_file
, fixP
->fx_line
);
4565 insn
= (insn
& ~ 0x1ffd) | re_assemble_12 (val
>> 2);
4568 /* Handle some of the opcodes with the 'W' operand type. */
4571 offsetT distance
= * valP
;
4573 /* If this is an absolute branch (ie no link) with an out of
4574 range target, then we want to complain. */
4575 if (fixP
->fx_r_type
== (int) R_HPPA_PCREL_CALL
4576 && (insn
& 0xffe00000) == 0xe8000000)
4577 CHECK_FIELD_WHERE (distance
- 8, 262143, -262144,
4578 fixP
->fx_file
, fixP
->fx_line
);
4580 CHECK_FIELD_WHERE (new_val
- 8, 262143, -262144,
4581 fixP
->fx_file
, fixP
->fx_line
);
4584 insn
= (insn
& ~ 0x1f1ffd) | re_assemble_17 (val
>> 2);
4590 offsetT distance
= * valP
;
4592 /* If this is an absolute branch (ie no link) with an out of
4593 range target, then we want to complain. */
4594 if (fixP
->fx_r_type
== (int) R_HPPA_PCREL_CALL
4595 && (insn
& 0xffe00000) == 0xe8000000)
4596 CHECK_FIELD_WHERE (distance
- 8, 8388607, -8388608,
4597 fixP
->fx_file
, fixP
->fx_line
);
4599 CHECK_FIELD_WHERE (new_val
- 8, 8388607, -8388608,
4600 fixP
->fx_file
, fixP
->fx_line
);
4603 insn
= (insn
& ~ 0x3ff1ffd) | re_assemble_22 (val
>> 2);
4609 insn
= (insn
& ~ 0xfff1) | re_assemble_16 (val
& -8);
4614 insn
= (insn
& ~ 0xfff9) | re_assemble_16 (val
& -4);
4619 insn
= (insn
& ~ 0xffff) | re_assemble_16 (val
);
4627 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4628 _("Unknown relocation encountered in md_apply_fix."));
4632 /* Insert the relocation. */
4633 bfd_put_32 (stdoutput
, insn
, buf
);
4636 /* Exactly what point is a PC-relative offset relative TO?
4637 On the PA, they're relative to the address of the offset. */
4640 md_pcrel_from (fixP
)
4643 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
4646 /* Return nonzero if the input line pointer is at the end of
4650 is_end_of_statement ()
4652 return ((*input_line_pointer
== '\n')
4653 || (*input_line_pointer
== ';')
4654 || (*input_line_pointer
== '!'));
4657 /* Read a number from S. The number might come in one of many forms,
4658 the most common will be a hex or decimal constant, but it could be
4659 a pre-defined register (Yuk!), or an absolute symbol.
4661 Return 1 on success or 0 on failure. If STRICT, then a missing
4662 register prefix will cause a failure. The number itself is
4663 returned in `pa_number'.
4665 IS_FLOAT indicates that a PA-89 FP register number should be
4666 parsed; A `l' or `r' suffix is checked for if but 2 of IS_FLOAT is
4669 pa_parse_number can not handle negative constants and will fail
4670 horribly if it is passed such a constant. */
4673 pa_parse_number (s
, is_float
)
4683 boolean have_prefix
;
4685 /* Skip whitespace before the number. */
4686 while (*p
== ' ' || *p
== '\t')
4692 if (!strict
&& ISDIGIT (*p
))
4694 /* Looks like a number. */
4696 if (*p
== '0' && (*(p
+ 1) == 'x' || *(p
+ 1) == 'X'))
4698 /* The number is specified in hex. */
4700 while (ISDIGIT (*p
) || ((*p
>= 'a') && (*p
<= 'f'))
4701 || ((*p
>= 'A') && (*p
<= 'F')))
4704 num
= num
* 16 + *p
- '0';
4705 else if (*p
>= 'a' && *p
<= 'f')
4706 num
= num
* 16 + *p
- 'a' + 10;
4708 num
= num
* 16 + *p
- 'A' + 10;
4714 /* The number is specified in decimal. */
4715 while (ISDIGIT (*p
))
4717 num
= num
* 10 + *p
- '0';
4724 /* Check for a `l' or `r' suffix. */
4727 pa_number
+= FP_REG_BASE
;
4728 if (! (is_float
& 2))
4730 if (IS_R_SELECT (p
))
4732 pa_number
+= FP_REG_RSEL
;
4735 else if (IS_L_SELECT (p
))
4744 /* The number might be a predefined register. */
4749 /* Tege hack: Special case for general registers as the general
4750 code makes a binary search with case translation, and is VERY
4755 if (*p
== 'e' && *(p
+ 1) == 't'
4756 && (*(p
+ 2) == '0' || *(p
+ 2) == '1'))
4759 num
= *p
- '0' + 28;
4767 else if (!ISDIGIT (*p
))
4770 as_bad (_("Undefined register: '%s'."), name
);
4776 num
= num
* 10 + *p
++ - '0';
4777 while (ISDIGIT (*p
));
4782 /* Do a normal register search. */
4783 while (is_part_of_name (c
))
4789 status
= reg_name_search (name
);
4795 as_bad (_("Undefined register: '%s'."), name
);
4805 /* And finally, it could be a symbol in the absolute section which
4806 is effectively a constant, or a register alias symbol. */
4809 while (is_part_of_name (c
))
4815 if ((sym
= symbol_find (name
)) != NULL
)
4817 if (S_GET_SEGMENT (sym
) == reg_section
)
4819 num
= S_GET_VALUE (sym
);
4820 /* Well, we don't really have one, but we do have a
4824 else if (S_GET_SEGMENT (sym
) == &bfd_abs_section
)
4825 num
= S_GET_VALUE (sym
);
4829 as_bad (_("Non-absolute symbol: '%s'."), name
);
4835 /* There is where we'd come for an undefined symbol
4836 or for an empty string. For an empty string we
4837 will return zero. That's a concession made for
4838 compatability with the braindamaged HP assemblers. */
4844 as_bad (_("Undefined absolute constant: '%s'."), name
);
4853 if (!strict
|| have_prefix
)
4861 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
4863 /* Given NAME, find the register number associated with that name, return
4864 the integer value associated with the given name or -1 on failure. */
4867 reg_name_search (name
)
4870 int middle
, low
, high
;
4874 high
= REG_NAME_CNT
- 1;
4878 middle
= (low
+ high
) / 2;
4879 cmp
= strcasecmp (name
, pre_defined_registers
[middle
].name
);
4885 return pre_defined_registers
[middle
].value
;
4887 while (low
<= high
);
4892 /* Return nonzero if the given INSN and L/R information will require
4893 a new PA-1.1 opcode. */
4898 if ((pa_number
& FP_REG_RSEL
) != 0
4899 && !(the_insn
.fpof1
== DBL
&& the_insn
.fpof2
== DBL
))
4901 /* If this instruction is specific to a particular architecture,
4902 then set a new architecture. */
4903 if (bfd_get_mach (stdoutput
) < pa11
)
4905 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, pa11
))
4906 as_warn (_("could not update architecture and machine"));
4914 /* Parse a condition for a fcmp instruction. Return the numerical
4915 code associated with the condition. */
4918 pa_parse_fp_cmp_cond (s
)
4925 for (i
= 0; i
< 32; i
++)
4927 if (strncasecmp (*s
, fp_cond_map
[i
].string
,
4928 strlen (fp_cond_map
[i
].string
)) == 0)
4930 cond
= fp_cond_map
[i
].cond
;
4931 *s
+= strlen (fp_cond_map
[i
].string
);
4932 /* If not a complete match, back up the input string and
4934 if (**s
!= ' ' && **s
!= '\t')
4936 *s
-= strlen (fp_cond_map
[i
].string
);
4939 while (**s
== ' ' || **s
== '\t')
4945 as_bad (_("Invalid FP Compare Condition: %s"), *s
);
4947 /* Advance over the bogus completer. */
4948 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
4954 /* Parse a graphics test complete for ftest. */
4957 pa_parse_ftest_gfx_completer (s
)
4963 if (strncasecmp (*s
, "acc8", 4) == 0)
4968 else if (strncasecmp (*s
, "acc6", 4) == 0)
4973 else if (strncasecmp (*s
, "acc4", 4) == 0)
4978 else if (strncasecmp (*s
, "acc2", 4) == 0)
4983 else if (strncasecmp (*s
, "acc", 3) == 0)
4988 else if (strncasecmp (*s
, "rej8", 4) == 0)
4993 else if (strncasecmp (*s
, "rej", 3) == 0)
5001 as_bad (_("Invalid FTEST completer: %s"), *s
);
5007 /* Parse an FP operand format completer returning the completer
5010 static fp_operand_format
5011 pa_parse_fp_cnv_format (s
)
5020 if (strncasecmp (*s
, "sgl", 3) == 0)
5025 else if (strncasecmp (*s
, "dbl", 3) == 0)
5030 else if (strncasecmp (*s
, "quad", 4) == 0)
5035 else if (strncasecmp (*s
, "w", 1) == 0)
5040 else if (strncasecmp (*s
, "uw", 2) == 0)
5045 else if (strncasecmp (*s
, "dw", 2) == 0)
5050 else if (strncasecmp (*s
, "udw", 3) == 0)
5055 else if (strncasecmp (*s
, "qw", 2) == 0)
5060 else if (strncasecmp (*s
, "uqw", 3) == 0)
5067 format
= ILLEGAL_FMT
;
5068 as_bad (_("Invalid FP Operand Format: %3s"), *s
);
5075 /* Parse an FP operand format completer returning the completer
5078 static fp_operand_format
5079 pa_parse_fp_format (s
)
5088 if (strncasecmp (*s
, "sgl", 3) == 0)
5093 else if (strncasecmp (*s
, "dbl", 3) == 0)
5098 else if (strncasecmp (*s
, "quad", 4) == 0)
5105 format
= ILLEGAL_FMT
;
5106 as_bad (_("Invalid FP Operand Format: %3s"), *s
);
5113 /* Convert from a selector string into a selector type. */
5116 pa_chk_field_selector (str
)
5119 int middle
, low
, high
;
5123 /* Read past any whitespace. */
5124 /* FIXME: should we read past newlines and formfeeds??? */
5125 while (**str
== ' ' || **str
== '\t' || **str
== '\n' || **str
== '\f')
5128 if ((*str
)[1] == '\'' || (*str
)[1] == '%')
5129 name
[0] = TOLOWER ((*str
)[0]),
5131 else if ((*str
)[2] == '\'' || (*str
)[2] == '%')
5132 name
[0] = TOLOWER ((*str
)[0]),
5133 name
[1] = TOLOWER ((*str
)[1]),
5135 else if ((*str
)[3] == '\'' || (*str
)[3] == '%')
5136 name
[0] = TOLOWER ((*str
)[0]),
5137 name
[1] = TOLOWER ((*str
)[1]),
5138 name
[2] = TOLOWER ((*str
)[2]),
5144 high
= sizeof (selector_table
) / sizeof (struct selector_entry
) - 1;
5148 middle
= (low
+ high
) / 2;
5149 cmp
= strcmp (name
, selector_table
[middle
].prefix
);
5156 *str
+= strlen (name
) + 1;
5158 if (selector_table
[middle
].field_selector
== e_nsel
)
5161 return selector_table
[middle
].field_selector
;
5164 while (low
<= high
);
5169 /* Mark (via expr_end) the end of an expression (I think). FIXME. */
5172 get_expression (str
)
5178 save_in
= input_line_pointer
;
5179 input_line_pointer
= str
;
5180 seg
= expression (&the_insn
.exp
);
5181 if (!(seg
== absolute_section
5182 || seg
== undefined_section
5183 || SEG_NORMAL (seg
)))
5185 as_warn (_("Bad segment in expression."));
5186 expr_end
= input_line_pointer
;
5187 input_line_pointer
= save_in
;
5190 expr_end
= input_line_pointer
;
5191 input_line_pointer
= save_in
;
5195 /* Mark (via expr_end) the end of an absolute expression. FIXME. */
5197 pa_get_absolute_expression (insn
, strp
)
5203 insn
->field_selector
= pa_chk_field_selector (strp
);
5204 save_in
= input_line_pointer
;
5205 input_line_pointer
= *strp
;
5206 expression (&insn
->exp
);
5207 /* This is not perfect, but is a huge improvement over doing nothing.
5209 The PA assembly syntax is ambigious in a variety of ways. Consider
5210 this string "4 %r5" Is that the number 4 followed by the register
5211 r5, or is that 4 MOD r5?
5213 If we get a modulo expresion When looking for an absolute, we try
5214 again cutting off the input string at the first whitespace character. */
5215 if (insn
->exp
.X_op
== O_modulus
)
5220 input_line_pointer
= *strp
;
5222 while (*s
!= ',' && *s
!= ' ' && *s
!= '\t')
5228 retval
= pa_get_absolute_expression (insn
, strp
);
5230 input_line_pointer
= save_in
;
5232 return evaluate_absolute (insn
);
5234 /* When in strict mode we have a non-match, fix up the pointers
5235 and return to our caller. */
5236 if (insn
->exp
.X_op
!= O_constant
&& strict
)
5238 expr_end
= input_line_pointer
;
5239 input_line_pointer
= save_in
;
5242 if (insn
->exp
.X_op
!= O_constant
)
5244 as_bad (_("Bad segment (should be absolute)."));
5245 expr_end
= input_line_pointer
;
5246 input_line_pointer
= save_in
;
5249 expr_end
= input_line_pointer
;
5250 input_line_pointer
= save_in
;
5251 return evaluate_absolute (insn
);
5254 /* Evaluate an absolute expression EXP which may be modified by
5255 the selector FIELD_SELECTOR. Return the value of the expression. */
5257 evaluate_absolute (insn
)
5262 int field_selector
= insn
->field_selector
;
5265 value
= exp
.X_add_number
;
5267 return hppa_field_adjust (0, value
, field_selector
);
5270 /* Given an argument location specification return the associated
5271 argument location number. */
5274 pa_build_arg_reloc (type_name
)
5278 if (strncasecmp (type_name
, "no", 2) == 0)
5280 if (strncasecmp (type_name
, "gr", 2) == 0)
5282 else if (strncasecmp (type_name
, "fr", 2) == 0)
5284 else if (strncasecmp (type_name
, "fu", 2) == 0)
5287 as_bad (_("Invalid argument location: %s\n"), type_name
);
5292 /* Encode and return an argument relocation specification for
5293 the given register in the location specified by arg_reloc. */
5296 pa_align_arg_reloc (reg
, arg_reloc
)
5298 unsigned int arg_reloc
;
5300 unsigned int new_reloc
;
5302 new_reloc
= arg_reloc
;
5318 as_bad (_("Invalid argument description: %d"), reg
);
5324 /* Parse a PA nullification completer (,n). Return nonzero if the
5325 completer was found; return zero if no completer was found. */
5337 if (strncasecmp (*s
, "n", 1) == 0)
5341 as_bad (_("Invalid Nullification: (%c)"), **s
);
5350 /* Parse a non-negated compare/subtract completer returning the
5351 number (for encoding in instrutions) of the given completer. */
5354 pa_parse_nonneg_cmpsub_cmpltr (s
)
5358 char *name
= *s
+ 1;
5367 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5372 if (strcmp (name
, "=") == 0)
5376 else if (strcmp (name
, "<") == 0)
5380 else if (strcmp (name
, "<=") == 0)
5384 else if (strcmp (name
, "<<") == 0)
5388 else if (strcmp (name
, "<<=") == 0)
5392 else if (strcasecmp (name
, "sv") == 0)
5396 else if (strcasecmp (name
, "od") == 0)
5400 /* If we have something like addb,n then there is no condition
5402 else if (strcasecmp (name
, "n") == 0)
5414 /* Reset pointers if this was really a ,n for a branch instruction. */
5421 /* Parse a negated compare/subtract completer returning the
5422 number (for encoding in instrutions) of the given completer. */
5425 pa_parse_neg_cmpsub_cmpltr (s
)
5429 char *name
= *s
+ 1;
5438 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5443 if (strcasecmp (name
, "tr") == 0)
5447 else if (strcmp (name
, "<>") == 0)
5451 else if (strcmp (name
, ">=") == 0)
5455 else if (strcmp (name
, ">") == 0)
5459 else if (strcmp (name
, ">>=") == 0)
5463 else if (strcmp (name
, ">>") == 0)
5467 else if (strcasecmp (name
, "nsv") == 0)
5471 else if (strcasecmp (name
, "ev") == 0)
5475 /* If we have something like addb,n then there is no condition
5477 else if (strcasecmp (name
, "n") == 0)
5489 /* Reset pointers if this was really a ,n for a branch instruction. */
5496 /* Parse a 64 bit compare and branch completer returning the number (for
5497 encoding in instrutions) of the given completer.
5499 Nonnegated comparisons are returned as 0-7, negated comparisons are
5500 returned as 8-15. */
5503 pa_parse_cmpb_64_cmpltr (s
)
5507 char *name
= *s
+ 1;
5514 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5519 if (strcmp (name
, "*") == 0)
5523 else if (strcmp (name
, "*=") == 0)
5527 else if (strcmp (name
, "*<") == 0)
5531 else if (strcmp (name
, "*<=") == 0)
5535 else if (strcmp (name
, "*<<") == 0)
5539 else if (strcmp (name
, "*<<=") == 0)
5543 else if (strcasecmp (name
, "*sv") == 0)
5547 else if (strcasecmp (name
, "*od") == 0)
5551 else if (strcasecmp (name
, "*tr") == 0)
5555 else if (strcmp (name
, "*<>") == 0)
5559 else if (strcmp (name
, "*>=") == 0)
5563 else if (strcmp (name
, "*>") == 0)
5567 else if (strcmp (name
, "*>>=") == 0)
5571 else if (strcmp (name
, "*>>") == 0)
5575 else if (strcasecmp (name
, "*nsv") == 0)
5579 else if (strcasecmp (name
, "*ev") == 0)
5593 /* Parse a 64 bit compare immediate and branch completer returning the number
5594 (for encoding in instrutions) of the given completer. */
5597 pa_parse_cmpib_64_cmpltr (s
)
5601 char *name
= *s
+ 1;
5608 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5613 if (strcmp (name
, "*<<") == 0)
5617 else if (strcmp (name
, "*=") == 0)
5621 else if (strcmp (name
, "*<") == 0)
5625 else if (strcmp (name
, "*<=") == 0)
5629 else if (strcmp (name
, "*>>=") == 0)
5633 else if (strcmp (name
, "*<>") == 0)
5637 else if (strcasecmp (name
, "*>=") == 0)
5641 else if (strcasecmp (name
, "*>") == 0)
5655 /* Parse a non-negated addition completer returning the number
5656 (for encoding in instrutions) of the given completer. */
5659 pa_parse_nonneg_add_cmpltr (s
)
5663 char *name
= *s
+ 1;
5672 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5676 if (strcmp (name
, "=") == 0)
5680 else if (strcmp (name
, "<") == 0)
5684 else if (strcmp (name
, "<=") == 0)
5688 else if (strcasecmp (name
, "nuv") == 0)
5692 else if (strcasecmp (name
, "znv") == 0)
5696 else if (strcasecmp (name
, "sv") == 0)
5700 else if (strcasecmp (name
, "od") == 0)
5704 /* If we have something like addb,n then there is no condition
5706 else if (strcasecmp (name
, "n") == 0)
5718 /* Reset pointers if this was really a ,n for a branch instruction. */
5725 /* Parse a negated addition completer returning the number
5726 (for encoding in instrutions) of the given completer. */
5729 pa_parse_neg_add_cmpltr (s
)
5733 char *name
= *s
+ 1;
5742 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5746 if (strcasecmp (name
, "tr") == 0)
5750 else if (strcmp (name
, "<>") == 0)
5754 else if (strcmp (name
, ">=") == 0)
5758 else if (strcmp (name
, ">") == 0)
5762 else if (strcasecmp (name
, "uv") == 0)
5766 else if (strcasecmp (name
, "vnz") == 0)
5770 else if (strcasecmp (name
, "nsv") == 0)
5774 else if (strcasecmp (name
, "ev") == 0)
5778 /* If we have something like addb,n then there is no condition
5780 else if (strcasecmp (name
, "n") == 0)
5792 /* Reset pointers if this was really a ,n for a branch instruction. */
5799 /* Parse a 64 bit wide mode add and branch completer returning the number (for
5800 encoding in instrutions) of the given completer. */
5803 pa_parse_addb_64_cmpltr (s
)
5807 char *name
= *s
+ 1;
5816 while (**s
!= ',' && **s
!= ' ' && **s
!= '\t')
5820 if (strcmp (name
, "=") == 0)
5824 else if (strcmp (name
, "<") == 0)
5828 else if (strcmp (name
, "<=") == 0)
5832 else if (strcasecmp (name
, "nuv") == 0)
5836 else if (strcasecmp (name
, "*=") == 0)
5840 else if (strcasecmp (name
, "*<") == 0)
5844 else if (strcasecmp (name
, "*<=") == 0)
5848 else if (strcmp (name
, "tr") == 0)
5852 else if (strcmp (name
, "<>") == 0)
5856 else if (strcmp (name
, ">=") == 0)
5860 else if (strcmp (name
, ">") == 0)
5864 else if (strcasecmp (name
, "uv") == 0)
5868 else if (strcasecmp (name
, "*<>") == 0)
5872 else if (strcasecmp (name
, "*>=") == 0)
5876 else if (strcasecmp (name
, "*>") == 0)
5880 /* If we have something like addb,n then there is no condition
5882 else if (strcasecmp (name
, "n") == 0)
5894 /* Reset pointers if this was really a ,n for a branch instruction. */
5902 /* Handle an alignment directive. Special so that we can update the
5903 alignment of the subspace if necessary. */
5908 /* We must have a valid space and subspace. */
5909 pa_check_current_space_and_subspace ();
5911 /* Let the generic gas code do most of the work. */
5912 s_align_bytes (bytes
);
5914 /* If bytes is a power of 2, then update the current subspace's
5915 alignment if necessary. */
5916 if (log2 (bytes
) != -1)
5917 record_alignment (current_subspace
->ssd_seg
, log2 (bytes
));
5921 /* Handle a .BLOCK type pseudo-op. */
5925 int z ATTRIBUTE_UNUSED
;
5929 unsigned int temp_size
;
5933 /* We must have a valid space and subspace. */
5934 pa_check_current_space_and_subspace ();
5937 temp_size
= get_absolute_expression ();
5939 /* Always fill with zeros, that's what the HP assembler does. */
5942 p
= frag_var (rs_fill
, (int) temp_size
, (int) temp_size
,
5943 (relax_substateT
) 0, (symbolS
*) 0, (offsetT
) 1, NULL
);
5944 memset (p
, 0, temp_size
);
5946 /* Convert 2 bytes at a time. */
5948 for (i
= 0; i
< temp_size
; i
+= 2)
5950 md_number_to_chars (p
+ i
,
5952 (int) ((temp_size
- i
) > 2 ? 2 : (temp_size
- i
)));
5955 pa_undefine_label ();
5956 demand_empty_rest_of_line ();
5959 /* Handle a .begin_brtab and .end_brtab pseudo-op. */
5963 int begin ATTRIBUTE_UNUSED
;
5967 /* The BRTAB relocations are only availble in SOM (to denote
5968 the beginning and end of branch tables). */
5969 char *where
= frag_more (0);
5971 fix_new_hppa (frag_now
, where
- frag_now
->fr_literal
, 0,
5972 NULL
, (offsetT
) 0, NULL
,
5973 0, begin
? R_HPPA_BEGIN_BRTAB
: R_HPPA_END_BRTAB
,
5977 demand_empty_rest_of_line ();
5980 /* Handle a .begin_try and .end_try pseudo-op. */
5984 int begin ATTRIBUTE_UNUSED
;
5988 char *where
= frag_more (0);
5993 /* The TRY relocations are only availble in SOM (to denote
5994 the beginning and end of exception handling regions). */
5996 fix_new_hppa (frag_now
, where
- frag_now
->fr_literal
, 0,
5997 NULL
, (offsetT
) 0, begin
? NULL
: &exp
,
5998 0, begin
? R_HPPA_BEGIN_TRY
: R_HPPA_END_TRY
,
6002 demand_empty_rest_of_line ();
6005 /* Handle a .CALL pseudo-op. This involves storing away information
6006 about where arguments are to be found so the linker can detect
6007 (and correct) argument location mismatches between caller and callee. */
6011 int unused ATTRIBUTE_UNUSED
;
6014 /* We must have a valid space and subspace. */
6015 pa_check_current_space_and_subspace ();
6018 pa_call_args (&last_call_desc
);
6019 demand_empty_rest_of_line ();
6022 /* Do the dirty work of building a call descriptor which describes
6023 where the caller placed arguments to a function call. */
6026 pa_call_args (call_desc
)
6027 struct call_desc
*call_desc
;
6030 unsigned int temp
, arg_reloc
;
6032 while (!is_end_of_statement ())
6034 name
= input_line_pointer
;
6035 c
= get_symbol_end ();
6036 /* Process a source argument. */
6037 if ((strncasecmp (name
, "argw", 4) == 0))
6039 temp
= atoi (name
+ 4);
6040 p
= input_line_pointer
;
6042 input_line_pointer
++;
6043 name
= input_line_pointer
;
6044 c
= get_symbol_end ();
6045 arg_reloc
= pa_build_arg_reloc (name
);
6046 call_desc
->arg_reloc
|= pa_align_arg_reloc (temp
, arg_reloc
);
6048 /* Process a return value. */
6049 else if ((strncasecmp (name
, "rtnval", 6) == 0))
6051 p
= input_line_pointer
;
6053 input_line_pointer
++;
6054 name
= input_line_pointer
;
6055 c
= get_symbol_end ();
6056 arg_reloc
= pa_build_arg_reloc (name
);
6057 call_desc
->arg_reloc
|= (arg_reloc
& 0x3);
6061 as_bad (_("Invalid .CALL argument: %s"), name
);
6063 p
= input_line_pointer
;
6065 if (!is_end_of_statement ())
6066 input_line_pointer
++;
6070 /* Return TRUE if FRAG1 and FRAG2 are the same. */
6073 is_same_frag (frag1
, frag2
)
6080 else if (frag2
== NULL
)
6082 else if (frag1
== frag2
)
6084 else if (frag2
->fr_type
== rs_fill
&& frag2
->fr_fix
== 0)
6085 return (is_same_frag (frag1
, frag2
->fr_next
));
6091 /* Build an entry in the UNWIND subspace from the given function
6092 attributes in CALL_INFO. This is not needed for SOM as using
6093 R_ENTRY and R_EXIT relocations allow the linker to handle building
6094 of the unwind spaces. */
6097 pa_build_unwind_subspace (call_info
)
6098 struct call_info
*call_info
;
6100 asection
*seg
, *save_seg
;
6101 subsegT save_subseg
;
6102 unsigned int unwind
;
6106 if ((bfd_get_section_flags (stdoutput
, now_seg
)
6107 & (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
6108 != (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
6111 reloc
= R_PARISC_SEGREL32
;
6113 save_subseg
= now_subseg
;
6114 /* Get into the right seg/subseg. This may involve creating
6115 the seg the first time through. Make sure to have the
6116 old seg/subseg so that we can reset things when we are done. */
6117 seg
= bfd_get_section_by_name (stdoutput
, UNWIND_SECTION_NAME
);
6118 if (seg
== ASEC_NULL
)
6120 seg
= subseg_new (UNWIND_SECTION_NAME
, 0);
6121 bfd_set_section_flags (stdoutput
, seg
,
6122 SEC_READONLY
| SEC_HAS_CONTENTS
6123 | SEC_LOAD
| SEC_RELOC
| SEC_ALLOC
| SEC_DATA
);
6124 bfd_set_section_alignment (stdoutput
, seg
, 2);
6127 subseg_set (seg
, 0);
6129 /* Get some space to hold relocation information for the unwind
6133 /* Relocation info. for start offset of the function. */
6134 md_number_to_chars (p
, 0, 4);
6135 fix_new_hppa (frag_now
, p
- frag_now
->fr_literal
, 4,
6136 call_info
->start_symbol
, (offsetT
) 0,
6137 (expressionS
*) NULL
, 0, reloc
,
6140 /* Relocation info. for end offset of the function.
6142 Because we allow reductions of 32bit relocations for ELF, this will be
6143 reduced to section_sym + offset which avoids putting the temporary
6144 symbol into the symbol table. It (should) end up giving the same
6145 value as call_info->start_symbol + function size once the linker is
6146 finished with its work. */
6147 md_number_to_chars (p
+ 4, 0, 4);
6148 fix_new_hppa (frag_now
, p
+ 4 - frag_now
->fr_literal
, 4,
6149 call_info
->end_symbol
, (offsetT
) 0,
6150 (expressionS
*) NULL
, 0, reloc
,
6153 /* Dump the descriptor. */
6154 unwind
= UNWIND_LOW32 (&call_info
->ci_unwind
.descriptor
);
6155 md_number_to_chars (p
+ 8, unwind
, 4);
6157 unwind
= UNWIND_HIGH32 (&call_info
->ci_unwind
.descriptor
);
6158 md_number_to_chars (p
+ 12, unwind
, 4);
6160 /* Return back to the original segment/subsegment. */
6161 subseg_set (save_seg
, save_subseg
);
6165 /* Process a .CALLINFO pseudo-op. This information is used later
6166 to build unwind descriptors and maybe one day to support
6167 .ENTER and .LEAVE. */
6170 pa_callinfo (unused
)
6171 int unused ATTRIBUTE_UNUSED
;
6177 /* We must have a valid space and subspace. */
6178 pa_check_current_space_and_subspace ();
6181 /* .CALLINFO must appear within a procedure definition. */
6182 if (!within_procedure
)
6183 as_bad (_(".callinfo is not within a procedure definition"));
6185 /* Mark the fact that we found the .CALLINFO for the
6186 current procedure. */
6187 callinfo_found
= TRUE
;
6189 /* Iterate over the .CALLINFO arguments. */
6190 while (!is_end_of_statement ())
6192 name
= input_line_pointer
;
6193 c
= get_symbol_end ();
6194 /* Frame size specification. */
6195 if ((strncasecmp (name
, "frame", 5) == 0))
6197 p
= input_line_pointer
;
6199 input_line_pointer
++;
6200 temp
= get_absolute_expression ();
6201 if ((temp
& 0x3) != 0)
6203 as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp
);
6207 /* callinfo is in bytes and unwind_desc is in 8 byte units. */
6208 last_call_info
->ci_unwind
.descriptor
.frame_size
= temp
/ 8;
6211 /* Entry register (GR, GR and SR) specifications. */
6212 else if ((strncasecmp (name
, "entry_gr", 8) == 0))
6214 p
= input_line_pointer
;
6216 input_line_pointer
++;
6217 temp
= get_absolute_expression ();
6218 /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6219 even though %r19 is caller saved. I think this is a bug in
6220 the HP assembler, and we are not going to emulate it. */
6221 if (temp
< 3 || temp
> 18)
6222 as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6223 last_call_info
->ci_unwind
.descriptor
.entry_gr
= temp
- 2;
6225 else if ((strncasecmp (name
, "entry_fr", 8) == 0))
6227 p
= input_line_pointer
;
6229 input_line_pointer
++;
6230 temp
= get_absolute_expression ();
6231 /* Similarly the HP assembler takes 31 as the high bound even
6232 though %fr21 is the last callee saved floating point register. */
6233 if (temp
< 12 || temp
> 21)
6234 as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6235 last_call_info
->ci_unwind
.descriptor
.entry_fr
= temp
- 11;
6237 else if ((strncasecmp (name
, "entry_sr", 8) == 0))
6239 p
= input_line_pointer
;
6241 input_line_pointer
++;
6242 temp
= get_absolute_expression ();
6244 as_bad (_("Value for ENTRY_SR must be 3\n"));
6246 /* Note whether or not this function performs any calls. */
6247 else if ((strncasecmp (name
, "calls", 5) == 0) ||
6248 (strncasecmp (name
, "caller", 6) == 0))
6250 p
= input_line_pointer
;
6253 else if ((strncasecmp (name
, "no_calls", 8) == 0))
6255 p
= input_line_pointer
;
6258 /* Should RP be saved into the stack. */
6259 else if ((strncasecmp (name
, "save_rp", 7) == 0))
6261 p
= input_line_pointer
;
6263 last_call_info
->ci_unwind
.descriptor
.save_rp
= 1;
6265 /* Likewise for SP. */
6266 else if ((strncasecmp (name
, "save_sp", 7) == 0))
6268 p
= input_line_pointer
;
6270 last_call_info
->ci_unwind
.descriptor
.save_sp
= 1;
6272 /* Is this an unwindable procedure. If so mark it so
6273 in the unwind descriptor. */
6274 else if ((strncasecmp (name
, "no_unwind", 9) == 0))
6276 p
= input_line_pointer
;
6278 last_call_info
->ci_unwind
.descriptor
.cannot_unwind
= 1;
6280 /* Is this an interrupt routine. If so mark it in the
6281 unwind descriptor. */
6282 else if ((strncasecmp (name
, "hpux_int", 7) == 0))
6284 p
= input_line_pointer
;
6286 last_call_info
->ci_unwind
.descriptor
.hpux_interrupt_marker
= 1;
6288 /* Is this a millicode routine. "millicode" isn't in my
6289 assembler manual, but my copy is old. The HP assembler
6290 accepts it, and there's a place in the unwind descriptor
6291 to drop the information, so we'll accept it too. */
6292 else if ((strncasecmp (name
, "millicode", 9) == 0))
6294 p
= input_line_pointer
;
6296 last_call_info
->ci_unwind
.descriptor
.millicode
= 1;
6300 as_bad (_("Invalid .CALLINFO argument: %s"), name
);
6301 *input_line_pointer
= c
;
6303 if (!is_end_of_statement ())
6304 input_line_pointer
++;
6307 demand_empty_rest_of_line ();
6310 #if !(defined (OBJ_ELF) && defined (TE_LINUX))
6311 /* Switch to the text space. Like s_text, but delete our
6312 label when finished. */
6315 int unused ATTRIBUTE_UNUSED
;
6318 current_space
= is_defined_space ("$TEXT$");
6320 = pa_subsegment_to_subspace (current_space
->sd_seg
, 0);
6324 pa_undefine_label ();
6327 /* Switch to the data space. As usual delete our label. */
6330 int unused ATTRIBUTE_UNUSED
;
6333 current_space
= is_defined_space ("$PRIVATE$");
6335 = pa_subsegment_to_subspace (current_space
->sd_seg
, 0);
6338 pa_undefine_label ();
6341 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6342 the .comm pseudo-op has the following symtax:
6344 <label> .comm <length>
6346 where <label> is optional and is a symbol whose address will be the start of
6347 a block of memory <length> bytes long. <length> must be an absolute
6348 expression. <length> bytes will be allocated in the current space
6351 Also note the label may not even be on the same line as the .comm.
6353 This difference in syntax means the colon function will be called
6354 on the symbol before we arrive in pa_comm. colon will set a number
6355 of attributes of the symbol that need to be fixed here. In particular
6356 the value, section pointer, fragment pointer, flags, etc. What
6359 This also makes error detection all but impossible. */
6363 int unused ATTRIBUTE_UNUSED
;
6367 label_symbol_struct
*label_symbol
= pa_get_label ();
6370 symbol
= label_symbol
->lss_label
;
6375 size
= get_absolute_expression ();
6379 S_SET_VALUE (symbol
, size
);
6380 S_SET_SEGMENT (symbol
, bfd_und_section_ptr
);
6381 S_SET_EXTERNAL (symbol
);
6383 /* colon() has already set the frag to the current location in the
6384 current subspace; we need to reset the fragment to the zero address
6385 fragment. We also need to reset the segment pointer. */
6386 symbol_set_frag (symbol
, &zero_address_frag
);
6388 demand_empty_rest_of_line ();
6390 #endif /* !(defined (OBJ_ELF) && defined (TE_LINUX)) */
6392 /* Process a .END pseudo-op. */
6396 int unused ATTRIBUTE_UNUSED
;
6398 demand_empty_rest_of_line ();
6401 /* Process a .ENTER pseudo-op. This is not supported. */
6404 int unused ATTRIBUTE_UNUSED
;
6407 /* We must have a valid space and subspace. */
6408 pa_check_current_space_and_subspace ();
6411 as_bad (_("The .ENTER pseudo-op is not supported"));
6412 demand_empty_rest_of_line ();
6415 /* Process a .ENTRY pseudo-op. .ENTRY marks the beginning of the
6419 int unused ATTRIBUTE_UNUSED
;
6422 /* We must have a valid space and subspace. */
6423 pa_check_current_space_and_subspace ();
6426 if (!within_procedure
)
6427 as_bad (_("Misplaced .entry. Ignored."));
6430 if (!callinfo_found
)
6431 as_bad (_("Missing .callinfo."));
6433 demand_empty_rest_of_line ();
6434 within_entry_exit
= TRUE
;
6437 /* SOM defers building of unwind descriptors until the link phase.
6438 The assembler is responsible for creating an R_ENTRY relocation
6439 to mark the beginning of a region and hold the unwind bits, and
6440 for creating an R_EXIT relocation to mark the end of the region.
6442 FIXME. ELF should be using the same conventions! The problem
6443 is an unwind requires too much relocation space. Hmmm. Maybe
6444 if we split the unwind bits up between the relocations which
6445 denote the entry and exit points. */
6446 if (last_call_info
->start_symbol
!= NULL
)
6451 where
= frag_more (0);
6452 u
= UNWIND_LOW32 (&last_call_info
->ci_unwind
.descriptor
);
6453 fix_new_hppa (frag_now
, where
- frag_now
->fr_literal
, 0,
6454 NULL
, (offsetT
) 0, NULL
,
6455 0, R_HPPA_ENTRY
, e_fsel
, 0, 0, u
);
6460 /* Silly nonsense for pa_equ. The only half-sensible use for this is
6461 being able to subtract two register symbols that specify a range of
6462 registers, to get the size of the range. */
6463 static int fudge_reg_expressions
;
6466 hppa_force_reg_syms_absolute (resultP
, op
, rightP
)
6467 expressionS
*resultP
;
6468 operatorT op ATTRIBUTE_UNUSED
;
6469 expressionS
*rightP
;
6471 if (fudge_reg_expressions
6472 && rightP
->X_op
== O_register
6473 && resultP
->X_op
== O_register
)
6475 rightP
->X_op
= O_constant
;
6476 resultP
->X_op
= O_constant
;
6478 return 0; /* Continue normal expr handling. */
6481 /* Handle a .EQU pseudo-op. */
6487 label_symbol_struct
*label_symbol
= pa_get_label ();
6492 symbol
= label_symbol
->lss_label
;
6496 if (!pa_parse_number (&input_line_pointer
, 0))
6497 as_bad (_(".REG expression must be a register"));
6498 S_SET_VALUE (symbol
, pa_number
);
6499 S_SET_SEGMENT (symbol
, reg_section
);
6506 fudge_reg_expressions
= 1;
6507 seg
= expression (&exp
);
6508 fudge_reg_expressions
= 0;
6509 if (exp
.X_op
!= O_constant
6510 && exp
.X_op
!= O_register
)
6512 if (exp
.X_op
!= O_absent
)
6513 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6514 exp
.X_add_number
= 0;
6515 seg
= absolute_section
;
6517 S_SET_VALUE (symbol
, (unsigned int) exp
.X_add_number
);
6518 S_SET_SEGMENT (symbol
, seg
);
6524 as_bad (_(".REG must use a label"));
6526 as_bad (_(".EQU must use a label"));
6529 pa_undefine_label ();
6530 demand_empty_rest_of_line ();
6533 /* Helper function. Does processing for the end of a function. This
6534 usually involves creating some relocations or building special
6535 symbols to mark the end of the function. */
6542 where
= frag_more (0);
6545 /* Mark the end of the function, stuff away the location of the frag
6546 for the end of the function, and finally call pa_build_unwind_subspace
6547 to add an entry in the unwind table. */
6548 hppa_elf_mark_end_of_function ();
6549 pa_build_unwind_subspace (last_call_info
);
6551 /* SOM defers building of unwind descriptors until the link phase.
6552 The assembler is responsible for creating an R_ENTRY relocation
6553 to mark the beginning of a region and hold the unwind bits, and
6554 for creating an R_EXIT relocation to mark the end of the region.
6556 FIXME. ELF should be using the same conventions! The problem
6557 is an unwind requires too much relocation space. Hmmm. Maybe
6558 if we split the unwind bits up between the relocations which
6559 denote the entry and exit points. */
6560 fix_new_hppa (frag_now
, where
- frag_now
->fr_literal
, 0,
6562 NULL
, 0, R_HPPA_EXIT
, e_fsel
, 0, 0,
6563 UNWIND_HIGH32 (&last_call_info
->ci_unwind
.descriptor
));
6567 /* Process a .EXIT pseudo-op. */
6571 int unused ATTRIBUTE_UNUSED
;
6574 /* We must have a valid space and subspace. */
6575 pa_check_current_space_and_subspace ();
6578 if (!within_procedure
)
6579 as_bad (_(".EXIT must appear within a procedure"));
6582 if (!callinfo_found
)
6583 as_bad (_("Missing .callinfo"));
6586 if (!within_entry_exit
)
6587 as_bad (_("No .ENTRY for this .EXIT"));
6590 within_entry_exit
= FALSE
;
6595 demand_empty_rest_of_line ();
6598 /* Process a .EXPORT directive. This makes functions external
6599 and provides information such as argument relocation entries
6604 int unused ATTRIBUTE_UNUSED
;
6609 name
= input_line_pointer
;
6610 c
= get_symbol_end ();
6611 /* Make sure the given symbol exists. */
6612 if ((symbol
= symbol_find_or_make (name
)) == NULL
)
6614 as_bad (_("Cannot define export symbol: %s\n"), name
);
6615 p
= input_line_pointer
;
6617 input_line_pointer
++;
6621 /* OK. Set the external bits and process argument relocations.
6622 For the HP, weak and global are not mutually exclusive.
6623 S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6624 Call S_SET_EXTERNAL to get the other processing. Manually
6625 set BSF_GLOBAL when we get back. */
6626 S_SET_EXTERNAL (symbol
);
6627 symbol_get_bfdsym (symbol
)->flags
|= BSF_GLOBAL
;
6628 p
= input_line_pointer
;
6630 if (!is_end_of_statement ())
6632 input_line_pointer
++;
6633 pa_type_args (symbol
, 1);
6637 demand_empty_rest_of_line ();
6640 /* Helper function to process arguments to a .EXPORT pseudo-op. */
6643 pa_type_args (symbolP
, is_export
)
6648 unsigned int temp
, arg_reloc
;
6649 pa_symbol_type type
= SYMBOL_TYPE_UNKNOWN
;
6650 asymbol
*bfdsym
= symbol_get_bfdsym (symbolP
);
6652 if (strncasecmp (input_line_pointer
, "absolute", 8) == 0)
6655 input_line_pointer
+= 8;
6656 bfdsym
->flags
&= ~BSF_FUNCTION
;
6657 S_SET_SEGMENT (symbolP
, bfd_abs_section_ptr
);
6658 type
= SYMBOL_TYPE_ABSOLUTE
;
6660 else if (strncasecmp (input_line_pointer
, "code", 4) == 0)
6662 input_line_pointer
+= 4;
6663 /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6664 instead one should be IMPORTing/EXPORTing ENTRY types.
6666 Complain if one tries to EXPORT a CODE type since that's never
6667 done. Both GCC and HP C still try to IMPORT CODE types, so
6668 silently fix them to be ENTRY types. */
6669 if (S_IS_FUNCTION (symbolP
))
6672 as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6673 S_GET_NAME (symbolP
));
6675 bfdsym
->flags
|= BSF_FUNCTION
;
6676 type
= SYMBOL_TYPE_ENTRY
;
6680 bfdsym
->flags
&= ~BSF_FUNCTION
;
6681 type
= SYMBOL_TYPE_CODE
;
6684 else if (strncasecmp (input_line_pointer
, "data", 4) == 0)
6686 input_line_pointer
+= 4;
6687 bfdsym
->flags
&= ~BSF_FUNCTION
;
6688 bfdsym
->flags
|= BSF_OBJECT
;
6689 type
= SYMBOL_TYPE_DATA
;
6691 else if ((strncasecmp (input_line_pointer
, "entry", 5) == 0))
6693 input_line_pointer
+= 5;
6694 bfdsym
->flags
|= BSF_FUNCTION
;
6695 type
= SYMBOL_TYPE_ENTRY
;
6697 else if (strncasecmp (input_line_pointer
, "millicode", 9) == 0)
6699 input_line_pointer
+= 9;
6700 bfdsym
->flags
|= BSF_FUNCTION
;
6703 elf_symbol_type
*elfsym
= (elf_symbol_type
*) bfdsym
;
6704 elfsym
->internal_elf_sym
.st_info
=
6705 ELF_ST_INFO (ELF_ST_BIND (elfsym
->internal_elf_sym
.st_info
),
6709 type
= SYMBOL_TYPE_MILLICODE
;
6711 else if (strncasecmp (input_line_pointer
, "plabel", 6) == 0)
6713 input_line_pointer
+= 6;
6714 bfdsym
->flags
&= ~BSF_FUNCTION
;
6715 type
= SYMBOL_TYPE_PLABEL
;
6717 else if (strncasecmp (input_line_pointer
, "pri_prog", 8) == 0)
6719 input_line_pointer
+= 8;
6720 bfdsym
->flags
|= BSF_FUNCTION
;
6721 type
= SYMBOL_TYPE_PRI_PROG
;
6723 else if (strncasecmp (input_line_pointer
, "sec_prog", 8) == 0)
6725 input_line_pointer
+= 8;
6726 bfdsym
->flags
|= BSF_FUNCTION
;
6727 type
= SYMBOL_TYPE_SEC_PROG
;
6730 /* SOM requires much more information about symbol types
6731 than BFD understands. This is how we get this information
6732 to the SOM BFD backend. */
6733 #ifdef obj_set_symbol_type
6734 obj_set_symbol_type (bfdsym
, (int) type
);
6737 /* Now that the type of the exported symbol has been handled,
6738 handle any argument relocation information. */
6739 while (!is_end_of_statement ())
6741 if (*input_line_pointer
== ',')
6742 input_line_pointer
++;
6743 name
= input_line_pointer
;
6744 c
= get_symbol_end ();
6745 /* Argument sources. */
6746 if ((strncasecmp (name
, "argw", 4) == 0))
6748 p
= input_line_pointer
;
6750 input_line_pointer
++;
6751 temp
= atoi (name
+ 4);
6752 name
= input_line_pointer
;
6753 c
= get_symbol_end ();
6754 arg_reloc
= pa_align_arg_reloc (temp
, pa_build_arg_reloc (name
));
6755 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6756 symbol_arg_reloc_info (symbolP
) |= arg_reloc
;
6758 *input_line_pointer
= c
;
6760 /* The return value. */
6761 else if ((strncasecmp (name
, "rtnval", 6)) == 0)
6763 p
= input_line_pointer
;
6765 input_line_pointer
++;
6766 name
= input_line_pointer
;
6767 c
= get_symbol_end ();
6768 arg_reloc
= pa_build_arg_reloc (name
);
6769 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6770 symbol_arg_reloc_info (symbolP
) |= arg_reloc
;
6772 *input_line_pointer
= c
;
6774 /* Privelege level. */
6775 else if ((strncasecmp (name
, "priv_lev", 8)) == 0)
6777 p
= input_line_pointer
;
6779 input_line_pointer
++;
6780 temp
= atoi (input_line_pointer
);
6782 ((obj_symbol_type
*) bfdsym
)->tc_data
.ap
.hppa_priv_level
= temp
;
6784 c
= get_symbol_end ();
6785 *input_line_pointer
= c
;
6789 as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name
);
6790 p
= input_line_pointer
;
6793 if (!is_end_of_statement ())
6794 input_line_pointer
++;
6798 /* Handle an .IMPORT pseudo-op. Any symbol referenced in a given
6799 assembly file must either be defined in the assembly file, or
6800 explicitly IMPORTED from another. */
6804 int unused ATTRIBUTE_UNUSED
;
6809 name
= input_line_pointer
;
6810 c
= get_symbol_end ();
6812 symbol
= symbol_find (name
);
6813 /* Ugh. We might be importing a symbol defined earlier in the file,
6814 in which case all the code below will really screw things up
6815 (set the wrong segment, symbol flags & type, etc). */
6816 if (symbol
== NULL
|| !S_IS_DEFINED (symbol
))
6818 symbol
= symbol_find_or_make (name
);
6819 p
= input_line_pointer
;
6822 if (!is_end_of_statement ())
6824 input_line_pointer
++;
6825 pa_type_args (symbol
, 0);
6829 /* Sigh. To be compatable with the HP assembler and to help
6830 poorly written assembly code, we assign a type based on
6831 the current segment. Note only BSF_FUNCTION really
6832 matters, we do not need to set the full SYMBOL_TYPE_* info. */
6833 if (now_seg
== text_section
)
6834 symbol_get_bfdsym (symbol
)->flags
|= BSF_FUNCTION
;
6836 /* If the section is undefined, then the symbol is undefined
6837 Since this is an import, leave the section undefined. */
6838 S_SET_SEGMENT (symbol
, bfd_und_section_ptr
);
6843 /* The symbol was already defined. Just eat everything up to
6844 the end of the current statement. */
6845 while (!is_end_of_statement ())
6846 input_line_pointer
++;
6849 demand_empty_rest_of_line ();
6852 /* Handle a .LABEL pseudo-op. */
6856 int unused ATTRIBUTE_UNUSED
;
6860 name
= input_line_pointer
;
6861 c
= get_symbol_end ();
6863 if (strlen (name
) > 0)
6866 p
= input_line_pointer
;
6871 as_warn (_("Missing label name on .LABEL"));
6874 if (!is_end_of_statement ())
6876 as_warn (_("extra .LABEL arguments ignored."));
6877 ignore_rest_of_line ();
6879 demand_empty_rest_of_line ();
6882 /* Handle a .LEAVE pseudo-op. This is not supported yet. */
6886 int unused ATTRIBUTE_UNUSED
;
6889 /* We must have a valid space and subspace. */
6890 pa_check_current_space_and_subspace ();
6893 as_bad (_("The .LEAVE pseudo-op is not supported"));
6894 demand_empty_rest_of_line ();
6897 /* Handle a .LEVEL pseudo-op. */
6901 int unused ATTRIBUTE_UNUSED
;
6905 level
= input_line_pointer
;
6906 if (strncmp (level
, "1.0", 3) == 0)
6908 input_line_pointer
+= 3;
6909 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, 10))
6910 as_warn (_("could not set architecture and machine"));
6912 else if (strncmp (level
, "1.1", 3) == 0)
6914 input_line_pointer
+= 3;
6915 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, 11))
6916 as_warn (_("could not set architecture and machine"));
6918 else if (strncmp (level
, "2.0w", 4) == 0)
6920 input_line_pointer
+= 4;
6921 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, 25))
6922 as_warn (_("could not set architecture and machine"));
6924 else if (strncmp (level
, "2.0", 3) == 0)
6926 input_line_pointer
+= 3;
6927 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_hppa
, 20))
6928 as_warn (_("could not set architecture and machine"));
6932 as_bad (_("Unrecognized .LEVEL argument\n"));
6933 ignore_rest_of_line ();
6935 demand_empty_rest_of_line ();
6938 /* Handle a .ORIGIN pseudo-op. */
6942 int unused ATTRIBUTE_UNUSED
;
6945 /* We must have a valid space and subspace. */
6946 pa_check_current_space_and_subspace ();
6950 pa_undefine_label ();
6953 /* Handle a .PARAM pseudo-op. This is much like a .EXPORT, except it
6954 is for static functions. FIXME. Should share more code with .EXPORT. */
6958 int unused ATTRIBUTE_UNUSED
;
6963 name
= input_line_pointer
;
6964 c
= get_symbol_end ();
6966 if ((symbol
= symbol_find_or_make (name
)) == NULL
)
6968 as_bad (_("Cannot define static symbol: %s\n"), name
);
6969 p
= input_line_pointer
;
6971 input_line_pointer
++;
6975 S_CLEAR_EXTERNAL (symbol
);
6976 p
= input_line_pointer
;
6978 if (!is_end_of_statement ())
6980 input_line_pointer
++;
6981 pa_type_args (symbol
, 0);
6985 demand_empty_rest_of_line ();
6988 /* Handle a .PROC pseudo-op. It is used to mark the beginning
6989 of a procedure from a syntactical point of view. */
6993 int unused ATTRIBUTE_UNUSED
;
6995 struct call_info
*call_info
;
6998 /* We must have a valid space and subspace. */
6999 pa_check_current_space_and_subspace ();
7002 if (within_procedure
)
7003 as_fatal (_("Nested procedures"));
7005 /* Reset global variables for new procedure. */
7006 callinfo_found
= FALSE
;
7007 within_procedure
= TRUE
;
7009 /* Create another call_info structure. */
7010 call_info
= (struct call_info
*) xmalloc (sizeof (struct call_info
));
7013 as_fatal (_("Cannot allocate unwind descriptor\n"));
7015 memset (call_info
, 0, sizeof (struct call_info
));
7017 call_info
->ci_next
= NULL
;
7019 if (call_info_root
== NULL
)
7021 call_info_root
= call_info
;
7022 last_call_info
= call_info
;
7026 last_call_info
->ci_next
= call_info
;
7027 last_call_info
= call_info
;
7030 /* set up defaults on call_info structure */
7032 call_info
->ci_unwind
.descriptor
.cannot_unwind
= 0;
7033 call_info
->ci_unwind
.descriptor
.region_desc
= 1;
7034 call_info
->ci_unwind
.descriptor
.hpux_interrupt_marker
= 0;
7036 /* If we got a .PROC pseudo-op, we know that the function is defined
7037 locally. Make sure it gets into the symbol table. */
7039 label_symbol_struct
*label_symbol
= pa_get_label ();
7043 if (label_symbol
->lss_label
)
7045 last_call_info
->start_symbol
= label_symbol
->lss_label
;
7046 symbol_get_bfdsym (label_symbol
->lss_label
)->flags
|= BSF_FUNCTION
;
7049 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7052 last_call_info
->start_symbol
= NULL
;
7055 demand_empty_rest_of_line ();
7058 /* Process the syntatical end of a procedure. Make sure all the
7059 appropriate pseudo-ops were found within the procedure. */
7063 int unused ATTRIBUTE_UNUSED
;
7067 /* We must have a valid space and subspace. */
7068 pa_check_current_space_and_subspace ();
7071 /* If we are within a procedure definition, make sure we've
7072 defined a label for the procedure; handle case where the
7073 label was defined after the .PROC directive.
7075 Note there's not need to diddle with the segment or fragment
7076 for the label symbol in this case. We have already switched
7077 into the new $CODE$ subspace at this point. */
7078 if (within_procedure
&& last_call_info
->start_symbol
== NULL
)
7080 label_symbol_struct
*label_symbol
= pa_get_label ();
7084 if (label_symbol
->lss_label
)
7086 last_call_info
->start_symbol
= label_symbol
->lss_label
;
7087 symbol_get_bfdsym (label_symbol
->lss_label
)->flags
7090 /* Also handle allocation of a fixup to hold the unwind
7091 information when the label appears after the proc/procend. */
7092 if (within_entry_exit
)
7097 where
= frag_more (0);
7098 u
= UNWIND_LOW32 (&last_call_info
->ci_unwind
.descriptor
);
7099 fix_new_hppa (frag_now
, where
- frag_now
->fr_literal
, 0,
7100 NULL
, (offsetT
) 0, NULL
,
7101 0, R_HPPA_ENTRY
, e_fsel
, 0, 0, u
);
7106 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7109 as_bad (_("Missing function name for .PROC"));
7112 if (!within_procedure
)
7113 as_bad (_("misplaced .procend"));
7115 if (!callinfo_found
)
7116 as_bad (_("Missing .callinfo for this procedure"));
7118 if (within_entry_exit
)
7119 as_bad (_("Missing .EXIT for a .ENTRY"));
7122 /* ELF needs to mark the end of each function so that it can compute
7123 the size of the function (apparently its needed in the symbol table). */
7124 hppa_elf_mark_end_of_function ();
7127 within_procedure
= FALSE
;
7128 demand_empty_rest_of_line ();
7129 pa_undefine_label ();
7133 /* If VALUE is an exact power of two between zero and 2^31, then
7134 return log2 (VALUE). Else return -1. */
7142 while ((1 << shift
) != value
&& shift
< 32)
7151 /* Check to make sure we have a valid space and subspace. */
7154 pa_check_current_space_and_subspace ()
7156 if (current_space
== NULL
)
7157 as_fatal (_("Not in a space.\n"));
7159 if (current_subspace
== NULL
)
7160 as_fatal (_("Not in a subspace.\n"));
7163 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7164 then create a new space entry to hold the information specified
7165 by the parameters to the .SPACE directive. */
7167 static sd_chain_struct
*
7168 pa_parse_space_stmt (space_name
, create_flag
)
7172 char *name
, *ptemp
, c
;
7173 char loadable
, defined
, private, sort
;
7175 asection
*seg
= NULL
;
7176 sd_chain_struct
*space
;
7178 /* load default values */
7184 if (strcmp (space_name
, "$TEXT$") == 0)
7186 seg
= pa_def_spaces
[0].segment
;
7187 defined
= pa_def_spaces
[0].defined
;
7188 private = pa_def_spaces
[0].private;
7189 sort
= pa_def_spaces
[0].sort
;
7190 spnum
= pa_def_spaces
[0].spnum
;
7192 else if (strcmp (space_name
, "$PRIVATE$") == 0)
7194 seg
= pa_def_spaces
[1].segment
;
7195 defined
= pa_def_spaces
[1].defined
;
7196 private = pa_def_spaces
[1].private;
7197 sort
= pa_def_spaces
[1].sort
;
7198 spnum
= pa_def_spaces
[1].spnum
;
7201 if (!is_end_of_statement ())
7203 print_errors
= FALSE
;
7204 ptemp
= input_line_pointer
+ 1;
7205 /* First see if the space was specified as a number rather than
7206 as a name. According to the PA assembly manual the rest of
7207 the line should be ignored. */
7209 pa_parse_number (&ptemp
, 0);
7213 input_line_pointer
= ptemp
;
7217 while (!is_end_of_statement ())
7219 input_line_pointer
++;
7220 name
= input_line_pointer
;
7221 c
= get_symbol_end ();
7222 if ((strncasecmp (name
, "spnum", 5) == 0))
7224 *input_line_pointer
= c
;
7225 input_line_pointer
++;
7226 spnum
= get_absolute_expression ();
7228 else if ((strncasecmp (name
, "sort", 4) == 0))
7230 *input_line_pointer
= c
;
7231 input_line_pointer
++;
7232 sort
= get_absolute_expression ();
7234 else if ((strncasecmp (name
, "unloadable", 10) == 0))
7236 *input_line_pointer
= c
;
7239 else if ((strncasecmp (name
, "notdefined", 10) == 0))
7241 *input_line_pointer
= c
;
7244 else if ((strncasecmp (name
, "private", 7) == 0))
7246 *input_line_pointer
= c
;
7251 as_bad (_("Invalid .SPACE argument"));
7252 *input_line_pointer
= c
;
7253 if (!is_end_of_statement ())
7254 input_line_pointer
++;
7258 print_errors
= TRUE
;
7261 if (create_flag
&& seg
== NULL
)
7262 seg
= subseg_new (space_name
, 0);
7264 /* If create_flag is nonzero, then create the new space with
7265 the attributes computed above. Else set the values in
7266 an already existing space -- this can only happen for
7267 the first occurence of a built-in space. */
7269 space
= create_new_space (space_name
, spnum
, loadable
, defined
,
7270 private, sort
, seg
, 1);
7273 space
= is_defined_space (space_name
);
7274 SPACE_SPNUM (space
) = spnum
;
7275 SPACE_DEFINED (space
) = defined
& 1;
7276 SPACE_USER_DEFINED (space
) = 1;
7279 #ifdef obj_set_section_attributes
7280 obj_set_section_attributes (seg
, defined
, private, sort
, spnum
);
7286 /* Handle a .SPACE pseudo-op; this switches the current space to the
7287 given space, creating the new space if necessary. */
7291 int unused ATTRIBUTE_UNUSED
;
7293 char *name
, c
, *space_name
, *save_s
;
7294 sd_chain_struct
*sd_chain
;
7296 if (within_procedure
)
7298 as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7299 ignore_rest_of_line ();
7303 /* Check for some of the predefined spaces. FIXME: most of the code
7304 below is repeated several times, can we extract the common parts
7305 and place them into a subroutine or something similar? */
7306 /* FIXME Is this (and the next IF stmt) really right?
7307 What if INPUT_LINE_POINTER points to "$TEXT$FOO"? */
7308 if (strncmp (input_line_pointer
, "$TEXT$", 6) == 0)
7310 input_line_pointer
+= 6;
7311 sd_chain
= is_defined_space ("$TEXT$");
7312 if (sd_chain
== NULL
)
7313 sd_chain
= pa_parse_space_stmt ("$TEXT$", 1);
7314 else if (SPACE_USER_DEFINED (sd_chain
) == 0)
7315 sd_chain
= pa_parse_space_stmt ("$TEXT$", 0);
7317 current_space
= sd_chain
;
7318 subseg_set (text_section
, sd_chain
->sd_last_subseg
);
7320 = pa_subsegment_to_subspace (text_section
,
7321 sd_chain
->sd_last_subseg
);
7322 demand_empty_rest_of_line ();
7325 if (strncmp (input_line_pointer
, "$PRIVATE$", 9) == 0)
7327 input_line_pointer
+= 9;
7328 sd_chain
= is_defined_space ("$PRIVATE$");
7329 if (sd_chain
== NULL
)
7330 sd_chain
= pa_parse_space_stmt ("$PRIVATE$", 1);
7331 else if (SPACE_USER_DEFINED (sd_chain
) == 0)
7332 sd_chain
= pa_parse_space_stmt ("$PRIVATE$", 0);
7334 current_space
= sd_chain
;
7335 subseg_set (data_section
, sd_chain
->sd_last_subseg
);
7337 = pa_subsegment_to_subspace (data_section
,
7338 sd_chain
->sd_last_subseg
);
7339 demand_empty_rest_of_line ();
7342 if (!strncasecmp (input_line_pointer
,
7343 GDB_DEBUG_SPACE_NAME
,
7344 strlen (GDB_DEBUG_SPACE_NAME
)))
7346 input_line_pointer
+= strlen (GDB_DEBUG_SPACE_NAME
);
7347 sd_chain
= is_defined_space (GDB_DEBUG_SPACE_NAME
);
7348 if (sd_chain
== NULL
)
7349 sd_chain
= pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME
, 1);
7350 else if (SPACE_USER_DEFINED (sd_chain
) == 0)
7351 sd_chain
= pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME
, 0);
7353 current_space
= sd_chain
;
7356 asection
*gdb_section
7357 = bfd_make_section_old_way (stdoutput
, GDB_DEBUG_SPACE_NAME
);
7359 subseg_set (gdb_section
, sd_chain
->sd_last_subseg
);
7361 = pa_subsegment_to_subspace (gdb_section
,
7362 sd_chain
->sd_last_subseg
);
7364 demand_empty_rest_of_line ();
7368 /* It could be a space specified by number. */
7370 save_s
= input_line_pointer
;
7372 pa_parse_number (&input_line_pointer
, 0);
7375 if ((sd_chain
= pa_find_space_by_number (pa_number
)))
7377 current_space
= sd_chain
;
7379 subseg_set (sd_chain
->sd_seg
, sd_chain
->sd_last_subseg
);
7381 = pa_subsegment_to_subspace (sd_chain
->sd_seg
,
7382 sd_chain
->sd_last_subseg
);
7383 demand_empty_rest_of_line ();
7388 /* Not a number, attempt to create a new space. */
7390 input_line_pointer
= save_s
;
7391 name
= input_line_pointer
;
7392 c
= get_symbol_end ();
7393 space_name
= xmalloc (strlen (name
) + 1);
7394 strcpy (space_name
, name
);
7395 *input_line_pointer
= c
;
7397 sd_chain
= pa_parse_space_stmt (space_name
, 1);
7398 current_space
= sd_chain
;
7400 subseg_set (sd_chain
->sd_seg
, sd_chain
->sd_last_subseg
);
7401 current_subspace
= pa_subsegment_to_subspace (sd_chain
->sd_seg
,
7402 sd_chain
->sd_last_subseg
);
7403 demand_empty_rest_of_line ();
7407 /* Switch to a new space. (I think). FIXME. */
7411 int unused ATTRIBUTE_UNUSED
;
7416 sd_chain_struct
*space
;
7418 name
= input_line_pointer
;
7419 c
= get_symbol_end ();
7420 space
= is_defined_space (name
);
7424 md_number_to_chars (p
, SPACE_SPNUM (space
), 4);
7427 as_warn (_("Undefined space: '%s' Assuming space number = 0."), name
);
7429 *input_line_pointer
= c
;
7430 demand_empty_rest_of_line ();
7433 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7434 given subspace, creating the new subspace if necessary.
7436 FIXME. Should mirror pa_space more closely, in particular how
7437 they're broken up into subroutines. */
7440 pa_subspace (create_new
)
7443 char *name
, *ss_name
, c
;
7444 char loadable
, code_only
, common
, dup_common
, zero
, sort
;
7445 int i
, access
, space_index
, alignment
, quadrant
, applicable
, flags
;
7446 sd_chain_struct
*space
;
7447 ssd_chain_struct
*ssd
;
7450 if (current_space
== NULL
)
7451 as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7453 if (within_procedure
)
7455 as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7456 ignore_rest_of_line ();
7460 name
= input_line_pointer
;
7461 c
= get_symbol_end ();
7462 ss_name
= xmalloc (strlen (name
) + 1);
7463 strcpy (ss_name
, name
);
7464 *input_line_pointer
= c
;
7466 /* Load default values. */
7478 space
= current_space
;
7482 ssd
= is_defined_subspace (ss_name
);
7483 /* Allow user to override the builtin attributes of subspaces. But
7484 only allow the attributes to be changed once! */
7485 if (ssd
&& SUBSPACE_DEFINED (ssd
))
7487 subseg_set (ssd
->ssd_seg
, ssd
->ssd_subseg
);
7488 current_subspace
= ssd
;
7489 if (!is_end_of_statement ())
7490 as_warn (_("Parameters of an existing subspace can\'t be modified"));
7491 demand_empty_rest_of_line ();
7496 /* A new subspace. Load default values if it matches one of
7497 the builtin subspaces. */
7499 while (pa_def_subspaces
[i
].name
)
7501 if (strcasecmp (pa_def_subspaces
[i
].name
, ss_name
) == 0)
7503 loadable
= pa_def_subspaces
[i
].loadable
;
7504 common
= pa_def_subspaces
[i
].common
;
7505 dup_common
= pa_def_subspaces
[i
].dup_common
;
7506 code_only
= pa_def_subspaces
[i
].code_only
;
7507 zero
= pa_def_subspaces
[i
].zero
;
7508 space_index
= pa_def_subspaces
[i
].space_index
;
7509 alignment
= pa_def_subspaces
[i
].alignment
;
7510 quadrant
= pa_def_subspaces
[i
].quadrant
;
7511 access
= pa_def_subspaces
[i
].access
;
7512 sort
= pa_def_subspaces
[i
].sort
;
7519 /* We should be working with a new subspace now. Fill in
7520 any information as specified by the user. */
7521 if (!is_end_of_statement ())
7523 input_line_pointer
++;
7524 while (!is_end_of_statement ())
7526 name
= input_line_pointer
;
7527 c
= get_symbol_end ();
7528 if ((strncasecmp (name
, "quad", 4) == 0))
7530 *input_line_pointer
= c
;
7531 input_line_pointer
++;
7532 quadrant
= get_absolute_expression ();
7534 else if ((strncasecmp (name
, "align", 5) == 0))
7536 *input_line_pointer
= c
;
7537 input_line_pointer
++;
7538 alignment
= get_absolute_expression ();
7539 if (log2 (alignment
) == -1)
7541 as_bad (_("Alignment must be a power of 2"));
7545 else if ((strncasecmp (name
, "access", 6) == 0))
7547 *input_line_pointer
= c
;
7548 input_line_pointer
++;
7549 access
= get_absolute_expression ();
7551 else if ((strncasecmp (name
, "sort", 4) == 0))
7553 *input_line_pointer
= c
;
7554 input_line_pointer
++;
7555 sort
= get_absolute_expression ();
7557 else if ((strncasecmp (name
, "code_only", 9) == 0))
7559 *input_line_pointer
= c
;
7562 else if ((strncasecmp (name
, "unloadable", 10) == 0))
7564 *input_line_pointer
= c
;
7567 else if ((strncasecmp (name
, "common", 6) == 0))
7569 *input_line_pointer
= c
;
7572 else if ((strncasecmp (name
, "dup_comm", 8) == 0))
7574 *input_line_pointer
= c
;
7577 else if ((strncasecmp (name
, "zero", 4) == 0))
7579 *input_line_pointer
= c
;
7582 else if ((strncasecmp (name
, "first", 5) == 0))
7583 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7585 as_bad (_("Invalid .SUBSPACE argument"));
7586 if (!is_end_of_statement ())
7587 input_line_pointer
++;
7591 /* Compute a reasonable set of BFD flags based on the information
7592 in the .subspace directive. */
7593 applicable
= bfd_applicable_section_flags (stdoutput
);
7596 flags
|= (SEC_ALLOC
| SEC_LOAD
);
7599 if (common
|| dup_common
)
7600 flags
|= SEC_IS_COMMON
;
7602 flags
|= SEC_RELOC
| SEC_HAS_CONTENTS
;
7604 /* This is a zero-filled subspace (eg BSS). */
7606 flags
&= ~(SEC_LOAD
| SEC_HAS_CONTENTS
);
7608 applicable
&= flags
;
7610 /* If this is an existing subspace, then we want to use the
7611 segment already associated with the subspace.
7613 FIXME NOW! ELF BFD doesn't appear to be ready to deal with
7614 lots of sections. It might be a problem in the PA ELF
7615 code, I do not know yet. For now avoid creating anything
7616 but the "standard" sections for ELF. */
7618 section
= subseg_force_new (ss_name
, 0);
7620 section
= ssd
->ssd_seg
;
7622 section
= subseg_new (ss_name
, 0);
7625 seg_info (section
)->bss
= 1;
7627 /* Now set the flags. */
7628 bfd_set_section_flags (stdoutput
, section
, applicable
);
7630 /* Record any alignment request for this section. */
7631 record_alignment (section
, log2 (alignment
));
7633 /* Set the starting offset for this section. */
7634 bfd_set_section_vma (stdoutput
, section
,
7635 pa_subspace_start (space
, quadrant
));
7637 /* Now that all the flags are set, update an existing subspace,
7638 or create a new one. */
7641 current_subspace
= update_subspace (space
, ss_name
, loadable
,
7642 code_only
, common
, dup_common
,
7643 sort
, zero
, access
, space_index
,
7644 alignment
, quadrant
,
7647 current_subspace
= create_new_subspace (space
, ss_name
, loadable
,
7649 dup_common
, zero
, sort
,
7650 access
, space_index
,
7651 alignment
, quadrant
, section
);
7653 demand_empty_rest_of_line ();
7654 current_subspace
->ssd_seg
= section
;
7655 subseg_set (current_subspace
->ssd_seg
, current_subspace
->ssd_subseg
);
7657 SUBSPACE_DEFINED (current_subspace
) = 1;
7660 /* Create default space and subspace dictionaries. */
7667 space_dict_root
= NULL
;
7668 space_dict_last
= NULL
;
7671 while (pa_def_spaces
[i
].name
)
7675 /* Pick the right name to use for the new section. */
7676 name
= pa_def_spaces
[i
].name
;
7678 pa_def_spaces
[i
].segment
= subseg_new (name
, 0);
7679 create_new_space (pa_def_spaces
[i
].name
, pa_def_spaces
[i
].spnum
,
7680 pa_def_spaces
[i
].loadable
, pa_def_spaces
[i
].defined
,
7681 pa_def_spaces
[i
].private, pa_def_spaces
[i
].sort
,
7682 pa_def_spaces
[i
].segment
, 0);
7687 while (pa_def_subspaces
[i
].name
)
7690 int applicable
, subsegment
;
7691 asection
*segment
= NULL
;
7692 sd_chain_struct
*space
;
7694 /* Pick the right name for the new section and pick the right
7695 subsegment number. */
7696 name
= pa_def_subspaces
[i
].name
;
7699 /* Create the new section. */
7700 segment
= subseg_new (name
, subsegment
);
7702 /* For SOM we want to replace the standard .text, .data, and .bss
7703 sections with our own. We also want to set BFD flags for
7704 all the built-in subspaces. */
7705 if (!strcmp (pa_def_subspaces
[i
].name
, "$CODE$"))
7707 text_section
= segment
;
7708 applicable
= bfd_applicable_section_flags (stdoutput
);
7709 bfd_set_section_flags (stdoutput
, segment
,
7710 applicable
& (SEC_ALLOC
| SEC_LOAD
7711 | SEC_RELOC
| SEC_CODE
7713 | SEC_HAS_CONTENTS
));
7715 else if (!strcmp (pa_def_subspaces
[i
].name
, "$DATA$"))
7717 data_section
= segment
;
7718 applicable
= bfd_applicable_section_flags (stdoutput
);
7719 bfd_set_section_flags (stdoutput
, segment
,
7720 applicable
& (SEC_ALLOC
| SEC_LOAD
7722 | SEC_HAS_CONTENTS
));
7725 else if (!strcmp (pa_def_subspaces
[i
].name
, "$BSS$"))
7727 bss_section
= segment
;
7728 applicable
= bfd_applicable_section_flags (stdoutput
);
7729 bfd_set_section_flags (stdoutput
, segment
,
7730 applicable
& SEC_ALLOC
);
7732 else if (!strcmp (pa_def_subspaces
[i
].name
, "$LIT$"))
7734 applicable
= bfd_applicable_section_flags (stdoutput
);
7735 bfd_set_section_flags (stdoutput
, segment
,
7736 applicable
& (SEC_ALLOC
| SEC_LOAD
7739 | SEC_HAS_CONTENTS
));
7741 else if (!strcmp (pa_def_subspaces
[i
].name
, "$MILLICODE$"))
7743 applicable
= bfd_applicable_section_flags (stdoutput
);
7744 bfd_set_section_flags (stdoutput
, segment
,
7745 applicable
& (SEC_ALLOC
| SEC_LOAD
7748 | SEC_HAS_CONTENTS
));
7750 else if (!strcmp (pa_def_subspaces
[i
].name
, "$UNWIND$"))
7752 applicable
= bfd_applicable_section_flags (stdoutput
);
7753 bfd_set_section_flags (stdoutput
, segment
,
7754 applicable
& (SEC_ALLOC
| SEC_LOAD
7757 | SEC_HAS_CONTENTS
));
7760 /* Find the space associated with this subspace. */
7761 space
= pa_segment_to_space (pa_def_spaces
[pa_def_subspaces
[i
].
7762 def_space_index
].segment
);
7765 as_fatal (_("Internal error: Unable to find containing space for %s."),
7766 pa_def_subspaces
[i
].name
);
7769 create_new_subspace (space
, name
,
7770 pa_def_subspaces
[i
].loadable
,
7771 pa_def_subspaces
[i
].code_only
,
7772 pa_def_subspaces
[i
].common
,
7773 pa_def_subspaces
[i
].dup_common
,
7774 pa_def_subspaces
[i
].zero
,
7775 pa_def_subspaces
[i
].sort
,
7776 pa_def_subspaces
[i
].access
,
7777 pa_def_subspaces
[i
].space_index
,
7778 pa_def_subspaces
[i
].alignment
,
7779 pa_def_subspaces
[i
].quadrant
,
7785 /* Create a new space NAME, with the appropriate flags as defined
7786 by the given parameters. */
7788 static sd_chain_struct
*
7789 create_new_space (name
, spnum
, loadable
, defined
, private,
7790 sort
, seg
, user_defined
)
7800 sd_chain_struct
*chain_entry
;
7802 chain_entry
= (sd_chain_struct
*) xmalloc (sizeof (sd_chain_struct
));
7804 as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7807 SPACE_NAME (chain_entry
) = (char *) xmalloc (strlen (name
) + 1);
7808 strcpy (SPACE_NAME (chain_entry
), name
);
7809 SPACE_DEFINED (chain_entry
) = defined
;
7810 SPACE_USER_DEFINED (chain_entry
) = user_defined
;
7811 SPACE_SPNUM (chain_entry
) = spnum
;
7813 chain_entry
->sd_seg
= seg
;
7814 chain_entry
->sd_last_subseg
= -1;
7815 chain_entry
->sd_subspaces
= NULL
;
7816 chain_entry
->sd_next
= NULL
;
7818 /* Find spot for the new space based on its sort key. */
7819 if (!space_dict_last
)
7820 space_dict_last
= chain_entry
;
7822 if (space_dict_root
== NULL
)
7823 space_dict_root
= chain_entry
;
7826 sd_chain_struct
*chain_pointer
;
7827 sd_chain_struct
*prev_chain_pointer
;
7829 chain_pointer
= space_dict_root
;
7830 prev_chain_pointer
= NULL
;
7832 while (chain_pointer
)
7834 prev_chain_pointer
= chain_pointer
;
7835 chain_pointer
= chain_pointer
->sd_next
;
7838 /* At this point we've found the correct place to add the new
7839 entry. So add it and update the linked lists as appropriate. */
7840 if (prev_chain_pointer
)
7842 chain_entry
->sd_next
= chain_pointer
;
7843 prev_chain_pointer
->sd_next
= chain_entry
;
7847 space_dict_root
= chain_entry
;
7848 chain_entry
->sd_next
= chain_pointer
;
7851 if (chain_entry
->sd_next
== NULL
)
7852 space_dict_last
= chain_entry
;
7855 /* This is here to catch predefined spaces which do not get
7856 modified by the user's input. Another call is found at
7857 the bottom of pa_parse_space_stmt to handle cases where
7858 the user modifies a predefined space. */
7859 #ifdef obj_set_section_attributes
7860 obj_set_section_attributes (seg
, defined
, private, sort
, spnum
);
7866 /* Create a new subspace NAME, with the appropriate flags as defined
7867 by the given parameters.
7869 Add the new subspace to the subspace dictionary chain in numerical
7870 order as defined by the SORT entries. */
7872 static ssd_chain_struct
*
7873 create_new_subspace (space
, name
, loadable
, code_only
, common
,
7874 dup_common
, is_zero
, sort
, access
, space_index
,
7875 alignment
, quadrant
, seg
)
7876 sd_chain_struct
*space
;
7878 int loadable
, code_only
, common
, dup_common
, is_zero
;
7886 ssd_chain_struct
*chain_entry
;
7888 chain_entry
= (ssd_chain_struct
*) xmalloc (sizeof (ssd_chain_struct
));
7890 as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name
);
7892 SUBSPACE_NAME (chain_entry
) = (char *) xmalloc (strlen (name
) + 1);
7893 strcpy (SUBSPACE_NAME (chain_entry
), name
);
7895 /* Initialize subspace_defined. When we hit a .subspace directive
7896 we'll set it to 1 which "locks-in" the subspace attributes. */
7897 SUBSPACE_DEFINED (chain_entry
) = 0;
7899 chain_entry
->ssd_subseg
= 0;
7900 chain_entry
->ssd_seg
= seg
;
7901 chain_entry
->ssd_next
= NULL
;
7903 /* Find spot for the new subspace based on its sort key. */
7904 if (space
->sd_subspaces
== NULL
)
7905 space
->sd_subspaces
= chain_entry
;
7908 ssd_chain_struct
*chain_pointer
;
7909 ssd_chain_struct
*prev_chain_pointer
;
7911 chain_pointer
= space
->sd_subspaces
;
7912 prev_chain_pointer
= NULL
;
7914 while (chain_pointer
)
7916 prev_chain_pointer
= chain_pointer
;
7917 chain_pointer
= chain_pointer
->ssd_next
;
7920 /* Now we have somewhere to put the new entry. Insert it and update
7922 if (prev_chain_pointer
)
7924 chain_entry
->ssd_next
= chain_pointer
;
7925 prev_chain_pointer
->ssd_next
= chain_entry
;
7929 space
->sd_subspaces
= chain_entry
;
7930 chain_entry
->ssd_next
= chain_pointer
;
7934 #ifdef obj_set_subsection_attributes
7935 obj_set_subsection_attributes (seg
, space
->sd_seg
, access
,
7942 /* Update the information for the given subspace based upon the
7943 various arguments. Return the modified subspace chain entry. */
7945 static ssd_chain_struct
*
7946 update_subspace (space
, name
, loadable
, code_only
, common
, dup_common
, sort
,
7947 zero
, access
, space_index
, alignment
, quadrant
, section
)
7948 sd_chain_struct
*space
;
7962 ssd_chain_struct
*chain_entry
;
7964 chain_entry
= is_defined_subspace (name
);
7966 #ifdef obj_set_subsection_attributes
7967 obj_set_subsection_attributes (section
, space
->sd_seg
, access
,
7974 /* Return the space chain entry for the space with the name NAME or
7975 NULL if no such space exists. */
7977 static sd_chain_struct
*
7978 is_defined_space (name
)
7981 sd_chain_struct
*chain_pointer
;
7983 for (chain_pointer
= space_dict_root
;
7985 chain_pointer
= chain_pointer
->sd_next
)
7987 if (strcmp (SPACE_NAME (chain_pointer
), name
) == 0)
7988 return chain_pointer
;
7991 /* No mapping from segment to space was found. Return NULL. */
7995 /* Find and return the space associated with the given seg. If no mapping
7996 from the given seg to a space is found, then return NULL.
7998 Unlike subspaces, the number of spaces is not expected to grow much,
7999 so a linear exhaustive search is OK here. */
8001 static sd_chain_struct
*
8002 pa_segment_to_space (seg
)
8005 sd_chain_struct
*space_chain
;
8007 /* Walk through each space looking for the correct mapping. */
8008 for (space_chain
= space_dict_root
;
8010 space_chain
= space_chain
->sd_next
)
8012 if (space_chain
->sd_seg
== seg
)
8016 /* Mapping was not found. Return NULL. */
8020 /* Return the space chain entry for the subspace with the name NAME or
8021 NULL if no such subspace exists.
8023 Uses a linear search through all the spaces and subspaces, this may
8024 not be appropriate if we ever being placing each function in its
8027 static ssd_chain_struct
*
8028 is_defined_subspace (name
)
8031 sd_chain_struct
*space_chain
;
8032 ssd_chain_struct
*subspace_chain
;
8034 /* Walk through each space. */
8035 for (space_chain
= space_dict_root
;
8037 space_chain
= space_chain
->sd_next
)
8039 /* Walk through each subspace looking for a name which matches. */
8040 for (subspace_chain
= space_chain
->sd_subspaces
;
8042 subspace_chain
= subspace_chain
->ssd_next
)
8043 if (strcmp (SUBSPACE_NAME (subspace_chain
), name
) == 0)
8044 return subspace_chain
;
8047 /* Subspace wasn't found. Return NULL. */
8051 /* Find and return the subspace associated with the given seg. If no
8052 mapping from the given seg to a subspace is found, then return NULL.
8054 If we ever put each procedure/function within its own subspace
8055 (to make life easier on the compiler and linker), then this will have
8056 to become more efficient. */
8058 static ssd_chain_struct
*
8059 pa_subsegment_to_subspace (seg
, subseg
)
8063 sd_chain_struct
*space_chain
;
8064 ssd_chain_struct
*subspace_chain
;
8066 /* Walk through each space. */
8067 for (space_chain
= space_dict_root
;
8069 space_chain
= space_chain
->sd_next
)
8071 if (space_chain
->sd_seg
== seg
)
8073 /* Walk through each subspace within each space looking for
8074 the correct mapping. */
8075 for (subspace_chain
= space_chain
->sd_subspaces
;
8077 subspace_chain
= subspace_chain
->ssd_next
)
8078 if (subspace_chain
->ssd_subseg
== (int) subseg
)
8079 return subspace_chain
;
8083 /* No mapping from subsegment to subspace found. Return NULL. */
8087 /* Given a number, try and find a space with the name number.
8089 Return a pointer to a space dictionary chain entry for the space
8090 that was found or NULL on failure. */
8092 static sd_chain_struct
*
8093 pa_find_space_by_number (number
)
8096 sd_chain_struct
*space_chain
;
8098 for (space_chain
= space_dict_root
;
8100 space_chain
= space_chain
->sd_next
)
8102 if (SPACE_SPNUM (space_chain
) == (unsigned int) number
)
8106 /* No appropriate space found. Return NULL. */
8110 /* Return the starting address for the given subspace. If the starting
8111 address is unknown then return zero. */
8114 pa_subspace_start (space
, quadrant
)
8115 sd_chain_struct
*space
;
8118 /* FIXME. Assumes everyone puts read/write data at 0x4000000, this
8119 is not correct for the PA OSF1 port. */
8120 if ((strcmp (SPACE_NAME (space
), "$PRIVATE$") == 0) && quadrant
== 1)
8122 else if (space
->sd_seg
== data_section
&& quadrant
== 1)
8129 /* FIXME. Needs documentation. */
8131 pa_next_subseg (space
)
8132 sd_chain_struct
*space
;
8135 space
->sd_last_subseg
++;
8136 return space
->sd_last_subseg
;
8140 /* Helper function for pa_stringer. Used to find the end of
8147 unsigned int c
= *s
& CHAR_MASK
;
8160 /* Handle a .STRING type pseudo-op. */
8163 pa_stringer (append_zero
)
8166 char *s
, num_buf
[4];
8170 /* Preprocess the string to handle PA-specific escape sequences.
8171 For example, \xDD where DD is a hexadecimal number should be
8172 changed to \OOO where OOO is an octal number. */
8175 /* We must have a valid space and subspace. */
8176 pa_check_current_space_and_subspace ();
8179 /* Skip the opening quote. */
8180 s
= input_line_pointer
+ 1;
8182 while (is_a_char (c
= pa_stringer_aux (s
++)))
8189 /* Handle \x<num>. */
8192 unsigned int number
;
8197 /* Get past the 'x'. */
8199 for (num_digit
= 0, number
= 0, dg
= *s
;
8201 && (ISDIGIT (dg
) || (dg
>= 'a' && dg
<= 'f')
8202 || (dg
>= 'A' && dg
<= 'F'));
8206 number
= number
* 16 + dg
- '0';
8207 else if (dg
>= 'a' && dg
<= 'f')
8208 number
= number
* 16 + dg
- 'a' + 10;
8210 number
= number
* 16 + dg
- 'A' + 10;
8220 sprintf (num_buf
, "%02o", number
);
8223 sprintf (num_buf
, "%03o", number
);
8226 for (i
= 0; i
<= num_digit
; i
++)
8227 s_start
[i
] = num_buf
[i
];
8231 /* This might be a "\"", skip over the escaped char. */
8238 stringer (append_zero
);
8239 pa_undefine_label ();
8242 /* Handle a .VERSION pseudo-op. */
8246 int unused ATTRIBUTE_UNUSED
;
8249 pa_undefine_label ();
8254 /* Handle a .COMPILER pseudo-op. */
8257 pa_compiler (unused
)
8258 int unused ATTRIBUTE_UNUSED
;
8260 obj_som_compiler (0);
8261 pa_undefine_label ();
8266 /* Handle a .COPYRIGHT pseudo-op. */
8269 pa_copyright (unused
)
8270 int unused ATTRIBUTE_UNUSED
;
8273 pa_undefine_label ();
8276 /* Just like a normal cons, but when finished we have to undefine
8277 the latest space label. */
8284 pa_undefine_label ();
8287 /* Like float_cons, but we need to undefine our label. */
8290 pa_float_cons (float_type
)
8293 float_cons (float_type
);
8294 pa_undefine_label ();
8297 /* Like s_fill, but delete our label when finished. */
8301 int unused ATTRIBUTE_UNUSED
;
8304 /* We must have a valid space and subspace. */
8305 pa_check_current_space_and_subspace ();
8309 pa_undefine_label ();
8312 /* Like lcomm, but delete our label when finished. */
8315 pa_lcomm (needs_align
)
8319 /* We must have a valid space and subspace. */
8320 pa_check_current_space_and_subspace ();
8323 s_lcomm (needs_align
);
8324 pa_undefine_label ();
8327 /* Like lsym, but delete our label when finished. */
8331 int unused ATTRIBUTE_UNUSED
;
8334 /* We must have a valid space and subspace. */
8335 pa_check_current_space_and_subspace ();
8339 pa_undefine_label ();
8342 /* On the PA relocations which involve function symbols must not be
8343 adjusted. This so that the linker can know when/how to create argument
8344 relocation stubs for indirect calls and calls to static functions.
8346 "T" field selectors create DLT relative fixups for accessing
8347 globals and statics in PIC code; each DLT relative fixup creates
8348 an entry in the DLT table. The entries contain the address of
8349 the final target (eg accessing "foo" would create a DLT entry
8350 with the address of "foo").
8352 Unfortunately, the HP linker doesn't take into account any addend
8353 when generating the DLT; so accessing $LIT$+8 puts the address of
8354 $LIT$ into the DLT rather than the address of $LIT$+8.
8356 The end result is we can't perform relocation symbol reductions for
8357 any fixup which creates entries in the DLT (eg they use "T" field
8360 Reject reductions involving symbols with external scope; such
8361 reductions make life a living hell for object file editors.
8363 FIXME. Also reject R_HPPA relocations which are 32bits wide in
8364 the code space. The SOM BFD backend doesn't know how to pull the
8365 right bits out of an instruction. */
8368 hppa_fix_adjustable (fixp
)
8372 struct hppa_fix_struct
*hppa_fix
;
8374 hppa_fix
= (struct hppa_fix_struct
*) fixp
->tc_fix_data
;
8377 /* Reject reductions of symbols in 32bit relocs. */
8378 if (fixp
->fx_r_type
== R_HPPA
&& hppa_fix
->fx_r_format
== 32)
8383 /* LR/RR selectors are implicitly used for a number of different relocation
8384 types. We must ensure that none of these types are adjusted (see below)
8385 even if they occur with a different selector. */
8386 code
= elf_hppa_reloc_final_type (stdoutput
, fixp
->fx_r_type
,
8387 hppa_fix
->fx_r_format
,
8388 hppa_fix
->fx_r_field
);
8392 /* Relocation types which use e_lrsel. */
8393 case R_PARISC_DIR21L
:
8394 case R_PARISC_DLTREL21L
:
8395 case R_PARISC_DPREL21L
:
8396 case R_PARISC_PLTOFF21L
:
8398 /* Relocation types which use e_rrsel. */
8399 case R_PARISC_DIR14R
:
8400 case R_PARISC_DIR14DR
:
8401 case R_PARISC_DIR14WR
:
8402 case R_PARISC_DIR17R
:
8403 case R_PARISC_DLTREL14R
:
8404 case R_PARISC_DLTREL14DR
:
8405 case R_PARISC_DLTREL14WR
:
8406 case R_PARISC_DPREL14R
:
8407 case R_PARISC_DPREL14DR
:
8408 case R_PARISC_DPREL14WR
:
8409 case R_PARISC_PLTOFF14R
:
8410 case R_PARISC_PLTOFF14DR
:
8411 case R_PARISC_PLTOFF14WR
:
8413 /* Other types that we reject for reduction. */
8414 case R_PARISC_GNU_VTENTRY
:
8415 case R_PARISC_GNU_VTINHERIT
:
8422 /* Reject reductions of symbols in sym1-sym2 expressions when
8423 the fixup will occur in a CODE subspace.
8425 XXX FIXME: Long term we probably want to reject all of these;
8426 for example reducing in the debug section would lose if we ever
8427 supported using the optimizing hp linker. */
8430 && (hppa_fix
->segment
->flags
& SEC_CODE
))
8433 /* We can't adjust any relocs that use LR% and RR% field selectors.
8435 If a symbol is reduced to a section symbol, the assembler will
8436 adjust the addend unless the symbol happens to reside right at
8437 the start of the section. Additionally, the linker has no choice
8438 but to manipulate the addends when coalescing input sections for
8439 "ld -r". Since an LR% field selector is defined to round the
8440 addend, we can't change the addend without risking that a LR% and
8441 it's corresponding (possible multiple) RR% field will no longer
8442 sum to the right value.
8445 . ldil LR%foo+0,%r21
8446 . ldw RR%foo+0(%r21),%r26
8447 . ldw RR%foo+4(%r21),%r25
8449 If foo is at address 4092 (decimal) in section `sect', then after
8450 reducing to the section symbol we get
8451 . LR%sect+4092 == (L%sect)+0
8452 . RR%sect+4092 == (R%sect)+4092
8453 . RR%sect+4096 == (R%sect)-4096
8454 and the last address loses because rounding the addend to 8k
8455 mutiples takes us up to 8192 with an offset of -4096.
8457 In cases where the LR% expression is identical to the RR% one we
8458 will never have a problem, but is so happens that gcc rounds
8459 addends involved in LR% field selectors to work around a HP
8460 linker bug. ie. We often have addresses like the last case
8461 above where the LR% expression is offset from the RR% one. */
8463 if (hppa_fix
->fx_r_field
== e_lrsel
8464 || hppa_fix
->fx_r_field
== e_rrsel
8465 || hppa_fix
->fx_r_field
== e_nlrsel
)
8468 /* Reject reductions of symbols in DLT relative relocs,
8469 relocations with plabels. */
8470 if (hppa_fix
->fx_r_field
== e_tsel
8471 || hppa_fix
->fx_r_field
== e_ltsel
8472 || hppa_fix
->fx_r_field
== e_rtsel
8473 || hppa_fix
->fx_r_field
== e_psel
8474 || hppa_fix
->fx_r_field
== e_rpsel
8475 || hppa_fix
->fx_r_field
== e_lpsel
)
8478 /* Reject absolute calls (jumps). */
8479 if (hppa_fix
->fx_r_type
== R_HPPA_ABS_CALL
)
8482 /* Reject reductions of function symbols. */
8483 if (fixp
->fx_addsy
!= 0 && S_IS_FUNCTION (fixp
->fx_addsy
))
8489 /* Return nonzero if the fixup in FIXP will require a relocation,
8490 even it if appears that the fixup could be completely handled
8494 hppa_force_relocation (fixp
)
8497 struct hppa_fix_struct
*hppa_fixp
;
8499 hppa_fixp
= (struct hppa_fix_struct
*) fixp
->tc_fix_data
;
8501 if (fixp
->fx_r_type
== (int) R_HPPA_ENTRY
8502 || fixp
->fx_r_type
== (int) R_HPPA_EXIT
8503 || fixp
->fx_r_type
== (int) R_HPPA_BEGIN_BRTAB
8504 || fixp
->fx_r_type
== (int) R_HPPA_END_BRTAB
8505 || fixp
->fx_r_type
== (int) R_HPPA_BEGIN_TRY
8506 || fixp
->fx_r_type
== (int) R_HPPA_END_TRY
8507 || (fixp
->fx_addsy
!= NULL
&& fixp
->fx_subsy
!= NULL
8508 && (hppa_fixp
->segment
->flags
& SEC_CODE
) != 0))
8512 if (fixp
->fx_r_type
== (int) R_PARISC_GNU_VTINHERIT
8513 || fixp
->fx_r_type
== (int) R_PARISC_GNU_VTENTRY
)
8517 assert (fixp
->fx_addsy
!= NULL
);
8519 /* Ensure we emit a relocation for global symbols so that dynamic
8521 if (S_FORCE_RELOC (fixp
->fx_addsy
))
8524 /* It is necessary to force PC-relative calls/jumps to have a relocation
8525 entry if they're going to need either an argument relocation or long
8528 && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp
->fx_addsy
),
8529 hppa_fixp
->fx_arg_reloc
))
8532 /* Now check to see if we're going to need a long-branch stub. */
8533 if (fixp
->fx_r_type
== (int) R_HPPA_PCREL_CALL
)
8535 long pc
= md_pcrel_from (fixp
);
8536 valueT distance
, min_stub_distance
;
8538 distance
= fixp
->fx_offset
+ S_GET_VALUE (fixp
->fx_addsy
) - pc
- 8;
8540 /* Distance to the closest possible stub. This will detect most
8541 but not all circumstances where a stub will not work. */
8542 min_stub_distance
= pc
+ 16;
8544 if (last_call_info
!= NULL
)
8545 min_stub_distance
-= S_GET_VALUE (last_call_info
->start_symbol
);
8548 if ((distance
+ 8388608 >= 16777216
8549 && min_stub_distance
<= 8388608)
8550 || (hppa_fixp
->fx_r_format
== 17
8551 && distance
+ 262144 >= 524288
8552 && min_stub_distance
<= 262144)
8553 || (hppa_fixp
->fx_r_format
== 12
8554 && distance
+ 8192 >= 16384
8555 && min_stub_distance
<= 8192)
8560 if (fixp
->fx_r_type
== (int) R_HPPA_ABS_CALL
)
8563 /* No need (yet) to force another relocations to be emitted. */
8567 /* Now for some ELF specific code. FIXME. */
8569 /* Mark the end of a function so that it's possible to compute
8570 the size of the function in elf_hppa_final_processing. */
8573 hppa_elf_mark_end_of_function ()
8575 /* ELF does not have EXIT relocations. All we do is create a
8576 temporary symbol marking the end of the function. */
8579 if (last_call_info
== NULL
|| last_call_info
->start_symbol
== NULL
)
8581 /* We have already warned about a missing label,
8582 or other problems. */
8586 name
= (char *) xmalloc (strlen ("L$\001end_")
8587 + strlen (S_GET_NAME (last_call_info
->start_symbol
))
8593 strcpy (name
, "L$\001end_");
8594 strcat (name
, S_GET_NAME (last_call_info
->start_symbol
));
8596 /* If we have a .exit followed by a .procend, then the
8597 symbol will have already been defined. */
8598 symbolP
= symbol_find (name
);
8601 /* The symbol has already been defined! This can
8602 happen if we have a .exit followed by a .procend.
8604 This is *not* an error. All we want to do is free
8605 the memory we just allocated for the name and continue. */
8610 /* symbol value should be the offset of the
8611 last instruction of the function */
8612 symbolP
= symbol_new (name
, now_seg
, (valueT
) (frag_now_fix () - 4),
8616 S_CLEAR_EXTERNAL (symbolP
);
8617 symbol_table_insert (symbolP
);
8621 last_call_info
->end_symbol
= symbolP
;
8623 as_bad (_("Symbol '%s' could not be created."), name
);
8627 as_bad (_("No memory for symbol name."));
8631 /* For ELF, this function serves one purpose: to setup the st_size
8632 field of STT_FUNC symbols. To do this, we need to scan the
8633 call_info structure list, determining st_size in by taking the
8634 difference in the address of the beginning/end marker symbols. */
8637 elf_hppa_final_processing ()
8639 struct call_info
*call_info_pointer
;
8641 for (call_info_pointer
= call_info_root
;
8643 call_info_pointer
= call_info_pointer
->ci_next
)
8645 elf_symbol_type
*esym
8646 = ((elf_symbol_type
*)
8647 symbol_get_bfdsym (call_info_pointer
->start_symbol
));
8648 esym
->internal_elf_sym
.st_size
=
8649 S_GET_VALUE (call_info_pointer
->end_symbol
)
8650 - S_GET_VALUE (call_info_pointer
->start_symbol
) + 4;
8655 pa_vtable_entry (ignore
)
8656 int ignore ATTRIBUTE_UNUSED
;
8658 struct fix
*new_fix
;
8660 new_fix
= obj_elf_vtable_entry (0);
8664 struct hppa_fix_struct
*hppa_fix
= (struct hppa_fix_struct
*)
8665 obstack_alloc (¬es
, sizeof (struct hppa_fix_struct
));
8666 hppa_fix
->fx_r_type
= R_HPPA
;
8667 hppa_fix
->fx_r_field
= e_fsel
;
8668 hppa_fix
->fx_r_format
= 32;
8669 hppa_fix
->fx_arg_reloc
= 0;
8670 hppa_fix
->segment
= now_seg
;
8671 new_fix
->tc_fix_data
= (void *) hppa_fix
;
8672 new_fix
->fx_r_type
= (int) R_PARISC_GNU_VTENTRY
;
8677 pa_vtable_inherit (ignore
)
8678 int ignore ATTRIBUTE_UNUSED
;
8680 struct fix
*new_fix
;
8682 new_fix
= obj_elf_vtable_inherit (0);
8686 struct hppa_fix_struct
*hppa_fix
= (struct hppa_fix_struct
*)
8687 obstack_alloc (¬es
, sizeof (struct hppa_fix_struct
));
8688 hppa_fix
->fx_r_type
= R_HPPA
;
8689 hppa_fix
->fx_r_field
= e_fsel
;
8690 hppa_fix
->fx_r_format
= 32;
8691 hppa_fix
->fx_arg_reloc
= 0;
8692 hppa_fix
->segment
= now_seg
;
8693 new_fix
->tc_fix_data
= (void *) hppa_fix
;
8694 new_fix
->fx_r_type
= (int) R_PARISC_GNU_VTINHERIT
;