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