projects / deliverable / binutils-gdb.git / blob
? search:


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