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