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