projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* tc-hppa.c (pa_ip): Reject match for '#' immediate if not pa20.
[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 if (bfd_get_mach (stdoutput) != pa20)
3070 break;
3071 the_insn.field_selector = pa_chk_field_selector (&s);
3072 get_expression (s);
3073 s = expr_end;
3074 if (the_insn.exp.X_op == O_constant)
3075 {
3076 num = evaluate_absolute (&the_insn);
3077 if (num & 0x7)
3078 break;
3079 CHECK_FIELD (num, 8191, -8192, 0);
3080 if (num < 0)
3081 opcode |= 1;
3082 num &= 0x1fff;
3083 num >>= 3;
3084 INSERT_FIELD_AND_CONTINUE (opcode, num, 4);
3085 }
3086 else
3087 {
3088 if (is_DP_relative (the_insn.exp))
3089 the_insn.reloc = R_HPPA_GOTOFF;
3090 else if (is_PC_relative (the_insn.exp))
3091 the_insn.reloc = R_HPPA_PCREL_CALL;
3092 else
3093 the_insn.reloc = R_HPPA;
3094 the_insn.format = 14;
3095 continue;
3096 }
3097 break;
3098
3099 /* Handle 14 bit immediate, shifted left twice. */
3100 case 'd':
3101 the_insn.field_selector = pa_chk_field_selector (&s);
3102 get_expression (s);
3103 s = expr_end;
3104 if (the_insn.exp.X_op == O_constant)
3105 {
3106 num = evaluate_absolute (&the_insn);
3107 if (num & 0x3)
3108 break;
3109 CHECK_FIELD (num, 8191, -8192, 0);
3110 if (num < 0)
3111 opcode |= 1;
3112 num &= 0x1fff;
3113 num >>= 2;
3114 INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
3115 }
3116 else
3117 {
3118 if (is_DP_relative (the_insn.exp))
3119 the_insn.reloc = R_HPPA_GOTOFF;
3120 else if (is_PC_relative (the_insn.exp))
3121 the_insn.reloc = R_HPPA_PCREL_CALL;
3122 else
3123 the_insn.reloc = R_HPPA;
3124 the_insn.format = 14;
3125 continue;
3126 }
3127
3128 /* Handle a 14 bit immediate at 31. */
3129 case 'j':
3130 the_insn.field_selector = pa_chk_field_selector (&s);
3131 get_expression (s);
3132 s = expr_end;
3133 if (the_insn.exp.X_op == O_constant)
3134 {
3135 num = evaluate_absolute (&the_insn);
3136 CHECK_FIELD (num, 8191, -8192, 0);
3137 num = low_sign_unext (num, 14);
3138 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3139 }
3140 else
3141 {
3142 if (is_DP_relative (the_insn.exp))
3143 the_insn.reloc = R_HPPA_GOTOFF;
3144 else if (is_PC_relative (the_insn.exp))
3145 the_insn.reloc = R_HPPA_PCREL_CALL;
3146 else
3147 the_insn.reloc = R_HPPA;
3148 the_insn.format = 14;
3149 continue;
3150 }
3151
3152 /* Handle a 21 bit immediate at 31. */
3153 case 'k':
3154 the_insn.field_selector = pa_chk_field_selector (&s);
3155 get_expression (s);
3156 s = expr_end;
3157 if (the_insn.exp.X_op == O_constant)
3158 {
3159 num = evaluate_absolute (&the_insn);
3160 CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
3161 opcode |= re_assemble_21 (num);
3162 continue;
3163 }
3164 else
3165 {
3166 if (is_DP_relative (the_insn.exp))
3167 the_insn.reloc = R_HPPA_GOTOFF;
3168 else if (is_PC_relative (the_insn.exp))
3169 the_insn.reloc = R_HPPA_PCREL_CALL;
3170 else
3171 the_insn.reloc = R_HPPA;
3172 the_insn.format = 21;
3173 continue;
3174 }
3175
3176 /* Handle a 16 bit immediate at 31 (PA 2.0 wide mode only). */
3177 case 'l':
3178 the_insn.field_selector = pa_chk_field_selector (&s);
3179 get_expression (s);
3180 s = expr_end;
3181 if (the_insn.exp.X_op == O_constant)
3182 {
3183 num = evaluate_absolute (&the_insn);
3184 CHECK_FIELD (num, 32767, -32768, 0);
3185 opcode |= re_assemble_16 (num);
3186 continue;
3187 }
3188 else
3189 {
3190 /* ??? Is this valid for wide mode? */
3191 if (is_DP_relative (the_insn.exp))
3192 the_insn.reloc = R_HPPA_GOTOFF;
3193 else if (is_PC_relative (the_insn.exp))
3194 the_insn.reloc = R_HPPA_PCREL_CALL;
3195 else
3196 the_insn.reloc = R_HPPA;
3197 the_insn.format = 14;
3198 continue;
3199 }
3200
3201 /* Handle a word-aligned 16-bit imm. at 31 (PA2.0 wide). */
3202 case 'y':
3203 the_insn.field_selector = pa_chk_field_selector (&s);
3204 get_expression (s);
3205 s = expr_end;
3206 if (the_insn.exp.X_op == O_constant)
3207 {
3208 num = evaluate_absolute (&the_insn);
3209 CHECK_FIELD (num, 32767, -32768, 0);
3210 CHECK_ALIGN (num, 4, 0);
3211 opcode |= re_assemble_16 (num);
3212 continue;
3213 }
3214 else
3215 {
3216 /* ??? Is this valid for wide mode? */
3217 if (is_DP_relative (the_insn.exp))
3218 the_insn.reloc = R_HPPA_GOTOFF;
3219 else if (is_PC_relative (the_insn.exp))
3220 the_insn.reloc = R_HPPA_PCREL_CALL;
3221 else
3222 the_insn.reloc = R_HPPA;
3223 the_insn.format = 14;
3224 continue;
3225 }
3226
3227 /* Handle a dword-aligned 16-bit imm. at 31 (PA2.0 wide). */
3228 case '&':
3229 the_insn.field_selector = pa_chk_field_selector (&s);
3230 get_expression (s);
3231 s = expr_end;
3232 if (the_insn.exp.X_op == O_constant)
3233 {
3234 num = evaluate_absolute (&the_insn);
3235 CHECK_FIELD (num, 32767, -32768, 0);
3236 CHECK_ALIGN (num, 8, 0);
3237 opcode |= re_assemble_16 (num);
3238 continue;
3239 }
3240 else
3241 {
3242 /* ??? Is this valid for wide mode? */
3243 if (is_DP_relative (the_insn.exp))
3244 the_insn.reloc = R_HPPA_GOTOFF;
3245 else if (is_PC_relative (the_insn.exp))
3246 the_insn.reloc = R_HPPA_PCREL_CALL;
3247 else
3248 the_insn.reloc = R_HPPA;
3249 the_insn.format = 14;
3250 continue;
3251 }
3252
3253 /* Handle a 12 bit branch displacement. */
3254 case 'w':
3255 the_insn.field_selector = pa_chk_field_selector (&s);
3256 get_expression (s);
3257 s = expr_end;
3258 the_insn.pcrel = 1;
3259 if (!the_insn.exp.X_add_symbol
3260 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
3261 FAKE_LABEL_NAME))
3262 {
3263 num = evaluate_absolute (&the_insn);
3264 if (num % 4)
3265 {
3266 as_bad (_("Branch to unaligned address"));
3267 break;
3268 }
3269 if (the_insn.exp.X_add_symbol)
3270 num -= 8;
3271 CHECK_FIELD (num, 8191, -8192, 0);
3272 opcode |= re_assemble_12 (num >> 2);
3273 continue;
3274 }
3275 else
3276 {
3277 the_insn.reloc = R_HPPA_PCREL_CALL;
3278 the_insn.format = 12;
3279 the_insn.arg_reloc = last_call_desc.arg_reloc;
3280 memset (&last_call_desc, 0, sizeof (struct call_desc));
3281 s = expr_end;
3282 continue;
3283 }
3284
3285 /* Handle a 17 bit branch displacement. */
3286 case 'W':
3287 the_insn.field_selector = pa_chk_field_selector (&s);
3288 get_expression (s);
3289 s = expr_end;
3290 the_insn.pcrel = 1;
3291 if (!the_insn.exp.X_add_symbol
3292 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
3293 FAKE_LABEL_NAME))
3294 {
3295 num = evaluate_absolute (&the_insn);
3296 if (num % 4)
3297 {
3298 as_bad (_("Branch to unaligned address"));
3299 break;
3300 }
3301 if (the_insn.exp.X_add_symbol)
3302 num -= 8;
3303 CHECK_FIELD (num, 262143, -262144, 0);
3304 opcode |= re_assemble_17 (num >> 2);
3305 continue;
3306 }
3307 else
3308 {
3309 the_insn.reloc = R_HPPA_PCREL_CALL;
3310 the_insn.format = 17;
3311 the_insn.arg_reloc = last_call_desc.arg_reloc;
3312 memset (&last_call_desc, 0, sizeof (struct call_desc));
3313 continue;
3314 }
3315
3316 /* Handle a 22 bit branch displacement. */
3317 case 'X':
3318 the_insn.field_selector = pa_chk_field_selector (&s);
3319 get_expression (s);
3320 s = expr_end;
3321 the_insn.pcrel = 1;
3322 if (!the_insn.exp.X_add_symbol
3323 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
3324 FAKE_LABEL_NAME))
3325 {
3326 num = evaluate_absolute (&the_insn);
3327 if (num % 4)
3328 {
3329 as_bad (_("Branch to unaligned address"));
3330 break;
3331 }
3332 if (the_insn.exp.X_add_symbol)
3333 num -= 8;
3334 CHECK_FIELD (num, 8388607, -8388608, 0);
3335 opcode |= re_assemble_22 (num >> 2);
3336 }
3337 else
3338 {
3339 the_insn.reloc = R_HPPA_PCREL_CALL;
3340 the_insn.format = 22;
3341 the_insn.arg_reloc = last_call_desc.arg_reloc;
3342 memset (&last_call_desc, 0, sizeof (struct call_desc));
3343 continue;
3344 }
3345
3346 /* Handle an absolute 17 bit branch target. */
3347 case 'z':
3348 the_insn.field_selector = pa_chk_field_selector (&s);
3349 get_expression (s);
3350 s = expr_end;
3351 the_insn.pcrel = 0;
3352 if (!the_insn.exp.X_add_symbol
3353 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
3354 FAKE_LABEL_NAME))
3355 {
3356 num = evaluate_absolute (&the_insn);
3357 if (num % 4)
3358 {
3359 as_bad (_("Branch to unaligned address"));
3360 break;
3361 }
3362 if (the_insn.exp.X_add_symbol)
3363 num -= 8;
3364 CHECK_FIELD (num, 262143, -262144, 0);
3365 opcode |= re_assemble_17 (num >> 2);
3366 continue;
3367 }
3368 else
3369 {
3370 the_insn.reloc = R_HPPA_ABS_CALL;
3371 the_insn.format = 17;
3372 the_insn.arg_reloc = last_call_desc.arg_reloc;
3373 memset (&last_call_desc, 0, sizeof (struct call_desc));
3374 continue;
3375 }
3376
3377 /* Handle '%r1' implicit operand of addil instruction. */
3378 case 'Z':
3379 if (*s == ',' && *(s + 1) == '%' && *(s + 3) == '1'
3380 && (*(s + 2) == 'r' || *(s + 2) == 'R'))
3381 {
3382 s += 4;
3383 continue;
3384 }
3385 else
3386 break;
3387
3388 /* Handle '%sr0,%r31' implicit operand of be,l instruction. */
3389 case 'Y':
3390 if (strncasecmp (s, "%sr0,%r31", 9) != 0)
3391 break;
3392 s += 9;
3393 continue;
3394
3395 /* Handle immediate value of 0 for ordered load/store instructions. */
3396 case '@':
3397 if (*s != '0')
3398 break;
3399 s++;
3400 continue;
3401
3402 /* Handle a 2 bit shift count at 25. */
3403 case '.':
3404 num = pa_get_absolute_expression (&the_insn, &s);
3405 if (strict && the_insn.exp.X_op != O_constant)
3406 break;
3407 s = expr_end;
3408 CHECK_FIELD (num, 3, 1, strict);
3409 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3410
3411 /* Handle a 4 bit shift count at 25. */
3412 case '*':
3413 num = pa_get_absolute_expression (&the_insn, &s);
3414 if (strict && the_insn.exp.X_op != O_constant)
3415 break;
3416 s = expr_end;
3417 CHECK_FIELD (num, 15, 0, strict);
3418 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3419
3420 /* Handle a 5 bit shift count at 26. */
3421 case 'p':
3422 num = pa_get_absolute_expression (&the_insn, &s);
3423 if (strict && the_insn.exp.X_op != O_constant)
3424 break;
3425 s = expr_end;
3426 CHECK_FIELD (num, 31, 0, strict);
3427 INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
3428
3429 /* Handle a 6 bit shift count at 20,22:26. */
3430 case '~':
3431 num = pa_get_absolute_expression (&the_insn, &s);
3432 if (strict && the_insn.exp.X_op != O_constant)
3433 break;
3434 s = expr_end;
3435 CHECK_FIELD (num, 63, 0, strict);
3436 num = 63 - num;
3437 opcode |= (num & 0x20) << 6;
3438 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
3439
3440 /* Handle a 6 bit field length at 23,27:31. */
3441 case '%':
3442 flag = 0;
3443 num = pa_get_absolute_expression (&the_insn, &s);
3444 if (strict && the_insn.exp.X_op != O_constant)
3445 break;
3446 s = expr_end;
3447 CHECK_FIELD (num, 64, 1, strict);
3448 num--;
3449 opcode |= (num & 0x20) << 3;
3450 num = 31 - (num & 0x1f);
3451 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3452
3453 /* Handle a 6 bit field length at 19,27:31. */
3454 case '|':
3455 num = pa_get_absolute_expression (&the_insn, &s);
3456 if (strict && the_insn.exp.X_op != O_constant)
3457 break;
3458 s = expr_end;
3459 CHECK_FIELD (num, 64, 1, strict);
3460 num--;
3461 opcode |= (num & 0x20) << 7;
3462 num = 31 - (num & 0x1f);
3463 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3464
3465 /* Handle a 5 bit bit position at 26. */
3466 case 'P':
3467 num = pa_get_absolute_expression (&the_insn, &s);
3468 if (strict && the_insn.exp.X_op != O_constant)
3469 break;
3470 s = expr_end;
3471 CHECK_FIELD (num, 31, 0, strict);
3472 INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
3473
3474 /* Handle a 6 bit bit position at 20,22:26. */
3475 case 'q':
3476 num = pa_get_absolute_expression (&the_insn, &s);
3477 if (strict && the_insn.exp.X_op != O_constant)
3478 break;
3479 s = expr_end;
3480 CHECK_FIELD (num, 63, 0, strict);
3481 opcode |= (num & 0x20) << 6;
3482 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
3483
3484 /* Handle a 5 bit immediate at 10 with 'd' as the complement
3485 of the high bit of the immediate. */
3486 case 'B':
3487 num = pa_get_absolute_expression (&the_insn, &s);
3488 if (strict && the_insn.exp.X_op != O_constant)
3489 break;
3490 s = expr_end;
3491 CHECK_FIELD (num, 63, 0, strict);
3492 if (num & 0x20)
3493 ;
3494 else
3495 opcode |= (1 << 13);
3496 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 21);
3497
3498 /* Handle a 5 bit immediate at 10. */
3499 case 'Q':
3500 num = pa_get_absolute_expression (&the_insn, &s);
3501 if (strict && the_insn.exp.X_op != O_constant)
3502 break;
3503 s = expr_end;
3504 CHECK_FIELD (num, 31, 0, strict);
3505 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3506
3507 /* Handle a 9 bit immediate at 28. */
3508 case '$':
3509 num = pa_get_absolute_expression (&the_insn, &s);
3510 if (strict && the_insn.exp.X_op != O_constant)
3511 break;
3512 s = expr_end;
3513 CHECK_FIELD (num, 511, 1, strict);
3514 INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
3515
3516 /* Handle a 13 bit immediate at 18. */
3517 case 'A':
3518 num = pa_get_absolute_expression (&the_insn, &s);
3519 if (strict && the_insn.exp.X_op != O_constant)
3520 break;
3521 s = expr_end;
3522 CHECK_FIELD (num, 8191, 0, strict);
3523 INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
3524
3525 /* Handle a 26 bit immediate at 31. */
3526 case 'D':
3527 num = pa_get_absolute_expression (&the_insn, &s);
3528 if (strict && the_insn.exp.X_op != O_constant)
3529 break;
3530 s = expr_end;
3531 CHECK_FIELD (num, 67108863, 0, strict);
3532 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3533
3534 /* Handle a 3 bit SFU identifier at 25. */
3535 case 'v':
3536 if (*s++ != ',')
3537 as_bad (_("Invalid SFU identifier"));
3538 num = pa_get_absolute_expression (&the_insn, &s);
3539 if (strict && the_insn.exp.X_op != O_constant)
3540 break;
3541 s = expr_end;
3542 CHECK_FIELD (num, 7, 0, strict);
3543 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3544
3545 /* Handle a 20 bit SOP field for spop0. */
3546 case 'O':
3547 num = pa_get_absolute_expression (&the_insn, &s);
3548 if (strict && the_insn.exp.X_op != O_constant)
3549 break;
3550 s = expr_end;
3551 CHECK_FIELD (num, 1048575, 0, strict);
3552 num = (num & 0x1f) | ((num & 0x000fffe0) << 6);
3553 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3554
3555 /* Handle a 15bit SOP field for spop1. */
3556 case 'o':
3557 num = pa_get_absolute_expression (&the_insn, &s);
3558 if (strict && the_insn.exp.X_op != O_constant)
3559 break;
3560 s = expr_end;
3561 CHECK_FIELD (num, 32767, 0, strict);
3562 INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
3563
3564 /* Handle a 10bit SOP field for spop3. */
3565 case '0':
3566 num = pa_get_absolute_expression (&the_insn, &s);
3567 if (strict && the_insn.exp.X_op != O_constant)
3568 break;
3569 s = expr_end;
3570 CHECK_FIELD (num, 1023, 0, strict);
3571 num = (num & 0x1f) | ((num & 0x000003e0) << 6);
3572 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3573
3574 /* Handle a 15 bit SOP field for spop2. */
3575 case '1':
3576 num = pa_get_absolute_expression (&the_insn, &s);
3577 if (strict && the_insn.exp.X_op != O_constant)
3578 break;
3579 s = expr_end;
3580 CHECK_FIELD (num, 32767, 0, strict);
3581 num = (num & 0x1f) | ((num & 0x00007fe0) << 6);
3582 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3583
3584 /* Handle a 3-bit co-processor ID field. */
3585 case 'u':
3586 if (*s++ != ',')
3587 as_bad (_("Invalid COPR identifier"));
3588 num = pa_get_absolute_expression (&the_insn, &s);
3589 if (strict && the_insn.exp.X_op != O_constant)
3590 break;
3591 s = expr_end;
3592 CHECK_FIELD (num, 7, 0, strict);
3593 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3594
3595 /* Handle a 22bit SOP field for copr. */
3596 case '2':
3597 num = pa_get_absolute_expression (&the_insn, &s);
3598 if (strict && the_insn.exp.X_op != O_constant)
3599 break;
3600 s = expr_end;
3601 CHECK_FIELD (num, 4194303, 0, strict);
3602 num = (num & 0x1f) | ((num & 0x003fffe0) << 4);
3603 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3604
3605 /* Handle a source FP operand format completer. */
3606 case '{':
3607 if (*s == ',' && *(s+1) == 't')
3608 {
3609 the_insn.trunc = 1;
3610 s += 2;
3611 }
3612 else
3613 the_insn.trunc = 0;
3614 flag = pa_parse_fp_cnv_format (&s);
3615 the_insn.fpof1 = flag;
3616 if (flag == W || flag == UW)
3617 flag = SGL;
3618 if (flag == DW || flag == UDW)
3619 flag = DBL;
3620 if (flag == QW || flag == UQW)
3621 flag = QUAD;
3622 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3623
3624 /* Handle a destination FP operand format completer. */
3625 case '_':
3626 /* pa_parse_format needs the ',' prefix. */
3627 s--;
3628 flag = pa_parse_fp_cnv_format (&s);
3629 the_insn.fpof2 = flag;
3630 if (flag == W || flag == UW)
3631 flag = SGL;
3632 if (flag == DW || flag == UDW)
3633 flag = DBL;
3634 if (flag == QW || flag == UQW)
3635 flag = QUAD;
3636 opcode |= flag << 13;
3637 if (the_insn.fpof1 == SGL
3638 || the_insn.fpof1 == DBL
3639 || the_insn.fpof1 == QUAD)
3640 {
3641 if (the_insn.fpof2 == SGL
3642 || the_insn.fpof2 == DBL
3643 || the_insn.fpof2 == QUAD)
3644 flag = 0;
3645 else if (the_insn.fpof2 == W
3646 || the_insn.fpof2 == DW
3647 || the_insn.fpof2 == QW)
3648 flag = 2;
3649 else if (the_insn.fpof2 == UW
3650 || the_insn.fpof2 == UDW
3651 || the_insn.fpof2 == UQW)
3652 flag = 6;
3653 else
3654 abort ();
3655 }
3656 else if (the_insn.fpof1 == W
3657 || the_insn.fpof1 == DW
3658 || the_insn.fpof1 == QW)
3659 {
3660 if (the_insn.fpof2 == SGL
3661 || the_insn.fpof2 == DBL
3662 || the_insn.fpof2 == QUAD)
3663 flag = 1;
3664 else
3665 abort ();
3666 }
3667 else if (the_insn.fpof1 == UW
3668 || the_insn.fpof1 == UDW
3669 || the_insn.fpof1 == UQW)
3670 {
3671 if (the_insn.fpof2 == SGL
3672 || the_insn.fpof2 == DBL
3673 || the_insn.fpof2 == QUAD)
3674 flag = 5;
3675 else
3676 abort ();
3677 }
3678 flag |= the_insn.trunc;
3679 INSERT_FIELD_AND_CONTINUE (opcode, flag, 15);
3680
3681 /* Handle a source FP operand format completer. */
3682 case 'F':
3683 flag = pa_parse_fp_format (&s);
3684 the_insn.fpof1 = flag;
3685 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3686
3687 /* Handle a destination FP operand format completer. */
3688 case 'G':
3689 /* pa_parse_format needs the ',' prefix. */
3690 s--;
3691 flag = pa_parse_fp_format (&s);
3692 the_insn.fpof2 = flag;
3693 INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
3694
3695 /* Handle a source FP operand format completer at 20. */
3696 case 'I':
3697 flag = pa_parse_fp_format (&s);
3698 the_insn.fpof1 = flag;
3699 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3700
3701 /* Handle a floating point operand format at 26.
3702 Only allows single and double precision. */
3703 case 'H':
3704 flag = pa_parse_fp_format (&s);
3705 switch (flag)
3706 {
3707 case SGL:
3708 opcode |= 0x20;
3709 case DBL:
3710 the_insn.fpof1 = flag;
3711 continue;
3712
3713 case QUAD:
3714 case ILLEGAL_FMT:
3715 default:
3716 as_bad (_("Invalid Floating Point Operand Format."));
3717 }
3718 break;
3719
3720 /* Handle all floating point registers. */
3721 case 'f':
3722 switch (*++args)
3723 {
3724 /* Float target register. */
3725 case 't':
3726 if (!pa_parse_number (&s, 3))
3727 break;
3728 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3729 CHECK_FIELD (num, 31, 0, 0);
3730 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3731
3732 /* Float target register with L/R selection. */
3733 case 'T':
3734 {
3735 if (!pa_parse_number (&s, 1))
3736 break;
3737 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3738 CHECK_FIELD (num, 31, 0, 0);
3739 opcode |= num;
3740
3741 /* 0x30 opcodes are FP arithmetic operation opcodes
3742 and need to be turned into 0x38 opcodes. This
3743 is not necessary for loads/stores. */
3744 if (need_pa11_opcode ()
3745 && ((opcode & 0xfc000000) == 0x30000000))
3746 opcode |= 1 << 27;
3747
3748 opcode |= (pa_number & FP_REG_RSEL ? 1 << 6 : 0);
3749 continue;
3750 }
3751
3752 /* Float operand 1. */
3753 case 'a':
3754 {
3755 if (!pa_parse_number (&s, 1))
3756 break;
3757 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3758 CHECK_FIELD (num, 31, 0, 0);
3759 opcode |= num << 21;
3760 if (need_pa11_opcode ())
3761 {
3762 opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
3763 opcode |= 1 << 27;
3764 }
3765 continue;
3766 }
3767
3768 /* Float operand 1 with L/R selection. */
3769 case 'X':
3770 case 'A':
3771 {
3772 if (!pa_parse_number (&s, 1))
3773 break;
3774 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3775 CHECK_FIELD (num, 31, 0, 0);
3776 opcode |= num << 21;
3777 opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
3778 continue;
3779 }
3780
3781 /* Float operand 2. */
3782 case 'b':
3783 {
3784 if (!pa_parse_number (&s, 1))
3785 break;
3786 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3787 CHECK_FIELD (num, 31, 0, 0);
3788 opcode |= num << 16;
3789 if (need_pa11_opcode ())
3790 {
3791 opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
3792 opcode |= 1 << 27;
3793 }
3794 continue;
3795 }
3796
3797 /* Float operand 2 with L/R selection. */
3798 case 'B':
3799 {
3800 if (!pa_parse_number (&s, 1))
3801 break;
3802 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3803 CHECK_FIELD (num, 31, 0, 0);
3804 opcode |= num << 16;
3805 opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
3806 continue;
3807 }
3808
3809 /* Float operand 3 for fmpyfadd, fmpynfadd. */
3810 case 'C':
3811 {
3812 if (!pa_parse_number (&s, 1))
3813 break;
3814 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3815 CHECK_FIELD (num, 31, 0, 0);
3816 opcode |= (num & 0x1c) << 11;
3817 opcode |= (num & 0x03) << 9;
3818 opcode |= (pa_number & FP_REG_RSEL ? 1 << 8 : 0);
3819 continue;
3820 }
3821
3822 /* Float mult operand 1 for fmpyadd, fmpysub */
3823 case 'i':
3824 {
3825 if (!pa_parse_number (&s, 1))
3826 break;
3827 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3828 CHECK_FIELD (num, 31, 0, 0);
3829 if (the_insn.fpof1 == SGL)
3830 {
3831 if (num < 16)
3832 {
3833 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3834 break;
3835 }
3836 num &= 0xF;
3837 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
3838 }
3839 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3840 }
3841
3842 /* Float mult operand 2 for fmpyadd, fmpysub */
3843 case 'j':
3844 {
3845 if (!pa_parse_number (&s, 1))
3846 break;
3847 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3848 CHECK_FIELD (num, 31, 0, 0);
3849 if (the_insn.fpof1 == SGL)
3850 {
3851 if (num < 16)
3852 {
3853 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3854 break;
3855 }
3856 num &= 0xF;
3857 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
3858 }
3859 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3860 }
3861
3862 /* Float mult target for fmpyadd, fmpysub */
3863 case 'k':
3864 {
3865 if (!pa_parse_number (&s, 1))
3866 break;
3867 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3868 CHECK_FIELD (num, 31, 0, 0);
3869 if (the_insn.fpof1 == SGL)
3870 {
3871 if (num < 16)
3872 {
3873 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3874 break;
3875 }
3876 num &= 0xF;
3877 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
3878 }
3879 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3880 }
3881
3882 /* Float add operand 1 for fmpyadd, fmpysub */
3883 case 'l':
3884 {
3885 if (!pa_parse_number (&s, 1))
3886 break;
3887 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3888 CHECK_FIELD (num, 31, 0, 0);
3889 if (the_insn.fpof1 == SGL)
3890 {
3891 if (num < 16)
3892 {
3893 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3894 break;
3895 }
3896 num &= 0xF;
3897 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
3898 }
3899 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3900 }
3901
3902 /* Float add target for fmpyadd, fmpysub */
3903 case 'm':
3904 {
3905 if (!pa_parse_number (&s, 1))
3906 break;
3907 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3908 CHECK_FIELD (num, 31, 0, 0);
3909 if (the_insn.fpof1 == SGL)
3910 {
3911 if (num < 16)
3912 {
3913 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3914 break;
3915 }
3916 num &= 0xF;
3917 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
3918 }
3919 INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
3920 }
3921
3922 /* Handle L/R register halves like 'x'. */
3923 case 'E':
3924 case 'e':
3925 {
3926 if (!pa_parse_number (&s, 1))
3927 break;
3928 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3929 CHECK_FIELD (num, 31, 0, 0);
3930 opcode |= num << 16;
3931 if (need_pa11_opcode ())
3932 {
3933 opcode |= (pa_number & FP_REG_RSEL ? 1 << 1 : 0);
3934 }
3935 continue;
3936 }
3937
3938 /* Float target register (PA 2.0 wide). */
3939 case 'x':
3940 if (!pa_parse_number (&s, 3))
3941 break;
3942 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3943 CHECK_FIELD (num, 31, 0, 0);
3944 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3945
3946 default:
3947 abort ();
3948 }
3949 break;
3950
3951 default:
3952 abort ();
3953 }
3954 break;
3955 }
3956
3957 /* If this instruction is specific to a particular architecture,
3958 then set a new architecture. This automatic promotion crud is
3959 for compatibility with HP's old assemblers only. */
3960 if (match == TRUE
3961 && bfd_get_mach (stdoutput) < insn->arch)
3962 {
3963 if (need_promotion)
3964 {
3965 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, insn->arch))
3966 as_warn (_("could not update architecture and machine"));
3967 }
3968 else
3969 {
3970 match = FALSE;
3971 if (!promoted_insn)
3972 promoted_insn = insn;
3973 }
3974 }
3975
3976 failed:
3977 /* Check if the args matched. */
3978 if (!match)
3979 {
3980 if (&insn[1] - pa_opcodes < (int) NUMOPCODES
3981 && !strcmp (insn->name, insn[1].name))
3982 {
3983 ++insn;
3984 s = argstart;
3985 continue;
3986 }
3987 else
3988 {
3989 if (promoted_insn)
3990 {
3991 insn = promoted_insn;
3992 need_promotion = TRUE;
3993 s = argstart;
3994 continue;
3995 }
3996 as_bad (_("Invalid operands %s"), error_message);
3997 return;
3998 }
3999 }
4000 break;
4001 }
4002
4003 the_insn.opcode = opcode;
4004 }
4005
4006 /* Turn a string in input_line_pointer into a floating point constant of type
4007 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
4008 emitted is stored in *sizeP . An error message or NULL is returned. */
4009
4010 #define MAX_LITTLENUMS 6
4011
4012 char *
4013 md_atof (type, litP, sizeP)
4014 char type;
4015 char *litP;
4016 int *sizeP;
4017 {
4018 int prec;
4019 LITTLENUM_TYPE words[MAX_LITTLENUMS];
4020 LITTLENUM_TYPE *wordP;
4021 char *t;
4022
4023 switch (type)
4024 {
4025
4026 case 'f':
4027 case 'F':
4028 case 's':
4029 case 'S':
4030 prec = 2;
4031 break;
4032
4033 case 'd':
4034 case 'D':
4035 case 'r':
4036 case 'R':
4037 prec = 4;
4038 break;
4039
4040 case 'x':
4041 case 'X':
4042 prec = 6;
4043 break;
4044
4045 case 'p':
4046 case 'P':
4047 prec = 6;
4048 break;
4049
4050 default:
4051 *sizeP = 0;
4052 return _("Bad call to MD_ATOF()");
4053 }
4054 t = atof_ieee (input_line_pointer, type, words);
4055 if (t)
4056 input_line_pointer = t;
4057 *sizeP = prec * sizeof (LITTLENUM_TYPE);
4058 for (wordP = words; prec--;)
4059 {
4060 md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
4061 litP += sizeof (LITTLENUM_TYPE);
4062 }
4063 return NULL;
4064 }
4065
4066 /* Write out big-endian. */
4067
4068 void
4069 md_number_to_chars (buf, val, n)
4070 char *buf;
4071 valueT val;
4072 int n;
4073 {
4074 number_to_chars_bigendian (buf, val, n);
4075 }
4076
4077 /* Translate internal representation of relocation info to BFD target
4078 format. */
4079
4080 arelent **
4081 tc_gen_reloc (section, fixp)
4082 asection *section;
4083 fixS *fixp;
4084 {
4085 arelent *reloc;
4086 struct hppa_fix_struct *hppa_fixp;
4087 static arelent *no_relocs = NULL;
4088 arelent **relocs;
4089 reloc_type **codes;
4090 reloc_type code;
4091 int n_relocs;
4092 int i;
4093
4094 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
4095 if (fixp->fx_addsy == 0)
4096 return &no_relocs;
4097
4098 assert (hppa_fixp != 0);
4099 assert (section != 0);
4100
4101 reloc = (arelent *) xmalloc (sizeof (arelent));
4102
4103 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4104 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4105 codes = hppa_gen_reloc_type (stdoutput,
4106 fixp->fx_r_type,
4107 hppa_fixp->fx_r_format,
4108 hppa_fixp->fx_r_field,
4109 fixp->fx_subsy != NULL,
4110 symbol_get_bfdsym (fixp->fx_addsy));
4111
4112 if (codes == NULL)
4113 {
4114 as_bad_where (fixp->fx_file, fixp->fx_line, _("Cannot handle fixup"));
4115 abort ();
4116 }
4117
4118 for (n_relocs = 0; codes[n_relocs]; n_relocs++)
4119 ;
4120
4121 relocs = (arelent **) xmalloc (sizeof (arelent *) * n_relocs + 1);
4122 reloc = (arelent *) xmalloc (sizeof (arelent) * n_relocs);
4123 for (i = 0; i < n_relocs; i++)
4124 relocs[i] = &reloc[i];
4125
4126 relocs[n_relocs] = NULL;
4127
4128 #ifdef OBJ_ELF
4129 switch (fixp->fx_r_type)
4130 {
4131 default:
4132 assert (n_relocs == 1);
4133
4134 code = *codes[0];
4135
4136 /* Now, do any processing that is dependent on the relocation type. */
4137 switch (code)
4138 {
4139 case R_PARISC_DLTREL21L:
4140 case R_PARISC_DLTREL14R:
4141 case R_PARISC_DLTREL14F:
4142 case R_PARISC_PLABEL32:
4143 case R_PARISC_PLABEL21L:
4144 case R_PARISC_PLABEL14R:
4145 /* For plabel relocations, the addend of the
4146 relocation should be either 0 (no static link) or 2
4147 (static link required). This adjustment is done in
4148 bfd/elf32-hppa.c:elf32_hppa_relocate_section.
4149
4150 We also slam a zero addend into the DLT relative relocs;
4151 it doesn't make a lot of sense to use any addend since
4152 it gets you a different (eg unknown) DLT entry. */
4153 reloc->addend = 0;
4154 break;
4155
4156 #ifdef ELF_ARG_RELOC
4157 case R_PARISC_PCREL17R:
4158 case R_PARISC_PCREL17F:
4159 case R_PARISC_PCREL17C:
4160 case R_PARISC_DIR17R:
4161 case R_PARISC_DIR17F:
4162 case R_PARISC_PCREL21L:
4163 case R_PARISC_DIR21L:
4164 reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc,
4165 fixp->fx_offset);
4166 break;
4167 #endif
4168
4169 case R_PARISC_DIR32:
4170 /* Facilitate hand-crafted unwind info. */
4171 if (strcmp (section->name, UNWIND_SECTION_NAME) == 0)
4172 code = R_PARISC_SEGREL32;
4173 /* Fall thru */
4174
4175 default:
4176 reloc->addend = fixp->fx_offset;
4177 break;
4178 }
4179
4180 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4181 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4182 reloc->howto = bfd_reloc_type_lookup (stdoutput,
4183 (bfd_reloc_code_real_type) code);
4184 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
4185
4186 assert (reloc->howto && (unsigned int) code == reloc->howto->type);
4187 break;
4188 }
4189 #else /* OBJ_SOM */
4190
4191 /* Walk over reach relocation returned by the BFD backend. */
4192 for (i = 0; i < n_relocs; i++)
4193 {
4194 code = *codes[i];
4195
4196 relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4197 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4198 relocs[i]->howto =
4199 bfd_reloc_type_lookup (stdoutput,
4200 (bfd_reloc_code_real_type) code);
4201 relocs[i]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4202
4203 switch (code)
4204 {
4205 case R_COMP2:
4206 /* The only time we ever use a R_COMP2 fixup is for the difference
4207 of two symbols. With that in mind we fill in all four
4208 relocs now and break out of the loop. */
4209 assert (i == 1);
4210 relocs[0]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
4211 relocs[0]->howto =
4212 bfd_reloc_type_lookup (stdoutput,
4213 (bfd_reloc_code_real_type) *codes[0]);
4214 relocs[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4215 relocs[0]->addend = 0;
4216 relocs[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4217 *relocs[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4218 relocs[1]->howto =
4219 bfd_reloc_type_lookup (stdoutput,
4220 (bfd_reloc_code_real_type) *codes[1]);
4221 relocs[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4222 relocs[1]->addend = 0;
4223 relocs[2]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4224 *relocs[2]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
4225 relocs[2]->howto =
4226 bfd_reloc_type_lookup (stdoutput,
4227 (bfd_reloc_code_real_type) *codes[2]);
4228 relocs[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4229 relocs[2]->addend = 0;
4230 relocs[3]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
4231 relocs[3]->howto =
4232 bfd_reloc_type_lookup (stdoutput,
4233 (bfd_reloc_code_real_type) *codes[3]);
4234 relocs[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4235 relocs[3]->addend = 0;
4236 relocs[4]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
4237 relocs[4]->howto =
4238 bfd_reloc_type_lookup (stdoutput,
4239 (bfd_reloc_code_real_type) *codes[4]);
4240 relocs[4]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4241 relocs[4]->addend = 0;
4242 goto done;
4243 case R_PCREL_CALL:
4244 case R_ABS_CALL:
4245 relocs[i]->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
4246 break;
4247
4248 case R_DLT_REL:
4249 case R_DATA_PLABEL:
4250 case R_CODE_PLABEL:
4251 /* For plabel relocations, the addend of the
4252 relocation should be either 0 (no static link) or 2
4253 (static link required).
4254
4255 FIXME: We always assume no static link!
4256
4257 We also slam a zero addend into the DLT relative relocs;
4258 it doesn't make a lot of sense to use any addend since
4259 it gets you a different (eg unknown) DLT entry. */
4260 relocs[i]->addend = 0;
4261 break;
4262
4263 case R_N_MODE:
4264 case R_S_MODE:
4265 case R_D_MODE:
4266 case R_R_MODE:
4267 case R_FSEL:
4268 case R_LSEL:
4269 case R_RSEL:
4270 case R_BEGIN_BRTAB:
4271 case R_END_BRTAB:
4272 case R_BEGIN_TRY:
4273 case R_N0SEL:
4274 case R_N1SEL:
4275 /* There is no symbol or addend associated with these fixups. */
4276 relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4277 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
4278 relocs[i]->addend = 0;
4279 break;
4280
4281 case R_END_TRY:
4282 case R_ENTRY:
4283 case R_EXIT:
4284 /* There is no symbol associated with these fixups. */
4285 relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4286 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
4287 relocs[i]->addend = fixp->fx_offset;
4288 break;
4289
4290 default:
4291 relocs[i]->addend = fixp->fx_offset;
4292 }
4293 }
4294
4295 done:
4296 #endif
4297
4298 return relocs;
4299 }
4300
4301 /* Process any machine dependent frag types. */
4302
4303 void
4304 md_convert_frag (abfd, sec, fragP)
4305 register bfd *abfd ATTRIBUTE_UNUSED;
4306 register asection *sec ATTRIBUTE_UNUSED;
4307 register fragS *fragP;
4308 {
4309 unsigned int address;
4310
4311 if (fragP->fr_type == rs_machine_dependent)
4312 {
4313 switch ((int) fragP->fr_subtype)
4314 {
4315 case 0:
4316 fragP->fr_type = rs_fill;
4317 know (fragP->fr_var == 1);
4318 know (fragP->fr_next);
4319 address = fragP->fr_address + fragP->fr_fix;
4320 if (address % fragP->fr_offset)
4321 {
4322 fragP->fr_offset =
4323 fragP->fr_next->fr_address
4324 - fragP->fr_address
4325 - fragP->fr_fix;
4326 }
4327 else
4328 fragP->fr_offset = 0;
4329 break;
4330 }
4331 }
4332 }
4333
4334 /* Round up a section size to the appropriate boundary. */
4335
4336 valueT
4337 md_section_align (segment, size)
4338 asection *segment;
4339 valueT size;
4340 {
4341 int align = bfd_get_section_alignment (stdoutput, segment);
4342 int align2 = (1 << align) - 1;
4343
4344 return (size + align2) & ~align2;
4345 }
4346
4347 /* Return the approximate size of a frag before relaxation has occurred. */
4348 int
4349 md_estimate_size_before_relax (fragP, segment)
4350 register fragS *fragP;
4351 asection *segment ATTRIBUTE_UNUSED;
4352 {
4353 int size;
4354
4355 size = 0;
4356
4357 while ((fragP->fr_fix + size) % fragP->fr_offset)
4358 size++;
4359
4360 return size;
4361 }
4362 \f
4363 #ifdef OBJ_ELF
4364 # ifdef WARN_COMMENTS
4365 const char *md_shortopts = "Vc";
4366 # else
4367 const char *md_shortopts = "V";
4368 # endif
4369 #else
4370 # ifdef WARN_COMMENTS
4371 const char *md_shortopts = "c";
4372 # else
4373 const char *md_shortopts = "";
4374 # endif
4375 #endif
4376
4377 struct option md_longopts[] = {
4378 #ifdef WARN_COMMENTS
4379 {"warn-comment", no_argument, NULL, 'c'},
4380 #endif
4381 {NULL, no_argument, NULL, 0}
4382 };
4383 size_t md_longopts_size = sizeof (md_longopts);
4384
4385 int
4386 md_parse_option (c, arg)
4387 int c ATTRIBUTE_UNUSED;
4388 char *arg ATTRIBUTE_UNUSED;
4389 {
4390 switch (c)
4391 {
4392 default:
4393 return 0;
4394
4395 #ifdef OBJ_ELF
4396 case 'V':
4397 print_version_id ();
4398 break;
4399 #endif
4400 #ifdef WARN_COMMENTS
4401 case 'c':
4402 warn_comment = 1;
4403 break;
4404 #endif
4405 }
4406
4407 return 1;
4408 }
4409
4410 void
4411 md_show_usage (stream)
4412 FILE *stream ATTRIBUTE_UNUSED;
4413 {
4414 #ifdef OBJ_ELF
4415 fprintf (stream, _("\
4416 -Q ignored\n"));
4417 #endif
4418 #ifdef WARN_COMMENTS
4419 fprintf (stream, _("\
4420 -c print a warning if a comment is found\n"));
4421 #endif
4422 }
4423 \f
4424 /* We have no need to default values of symbols. */
4425
4426 symbolS *
4427 md_undefined_symbol (name)
4428 char *name ATTRIBUTE_UNUSED;
4429 {
4430 return 0;
4431 }
4432
4433 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
4434 #define nonzero_dibits(x) \
4435 ((x) | (((x) & 0x55555555) << 1) | (((x) & 0xAAAAAAAA) >> 1))
4436 #define arg_reloc_stub_needed(CALLER, CALLEE) \
4437 (((CALLER) ^ (CALLEE)) & nonzero_dibits (CALLER) & nonzero_dibits (CALLEE))
4438 #else
4439 #define arg_reloc_stub_needed(CALLER, CALLEE) 0
4440 #endif
4441
4442 /* Apply a fixup to an instruction. */
4443
4444 void
4445 md_apply_fix (fixP, valP, seg)
4446 fixS *fixP;
4447 valueT *valP;
4448 segT seg ATTRIBUTE_UNUSED;
4449 {
4450 unsigned char *buf;
4451 struct hppa_fix_struct *hppa_fixP;
4452 offsetT new_val;
4453 int insn, val, fmt;
4454
4455 /* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
4456 never be "applied" (they are just markers). Likewise for
4457 R_HPPA_BEGIN_BRTAB and R_HPPA_END_BRTAB. */
4458 #ifdef OBJ_SOM
4459 if (fixP->fx_r_type == R_HPPA_ENTRY
4460 || fixP->fx_r_type == R_HPPA_EXIT
4461 || fixP->fx_r_type == R_HPPA_BEGIN_BRTAB
4462 || fixP->fx_r_type == R_HPPA_END_BRTAB
4463 || fixP->fx_r_type == R_HPPA_BEGIN_TRY)
4464 return;
4465
4466 /* Disgusting. We must set fx_offset ourselves -- R_HPPA_END_TRY
4467 fixups are considered not adjustable, which in turn causes
4468 adjust_reloc_syms to not set fx_offset. Ugh. */
4469 if (fixP->fx_r_type == R_HPPA_END_TRY)
4470 {
4471 fixP->fx_offset = * valP;
4472 return;
4473 }
4474 #endif
4475 #ifdef OBJ_ELF
4476 if (fixP->fx_r_type == (int) R_PARISC_GNU_VTENTRY
4477 || fixP->fx_r_type == (int) R_PARISC_GNU_VTINHERIT)
4478 return;
4479 #endif
4480
4481 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
4482 fixP->fx_done = 1;
4483
4484 /* There should have been an HPPA specific fixup associated
4485 with the GAS fixup. */
4486 hppa_fixP = (struct hppa_fix_struct *) fixP->tc_fix_data;
4487 if (hppa_fixP == NULL)
4488 {
4489 as_bad_where (fixP->fx_file, fixP->fx_line,
4490 _("no hppa_fixup entry for fixup type 0x%x"),
4491 fixP->fx_r_type);
4492 return;
4493 }
4494
4495 buf = (unsigned char *) (fixP->fx_frag->fr_literal + fixP->fx_where);
4496 insn = bfd_get_32 (stdoutput, buf);
4497 fmt = bfd_hppa_insn2fmt (stdoutput, insn);
4498
4499 /* If there is a symbol associated with this fixup, then it's something
4500 which will need a SOM relocation (except for some PC-relative relocs).
4501 In such cases we should treat the "val" or "addend" as zero since it
4502 will be added in as needed from fx_offset in tc_gen_reloc. */
4503 if ((fixP->fx_addsy != NULL
4504 || fixP->fx_r_type == (int) R_HPPA_NONE)
4505 #ifdef OBJ_SOM
4506 && fmt != 32
4507 #endif
4508 )
4509 new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
4510 #ifdef OBJ_SOM
4511 /* These field selectors imply that we do not want an addend. */
4512 else if (hppa_fixP->fx_r_field == e_psel
4513 || hppa_fixP->fx_r_field == e_rpsel
4514 || hppa_fixP->fx_r_field == e_lpsel
4515 || hppa_fixP->fx_r_field == e_tsel
4516 || hppa_fixP->fx_r_field == e_rtsel
4517 || hppa_fixP->fx_r_field == e_ltsel)
4518 new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
4519 #endif
4520 else
4521 new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
4522
4523 /* Handle pc-relative exceptions from above. */
4524 if ((fmt == 12 || fmt == 17 || fmt == 22)
4525 && fixP->fx_addsy
4526 && fixP->fx_pcrel
4527 && !arg_reloc_stub_needed (symbol_arg_reloc_info (fixP->fx_addsy),
4528 hppa_fixP->fx_arg_reloc)
4529 #ifdef OBJ_ELF
4530 && (* valP - 8 + 8192 < 16384
4531 || (fmt == 17 && * valP - 8 + 262144 < 524288)
4532 || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
4533 #endif
4534 #ifdef OBJ_SOM
4535 && (* valP - 8 + 262144 < 524288
4536 || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
4537 #endif
4538 && !S_IS_EXTERNAL (fixP->fx_addsy)
4539 && !S_IS_WEAK (fixP->fx_addsy)
4540 && S_GET_SEGMENT (fixP->fx_addsy) == hppa_fixP->segment
4541 && !(fixP->fx_subsy
4542 && S_GET_SEGMENT (fixP->fx_subsy) != hppa_fixP->segment))
4543 {
4544 new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
4545 }
4546
4547 switch (fmt)
4548 {
4549 case 10:
4550 CHECK_FIELD_WHERE (new_val, 8191, -8192,
4551 fixP->fx_file, fixP->fx_line);
4552 val = new_val;
4553
4554 insn = (insn & ~ 0x3ff1) | (((val & 0x1ff8) << 1)
4555 | ((val & 0x2000) >> 13));
4556 break;
4557 case -11:
4558 CHECK_FIELD_WHERE (new_val, 8191, -8192,
4559 fixP->fx_file, fixP->fx_line);
4560 val = new_val;
4561
4562 insn = (insn & ~ 0x3ff9) | (((val & 0x1ffc) << 1)
4563 | ((val & 0x2000) >> 13));
4564 break;
4565 /* Handle all opcodes with the 'j' operand type. */
4566 case 14:
4567 CHECK_FIELD_WHERE (new_val, 8191, -8192,
4568 fixP->fx_file, fixP->fx_line);
4569 val = new_val;
4570
4571 insn = ((insn & ~ 0x3fff) | low_sign_unext (val, 14));
4572 break;
4573
4574 /* Handle all opcodes with the 'k' operand type. */
4575 case 21:
4576 CHECK_FIELD_WHERE (new_val, 1048575, -1048576,
4577 fixP->fx_file, fixP->fx_line);
4578 val = new_val;
4579
4580 insn = (insn & ~ 0x1fffff) | re_assemble_21 (val);
4581 break;
4582
4583 /* Handle all the opcodes with the 'i' operand type. */
4584 case 11:
4585 CHECK_FIELD_WHERE (new_val, 1023, -1024,
4586 fixP->fx_file, fixP->fx_line);
4587 val = new_val;
4588
4589 insn = (insn & ~ 0x7ff) | low_sign_unext (val, 11);
4590 break;
4591
4592 /* Handle all the opcodes with the 'w' operand type. */
4593 case 12:
4594 CHECK_FIELD_WHERE (new_val - 8, 8191, -8192,
4595 fixP->fx_file, fixP->fx_line);
4596 val = new_val - 8;
4597
4598 insn = (insn & ~ 0x1ffd) | re_assemble_12 (val >> 2);
4599 break;
4600
4601 /* Handle some of the opcodes with the 'W' operand type. */
4602 case 17:
4603 {
4604 offsetT distance = * valP;
4605
4606 /* If this is an absolute branch (ie no link) with an out of
4607 range target, then we want to complain. */
4608 if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
4609 && (insn & 0xffe00000) == 0xe8000000)
4610 CHECK_FIELD_WHERE (distance - 8, 262143, -262144,
4611 fixP->fx_file, fixP->fx_line);
4612
4613 CHECK_FIELD_WHERE (new_val - 8, 262143, -262144,
4614 fixP->fx_file, fixP->fx_line);
4615 val = new_val - 8;
4616
4617 insn = (insn & ~ 0x1f1ffd) | re_assemble_17 (val >> 2);
4618 break;
4619 }
4620
4621 case 22:
4622 {
4623 offsetT distance = * valP;
4624
4625 /* If this is an absolute branch (ie no link) with an out of
4626 range target, then we want to complain. */
4627 if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
4628 && (insn & 0xffe00000) == 0xe8000000)
4629 CHECK_FIELD_WHERE (distance - 8, 8388607, -8388608,
4630 fixP->fx_file, fixP->fx_line);
4631
4632 CHECK_FIELD_WHERE (new_val - 8, 8388607, -8388608,
4633 fixP->fx_file, fixP->fx_line);
4634 val = new_val - 8;
4635
4636 insn = (insn & ~ 0x3ff1ffd) | re_assemble_22 (val >> 2);
4637 break;
4638 }
4639
4640 case -10:
4641 val = new_val;
4642 insn = (insn & ~ 0xfff1) | re_assemble_16 (val & -8);
4643 break;
4644
4645 case -16:
4646 val = new_val;
4647 insn = (insn & ~ 0xfff9) | re_assemble_16 (val & -4);
4648 break;
4649
4650 case 16:
4651 val = new_val;
4652 insn = (insn & ~ 0xffff) | re_assemble_16 (val);
4653 break;
4654
4655 case 32:
4656 insn = new_val;
4657 break;
4658
4659 default:
4660 as_bad_where (fixP->fx_file, fixP->fx_line,
4661 _("Unknown relocation encountered in md_apply_fix."));
4662 return;
4663 }
4664
4665 /* Insert the relocation. */
4666 bfd_put_32 (stdoutput, insn, buf);
4667 }
4668
4669 /* Exactly what point is a PC-relative offset relative TO?
4670 On the PA, they're relative to the address of the offset. */
4671
4672 long
4673 md_pcrel_from (fixP)
4674 fixS *fixP;
4675 {
4676 return fixP->fx_where + fixP->fx_frag->fr_address;
4677 }
4678
4679 /* Return nonzero if the input line pointer is at the end of
4680 a statement. */
4681
4682 static int
4683 is_end_of_statement ()
4684 {
4685 return ((*input_line_pointer == '\n')
4686 || (*input_line_pointer == ';')
4687 || (*input_line_pointer == '!'));
4688 }
4689
4690 /* Read a number from S. The number might come in one of many forms,
4691 the most common will be a hex or decimal constant, but it could be
4692 a pre-defined register (Yuk!), or an absolute symbol.
4693
4694 Return 1 on success or 0 on failure. If STRICT, then a missing
4695 register prefix will cause a failure. The number itself is
4696 returned in `pa_number'.
4697
4698 IS_FLOAT indicates that a PA-89 FP register number should be
4699 parsed; A `l' or `r' suffix is checked for if but 2 of IS_FLOAT is
4700 not set.
4701
4702 pa_parse_number can not handle negative constants and will fail
4703 horribly if it is passed such a constant. */
4704
4705 static int
4706 pa_parse_number (s, is_float)
4707 char **s;
4708 int is_float;
4709 {
4710 int num;
4711 char *name;
4712 char c;
4713 symbolS *sym;
4714 int status;
4715 char *p = *s;
4716 bfd_boolean have_prefix;
4717
4718 /* Skip whitespace before the number. */
4719 while (*p == ' ' || *p == '\t')
4720 p = p + 1;
4721
4722 pa_number = -1;
4723 have_prefix = 0;
4724 num = 0;
4725 if (!strict && ISDIGIT (*p))
4726 {
4727 /* Looks like a number. */
4728
4729 if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
4730 {
4731 /* The number is specified in hex. */
4732 p += 2;
4733 while (ISDIGIT (*p) || ((*p >= 'a') && (*p <= 'f'))
4734 || ((*p >= 'A') && (*p <= 'F')))
4735 {
4736 if (ISDIGIT (*p))
4737 num = num * 16 + *p - '0';
4738 else if (*p >= 'a' && *p <= 'f')
4739 num = num * 16 + *p - 'a' + 10;
4740 else
4741 num = num * 16 + *p - 'A' + 10;
4742 ++p;
4743 }
4744 }
4745 else
4746 {
4747 /* The number is specified in decimal. */
4748 while (ISDIGIT (*p))
4749 {
4750 num = num * 10 + *p - '0';
4751 ++p;
4752 }
4753 }
4754
4755 pa_number = num;
4756
4757 /* Check for a `l' or `r' suffix. */
4758 if (is_float)
4759 {
4760 pa_number += FP_REG_BASE;
4761 if (! (is_float & 2))
4762 {
4763 if (IS_R_SELECT (p))
4764 {
4765 pa_number += FP_REG_RSEL;
4766 ++p;
4767 }
4768 else if (IS_L_SELECT (p))
4769 {
4770 ++p;
4771 }
4772 }
4773 }
4774 }
4775 else if (*p == '%')
4776 {
4777 /* The number might be a predefined register. */
4778 have_prefix = 1;
4779 name = p;
4780 p++;
4781 c = *p;
4782 /* Tege hack: Special case for general registers as the general
4783 code makes a binary search with case translation, and is VERY
4784 slow. */
4785 if (c == 'r')
4786 {
4787 p++;
4788 if (*p == 'e' && *(p + 1) == 't'
4789 && (*(p + 2) == '0' || *(p + 2) == '1'))
4790 {
4791 p += 2;
4792 num = *p - '0' + 28;
4793 p++;
4794 }
4795 else if (*p == 'p')
4796 {
4797 num = 2;
4798 p++;
4799 }
4800 else if (!ISDIGIT (*p))
4801 {
4802 if (print_errors)
4803 as_bad (_("Undefined register: '%s'."), name);
4804 num = -1;
4805 }
4806 else
4807 {
4808 do
4809 num = num * 10 + *p++ - '0';
4810 while (ISDIGIT (*p));
4811 }
4812 }
4813 else
4814 {
4815 /* Do a normal register search. */
4816 while (is_part_of_name (c))
4817 {
4818 p = p + 1;
4819 c = *p;
4820 }
4821 *p = 0;
4822 status = reg_name_search (name);
4823 if (status >= 0)
4824 num = status;
4825 else
4826 {
4827 if (print_errors)
4828 as_bad (_("Undefined register: '%s'."), name);
4829 num = -1;
4830 }
4831 *p = c;
4832 }
4833
4834 pa_number = num;
4835 }
4836 else
4837 {
4838 /* And finally, it could be a symbol in the absolute section which
4839 is effectively a constant, or a register alias symbol. */
4840 name = p;
4841 c = *p;
4842 while (is_part_of_name (c))
4843 {
4844 p = p + 1;
4845 c = *p;
4846 }
4847 *p = 0;
4848 if ((sym = symbol_find (name)) != NULL)
4849 {
4850 if (S_GET_SEGMENT (sym) == reg_section)
4851 {
4852 num = S_GET_VALUE (sym);
4853 /* Well, we don't really have one, but we do have a
4854 register, so... */
4855 have_prefix = TRUE;
4856 }
4857 else if (S_GET_SEGMENT (sym) == &bfd_abs_section)
4858 num = S_GET_VALUE (sym);
4859 else if (!strict)
4860 {
4861 if (print_errors)
4862 as_bad (_("Non-absolute symbol: '%s'."), name);
4863 num = -1;
4864 }
4865 }
4866 else if (!strict)
4867 {
4868 /* There is where we'd come for an undefined symbol
4869 or for an empty string. For an empty string we
4870 will return zero. That's a concession made for
4871 compatibility with the braindamaged HP assemblers. */
4872 if (*name == 0)
4873 num = 0;
4874 else
4875 {
4876 if (print_errors)
4877 as_bad (_("Undefined absolute constant: '%s'."), name);
4878 num = -1;
4879 }
4880 }
4881 *p = c;
4882
4883 pa_number = num;
4884 }
4885
4886 if (!strict || have_prefix)
4887 {
4888 *s = p;
4889 return 1;
4890 }
4891 return 0;
4892 }
4893
4894 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
4895
4896 /* Given NAME, find the register number associated with that name, return
4897 the integer value associated with the given name or -1 on failure. */
4898
4899 static int
4900 reg_name_search (name)
4901 char *name;
4902 {
4903 int middle, low, high;
4904 int cmp;
4905
4906 low = 0;
4907 high = REG_NAME_CNT - 1;
4908
4909 do
4910 {
4911 middle = (low + high) / 2;
4912 cmp = strcasecmp (name, pre_defined_registers[middle].name);
4913 if (cmp < 0)
4914 high = middle - 1;
4915 else if (cmp > 0)
4916 low = middle + 1;
4917 else
4918 return pre_defined_registers[middle].value;
4919 }
4920 while (low <= high);
4921
4922 return -1;
4923 }
4924
4925 /* Return nonzero if the given INSN and L/R information will require
4926 a new PA-1.1 opcode. */
4927
4928 static int
4929 need_pa11_opcode ()
4930 {
4931 if ((pa_number & FP_REG_RSEL) != 0
4932 && !(the_insn.fpof1 == DBL && the_insn.fpof2 == DBL))
4933 {
4934 /* If this instruction is specific to a particular architecture,
4935 then set a new architecture. */
4936 if (bfd_get_mach (stdoutput) < pa11)
4937 {
4938 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, pa11))
4939 as_warn (_("could not update architecture and machine"));
4940 }
4941 return TRUE;
4942 }
4943 else
4944 return FALSE;
4945 }
4946
4947 /* Parse a condition for a fcmp instruction. Return the numerical
4948 code associated with the condition. */
4949
4950 static int
4951 pa_parse_fp_cmp_cond (s)
4952 char **s;
4953 {
4954 int cond, i;
4955
4956 cond = 0;
4957
4958 for (i = 0; i < 32; i++)
4959 {
4960 if (strncasecmp (*s, fp_cond_map[i].string,
4961 strlen (fp_cond_map[i].string)) == 0)
4962 {
4963 cond = fp_cond_map[i].cond;
4964 *s += strlen (fp_cond_map[i].string);
4965 /* If not a complete match, back up the input string and
4966 report an error. */
4967 if (**s != ' ' && **s != '\t')
4968 {
4969 *s -= strlen (fp_cond_map[i].string);
4970 break;
4971 }
4972 while (**s == ' ' || **s == '\t')
4973 *s = *s + 1;
4974 return cond;
4975 }
4976 }
4977
4978 as_bad (_("Invalid FP Compare Condition: %s"), *s);
4979
4980 /* Advance over the bogus completer. */
4981 while (**s != ',' && **s != ' ' && **s != '\t')
4982 *s += 1;
4983
4984 return 0;
4985 }
4986
4987 /* Parse a graphics test complete for ftest. */
4988
4989 static int
4990 pa_parse_ftest_gfx_completer (s)
4991 char **s;
4992 {
4993 int value;
4994
4995 value = 0;
4996 if (strncasecmp (*s, "acc8", 4) == 0)
4997 {
4998 value = 5;
4999 *s += 4;
5000 }
5001 else if (strncasecmp (*s, "acc6", 4) == 0)
5002 {
5003 value = 9;
5004 *s += 4;
5005 }
5006 else if (strncasecmp (*s, "acc4", 4) == 0)
5007 {
5008 value = 13;
5009 *s += 4;
5010 }
5011 else if (strncasecmp (*s, "acc2", 4) == 0)
5012 {
5013 value = 17;
5014 *s += 4;
5015 }
5016 else if (strncasecmp (*s, "acc", 3) == 0)
5017 {
5018 value = 1;
5019 *s += 3;
5020 }
5021 else if (strncasecmp (*s, "rej8", 4) == 0)
5022 {
5023 value = 6;
5024 *s += 4;
5025 }
5026 else if (strncasecmp (*s, "rej", 3) == 0)
5027 {
5028 value = 2;
5029 *s += 3;
5030 }
5031 else
5032 {
5033 value = 0;
5034 as_bad (_("Invalid FTEST completer: %s"), *s);
5035 }
5036
5037 return value;
5038 }
5039
5040 /* Parse an FP operand format completer returning the completer
5041 type. */
5042
5043 static fp_operand_format
5044 pa_parse_fp_cnv_format (s)
5045 char **s;
5046 {
5047 int format;
5048
5049 format = SGL;
5050 if (**s == ',')
5051 {
5052 *s += 1;
5053 if (strncasecmp (*s, "sgl", 3) == 0)
5054 {
5055 format = SGL;
5056 *s += 4;
5057 }
5058 else if (strncasecmp (*s, "dbl", 3) == 0)
5059 {
5060 format = DBL;
5061 *s += 4;
5062 }
5063 else if (strncasecmp (*s, "quad", 4) == 0)
5064 {
5065 format = QUAD;
5066 *s += 5;
5067 }
5068 else if (strncasecmp (*s, "w", 1) == 0)
5069 {
5070 format = W;
5071 *s += 2;
5072 }
5073 else if (strncasecmp (*s, "uw", 2) == 0)
5074 {
5075 format = UW;
5076 *s += 3;
5077 }
5078 else if (strncasecmp (*s, "dw", 2) == 0)
5079 {
5080 format = DW;
5081 *s += 3;
5082 }
5083 else if (strncasecmp (*s, "udw", 3) == 0)
5084 {
5085 format = UDW;
5086 *s += 4;
5087 }
5088 else if (strncasecmp (*s, "qw", 2) == 0)
5089 {
5090 format = QW;
5091 *s += 3;
5092 }
5093 else if (strncasecmp (*s, "uqw", 3) == 0)
5094 {
5095 format = UQW;
5096 *s += 4;
5097 }
5098 else
5099 {
5100 format = ILLEGAL_FMT;
5101 as_bad (_("Invalid FP Operand Format: %3s"), *s);
5102 }
5103 }
5104
5105 return format;
5106 }
5107
5108 /* Parse an FP operand format completer returning the completer
5109 type. */
5110
5111 static fp_operand_format
5112 pa_parse_fp_format (s)
5113 char **s;
5114 {
5115 int format;
5116
5117 format = SGL;
5118 if (**s == ',')
5119 {
5120 *s += 1;
5121 if (strncasecmp (*s, "sgl", 3) == 0)
5122 {
5123 format = SGL;
5124 *s += 4;
5125 }
5126 else if (strncasecmp (*s, "dbl", 3) == 0)
5127 {
5128 format = DBL;
5129 *s += 4;
5130 }
5131 else if (strncasecmp (*s, "quad", 4) == 0)
5132 {
5133 format = QUAD;
5134 *s += 5;
5135 }
5136 else
5137 {
5138 format = ILLEGAL_FMT;
5139 as_bad (_("Invalid FP Operand Format: %3s"), *s);
5140 }
5141 }
5142
5143 return format;
5144 }
5145
5146 /* Convert from a selector string into a selector type. */
5147
5148 static int
5149 pa_chk_field_selector (str)
5150 char **str;
5151 {
5152 int middle, low, high;
5153 int cmp;
5154 char name[4];
5155
5156 /* Read past any whitespace. */
5157 /* FIXME: should we read past newlines and formfeeds??? */
5158 while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
5159 *str = *str + 1;
5160
5161 if ((*str)[1] == '\'' || (*str)[1] == '%')
5162 name[0] = TOLOWER ((*str)[0]),
5163 name[1] = 0;
5164 else if ((*str)[2] == '\'' || (*str)[2] == '%')
5165 name[0] = TOLOWER ((*str)[0]),
5166 name[1] = TOLOWER ((*str)[1]),
5167 name[2] = 0;
5168 else if ((*str)[3] == '\'' || (*str)[3] == '%')
5169 name[0] = TOLOWER ((*str)[0]),
5170 name[1] = TOLOWER ((*str)[1]),
5171 name[2] = TOLOWER ((*str)[2]),
5172 name[3] = 0;
5173 else
5174 return e_fsel;
5175
5176 low = 0;
5177 high = sizeof (selector_table) / sizeof (struct selector_entry) - 1;
5178
5179 do
5180 {
5181 middle = (low + high) / 2;
5182 cmp = strcmp (name, selector_table[middle].prefix);
5183 if (cmp < 0)
5184 high = middle - 1;
5185 else if (cmp > 0)
5186 low = middle + 1;
5187 else
5188 {
5189 *str += strlen (name) + 1;
5190 #ifndef OBJ_SOM
5191 if (selector_table[middle].field_selector == e_nsel)
5192 return e_fsel;
5193 #endif
5194 return selector_table[middle].field_selector;
5195 }
5196 }
5197 while (low <= high);
5198
5199 return e_fsel;
5200 }
5201
5202 /* Mark (via expr_end) the end of an expression (I think). FIXME. */
5203
5204 static int
5205 get_expression (str)
5206 char *str;
5207 {
5208 char *save_in;
5209 asection *seg;
5210
5211 save_in = input_line_pointer;
5212 input_line_pointer = str;
5213 seg = expression (&the_insn.exp);
5214 if (!(seg == absolute_section
5215 || seg == undefined_section
5216 || SEG_NORMAL (seg)))
5217 {
5218 as_warn (_("Bad segment in expression."));
5219 expr_end = input_line_pointer;
5220 input_line_pointer = save_in;
5221 return 1;
5222 }
5223 expr_end = input_line_pointer;
5224 input_line_pointer = save_in;
5225 return 0;
5226 }
5227
5228 /* Mark (via expr_end) the end of an absolute expression. FIXME. */
5229 static int
5230 pa_get_absolute_expression (insn, strp)
5231 struct pa_it *insn;
5232 char **strp;
5233 {
5234 char *save_in;
5235
5236 insn->field_selector = pa_chk_field_selector (strp);
5237 save_in = input_line_pointer;
5238 input_line_pointer = *strp;
5239 expression (&insn->exp);
5240 /* This is not perfect, but is a huge improvement over doing nothing.
5241
5242 The PA assembly syntax is ambiguous in a variety of ways. Consider
5243 this string "4 %r5" Is that the number 4 followed by the register
5244 r5, or is that 4 MOD r5?
5245
5246 If we get a modulo expression when looking for an absolute, we try
5247 again cutting off the input string at the first whitespace character. */
5248 if (insn->exp.X_op == O_modulus)
5249 {
5250 char *s, c;
5251 int retval;
5252
5253 input_line_pointer = *strp;
5254 s = *strp;
5255 while (*s != ',' && *s != ' ' && *s != '\t')
5256 s++;
5257
5258 c = *s;
5259 *s = 0;
5260
5261 retval = pa_get_absolute_expression (insn, strp);
5262
5263 input_line_pointer = save_in;
5264 *s = c;
5265 return evaluate_absolute (insn);
5266 }
5267 /* When in strict mode we have a non-match, fix up the pointers
5268 and return to our caller. */
5269 if (insn->exp.X_op != O_constant && strict)
5270 {
5271 expr_end = input_line_pointer;
5272 input_line_pointer = save_in;
5273 return 0;
5274 }
5275 if (insn->exp.X_op != O_constant)
5276 {
5277 as_bad (_("Bad segment (should be absolute)."));
5278 expr_end = input_line_pointer;
5279 input_line_pointer = save_in;
5280 return 0;
5281 }
5282 expr_end = input_line_pointer;
5283 input_line_pointer = save_in;
5284 return evaluate_absolute (insn);
5285 }
5286
5287 /* Evaluate an absolute expression EXP which may be modified by
5288 the selector FIELD_SELECTOR. Return the value of the expression. */
5289 static int
5290 evaluate_absolute (insn)
5291 struct pa_it *insn;
5292 {
5293 offsetT value;
5294 expressionS exp;
5295 int field_selector = insn->field_selector;
5296
5297 exp = insn->exp;
5298 value = exp.X_add_number;
5299
5300 return hppa_field_adjust (0, value, field_selector);
5301 }
5302
5303 /* Given an argument location specification return the associated
5304 argument location number. */
5305
5306 static unsigned int
5307 pa_build_arg_reloc (type_name)
5308 char *type_name;
5309 {
5310
5311 if (strncasecmp (type_name, "no", 2) == 0)
5312 return 0;
5313 if (strncasecmp (type_name, "gr", 2) == 0)
5314 return 1;
5315 else if (strncasecmp (type_name, "fr", 2) == 0)
5316 return 2;
5317 else if (strncasecmp (type_name, "fu", 2) == 0)
5318 return 3;
5319 else
5320 as_bad (_("Invalid argument location: %s\n"), type_name);
5321
5322 return 0;
5323 }
5324
5325 /* Encode and return an argument relocation specification for
5326 the given register in the location specified by arg_reloc. */
5327
5328 static unsigned int
5329 pa_align_arg_reloc (reg, arg_reloc)
5330 unsigned int reg;
5331 unsigned int arg_reloc;
5332 {
5333 unsigned int new_reloc;
5334
5335 new_reloc = arg_reloc;
5336 switch (reg)
5337 {
5338 case 0:
5339 new_reloc <<= 8;
5340 break;
5341 case 1:
5342 new_reloc <<= 6;
5343 break;
5344 case 2:
5345 new_reloc <<= 4;
5346 break;
5347 case 3:
5348 new_reloc <<= 2;
5349 break;
5350 default:
5351 as_bad (_("Invalid argument description: %d"), reg);
5352 }
5353
5354 return new_reloc;
5355 }
5356
5357 /* Parse a PA nullification completer (,n). Return nonzero if the
5358 completer was found; return zero if no completer was found. */
5359
5360 static int
5361 pa_parse_nullif (s)
5362 char **s;
5363 {
5364 int nullif;
5365
5366 nullif = 0;
5367 if (**s == ',')
5368 {
5369 *s = *s + 1;
5370 if (strncasecmp (*s, "n", 1) == 0)
5371 nullif = 1;
5372 else
5373 {
5374 as_bad (_("Invalid Nullification: (%c)"), **s);
5375 nullif = 0;
5376 }
5377 *s = *s + 1;
5378 }
5379
5380 return nullif;
5381 }
5382
5383 /* Parse a non-negated compare/subtract completer returning the
5384 number (for encoding in instructions) of the given completer. */
5385
5386 static int
5387 pa_parse_nonneg_cmpsub_cmpltr (s)
5388 char **s;
5389 {
5390 int cmpltr;
5391 char *name = *s + 1;
5392 char c;
5393 char *save_s = *s;
5394 int nullify = 0;
5395
5396 cmpltr = 0;
5397 if (**s == ',')
5398 {
5399 *s += 1;
5400 while (**s != ',' && **s != ' ' && **s != '\t')
5401 *s += 1;
5402 c = **s;
5403 **s = 0x00;
5404
5405 if (strcmp (name, "=") == 0)
5406 {
5407 cmpltr = 1;
5408 }
5409 else if (strcmp (name, "<") == 0)
5410 {
5411 cmpltr = 2;
5412 }
5413 else if (strcmp (name, "<=") == 0)
5414 {
5415 cmpltr = 3;
5416 }
5417 else if (strcmp (name, "<<") == 0)
5418 {
5419 cmpltr = 4;
5420 }
5421 else if (strcmp (name, "<<=") == 0)
5422 {
5423 cmpltr = 5;
5424 }
5425 else if (strcasecmp (name, "sv") == 0)
5426 {
5427 cmpltr = 6;
5428 }
5429 else if (strcasecmp (name, "od") == 0)
5430 {
5431 cmpltr = 7;
5432 }
5433 /* If we have something like addb,n then there is no condition
5434 completer. */
5435 else if (strcasecmp (name, "n") == 0)
5436 {
5437 cmpltr = 0;
5438 nullify = 1;
5439 }
5440 else
5441 {
5442 cmpltr = -1;
5443 }
5444 **s = c;
5445 }
5446
5447 /* Reset pointers if this was really a ,n for a branch instruction. */
5448 if (nullify)
5449 *s = save_s;
5450
5451 return cmpltr;
5452 }
5453
5454 /* Parse a negated compare/subtract completer returning the
5455 number (for encoding in instructions) of the given completer. */
5456
5457 static int
5458 pa_parse_neg_cmpsub_cmpltr (s)
5459 char **s;
5460 {
5461 int cmpltr;
5462 char *name = *s + 1;
5463 char c;
5464 char *save_s = *s;
5465 int nullify = 0;
5466
5467 cmpltr = 0;
5468 if (**s == ',')
5469 {
5470 *s += 1;
5471 while (**s != ',' && **s != ' ' && **s != '\t')
5472 *s += 1;
5473 c = **s;
5474 **s = 0x00;
5475
5476 if (strcasecmp (name, "tr") == 0)
5477 {
5478 cmpltr = 0;
5479 }
5480 else if (strcmp (name, "<>") == 0)
5481 {
5482 cmpltr = 1;
5483 }
5484 else if (strcmp (name, ">=") == 0)
5485 {
5486 cmpltr = 2;
5487 }
5488 else if (strcmp (name, ">") == 0)
5489 {
5490 cmpltr = 3;
5491 }
5492 else if (strcmp (name, ">>=") == 0)
5493 {
5494 cmpltr = 4;
5495 }
5496 else if (strcmp (name, ">>") == 0)
5497 {
5498 cmpltr = 5;
5499 }
5500 else if (strcasecmp (name, "nsv") == 0)
5501 {
5502 cmpltr = 6;
5503 }
5504 else if (strcasecmp (name, "ev") == 0)
5505 {
5506 cmpltr = 7;
5507 }
5508 /* If we have something like addb,n then there is no condition
5509 completer. */
5510 else if (strcasecmp (name, "n") == 0)
5511 {
5512 cmpltr = 0;
5513 nullify = 1;
5514 }
5515 else
5516 {
5517 cmpltr = -1;
5518 }
5519 **s = c;
5520 }
5521
5522 /* Reset pointers if this was really a ,n for a branch instruction. */
5523 if (nullify)
5524 *s = save_s;
5525
5526 return cmpltr;
5527 }
5528
5529 /* Parse a 64 bit compare and branch completer returning the number (for
5530 encoding in instructions) of the given completer.
5531
5532 Nonnegated comparisons are returned as 0-7, negated comparisons are
5533 returned as 8-15. */
5534
5535 static int
5536 pa_parse_cmpb_64_cmpltr (s)
5537 char **s;
5538 {
5539 int cmpltr;
5540 char *name = *s + 1;
5541 char c;
5542
5543 cmpltr = -1;
5544 if (**s == ',')
5545 {
5546 *s += 1;
5547 while (**s != ',' && **s != ' ' && **s != '\t')
5548 *s += 1;
5549 c = **s;
5550 **s = 0x00;
5551
5552 if (strcmp (name, "*") == 0)
5553 {
5554 cmpltr = 0;
5555 }
5556 else if (strcmp (name, "*=") == 0)
5557 {
5558 cmpltr = 1;
5559 }
5560 else if (strcmp (name, "*<") == 0)
5561 {
5562 cmpltr = 2;
5563 }
5564 else if (strcmp (name, "*<=") == 0)
5565 {
5566 cmpltr = 3;
5567 }
5568 else if (strcmp (name, "*<<") == 0)
5569 {
5570 cmpltr = 4;
5571 }
5572 else if (strcmp (name, "*<<=") == 0)
5573 {
5574 cmpltr = 5;
5575 }
5576 else if (strcasecmp (name, "*sv") == 0)
5577 {
5578 cmpltr = 6;
5579 }
5580 else if (strcasecmp (name, "*od") == 0)
5581 {
5582 cmpltr = 7;
5583 }
5584 else if (strcasecmp (name, "*tr") == 0)
5585 {
5586 cmpltr = 8;
5587 }
5588 else if (strcmp (name, "*<>") == 0)
5589 {
5590 cmpltr = 9;
5591 }
5592 else if (strcmp (name, "*>=") == 0)
5593 {
5594 cmpltr = 10;
5595 }
5596 else if (strcmp (name, "*>") == 0)
5597 {
5598 cmpltr = 11;
5599 }
5600 else if (strcmp (name, "*>>=") == 0)
5601 {
5602 cmpltr = 12;
5603 }
5604 else if (strcmp (name, "*>>") == 0)
5605 {
5606 cmpltr = 13;
5607 }
5608 else if (strcasecmp (name, "*nsv") == 0)
5609 {
5610 cmpltr = 14;
5611 }
5612 else if (strcasecmp (name, "*ev") == 0)
5613 {
5614 cmpltr = 15;
5615 }
5616 else
5617 {
5618 cmpltr = -1;
5619 }
5620 **s = c;
5621 }
5622
5623 return cmpltr;
5624 }
5625
5626 /* Parse a 64 bit compare immediate and branch completer returning the number
5627 (for encoding in instructions) of the given completer. */
5628
5629 static int
5630 pa_parse_cmpib_64_cmpltr (s)
5631 char **s;
5632 {
5633 int cmpltr;
5634 char *name = *s + 1;
5635 char c;
5636
5637 cmpltr = -1;
5638 if (**s == ',')
5639 {
5640 *s += 1;
5641 while (**s != ',' && **s != ' ' && **s != '\t')
5642 *s += 1;
5643 c = **s;
5644 **s = 0x00;
5645
5646 if (strcmp (name, "*<<") == 0)
5647 {
5648 cmpltr = 0;
5649 }
5650 else if (strcmp (name, "*=") == 0)
5651 {
5652 cmpltr = 1;
5653 }
5654 else if (strcmp (name, "*<") == 0)
5655 {
5656 cmpltr = 2;
5657 }
5658 else if (strcmp (name, "*<=") == 0)
5659 {
5660 cmpltr = 3;
5661 }
5662 else if (strcmp (name, "*>>=") == 0)
5663 {
5664 cmpltr = 4;
5665 }
5666 else if (strcmp (name, "*<>") == 0)
5667 {
5668 cmpltr = 5;
5669 }
5670 else if (strcasecmp (name, "*>=") == 0)
5671 {
5672 cmpltr = 6;
5673 }
5674 else if (strcasecmp (name, "*>") == 0)
5675 {
5676 cmpltr = 7;
5677 }
5678 else
5679 {
5680 cmpltr = -1;
5681 }
5682 **s = c;
5683 }
5684
5685 return cmpltr;
5686 }
5687
5688 /* Parse a non-negated addition completer returning the number
5689 (for encoding in instructions) of the given completer. */
5690
5691 static int
5692 pa_parse_nonneg_add_cmpltr (s)
5693 char **s;
5694 {
5695 int cmpltr;
5696 char *name = *s + 1;
5697 char c;
5698 char *save_s = *s;
5699 int nullify = 0;
5700
5701 cmpltr = 0;
5702 if (**s == ',')
5703 {
5704 *s += 1;
5705 while (**s != ',' && **s != ' ' && **s != '\t')
5706 *s += 1;
5707 c = **s;
5708 **s = 0x00;
5709 if (strcmp (name, "=") == 0)
5710 {
5711 cmpltr = 1;
5712 }
5713 else if (strcmp (name, "<") == 0)
5714 {
5715 cmpltr = 2;
5716 }
5717 else if (strcmp (name, "<=") == 0)
5718 {
5719 cmpltr = 3;
5720 }
5721 else if (strcasecmp (name, "nuv") == 0)
5722 {
5723 cmpltr = 4;
5724 }
5725 else if (strcasecmp (name, "znv") == 0)
5726 {
5727 cmpltr = 5;
5728 }
5729 else if (strcasecmp (name, "sv") == 0)
5730 {
5731 cmpltr = 6;
5732 }
5733 else if (strcasecmp (name, "od") == 0)
5734 {
5735 cmpltr = 7;
5736 }
5737 /* If we have something like addb,n then there is no condition
5738 completer. */
5739 else if (strcasecmp (name, "n") == 0)
5740 {
5741 cmpltr = 0;
5742 nullify = 1;
5743 }
5744 else
5745 {
5746 cmpltr = -1;
5747 }
5748 **s = c;
5749 }
5750
5751 /* Reset pointers if this was really a ,n for a branch instruction. */
5752 if (nullify)
5753 *s = save_s;
5754
5755 return cmpltr;
5756 }
5757
5758 /* Parse a negated addition completer returning the number
5759 (for encoding in instructions) of the given completer. */
5760
5761 static int
5762 pa_parse_neg_add_cmpltr (s)
5763 char **s;
5764 {
5765 int cmpltr;
5766 char *name = *s + 1;
5767 char c;
5768 char *save_s = *s;
5769 int nullify = 0;
5770
5771 cmpltr = 0;
5772 if (**s == ',')
5773 {
5774 *s += 1;
5775 while (**s != ',' && **s != ' ' && **s != '\t')
5776 *s += 1;
5777 c = **s;
5778 **s = 0x00;
5779 if (strcasecmp (name, "tr") == 0)
5780 {
5781 cmpltr = 0;
5782 }
5783 else if (strcmp (name, "<>") == 0)
5784 {
5785 cmpltr = 1;
5786 }
5787 else if (strcmp (name, ">=") == 0)
5788 {
5789 cmpltr = 2;
5790 }
5791 else if (strcmp (name, ">") == 0)
5792 {
5793 cmpltr = 3;
5794 }
5795 else if (strcasecmp (name, "uv") == 0)
5796 {
5797 cmpltr = 4;
5798 }
5799 else if (strcasecmp (name, "vnz") == 0)
5800 {
5801 cmpltr = 5;
5802 }
5803 else if (strcasecmp (name, "nsv") == 0)
5804 {
5805 cmpltr = 6;
5806 }
5807 else if (strcasecmp (name, "ev") == 0)
5808 {
5809 cmpltr = 7;
5810 }
5811 /* If we have something like addb,n then there is no condition
5812 completer. */
5813 else if (strcasecmp (name, "n") == 0)
5814 {
5815 cmpltr = 0;
5816 nullify = 1;
5817 }
5818 else
5819 {
5820 cmpltr = -1;
5821 }
5822 **s = c;
5823 }
5824
5825 /* Reset pointers if this was really a ,n for a branch instruction. */
5826 if (nullify)
5827 *s = save_s;
5828
5829 return cmpltr;
5830 }
5831
5832 /* Parse a 64 bit wide mode add and branch completer returning the number (for
5833 encoding in instructions) of the given completer. */
5834
5835 static int
5836 pa_parse_addb_64_cmpltr (s)
5837 char **s;
5838 {
5839 int cmpltr;
5840 char *name = *s + 1;
5841 char c;
5842 char *save_s = *s;
5843 int nullify = 0;
5844
5845 cmpltr = 0;
5846 if (**s == ',')
5847 {
5848 *s += 1;
5849 while (**s != ',' && **s != ' ' && **s != '\t')
5850 *s += 1;
5851 c = **s;
5852 **s = 0x00;
5853 if (strcmp (name, "=") == 0)
5854 {
5855 cmpltr = 1;
5856 }
5857 else if (strcmp (name, "<") == 0)
5858 {
5859 cmpltr = 2;
5860 }
5861 else if (strcmp (name, "<=") == 0)
5862 {
5863 cmpltr = 3;
5864 }
5865 else if (strcasecmp (name, "nuv") == 0)
5866 {
5867 cmpltr = 4;
5868 }
5869 else if (strcasecmp (name, "*=") == 0)
5870 {
5871 cmpltr = 5;
5872 }
5873 else if (strcasecmp (name, "*<") == 0)
5874 {
5875 cmpltr = 6;
5876 }
5877 else if (strcasecmp (name, "*<=") == 0)
5878 {
5879 cmpltr = 7;
5880 }
5881 else if (strcmp (name, "tr") == 0)
5882 {
5883 cmpltr = 8;
5884 }
5885 else if (strcmp (name, "<>") == 0)
5886 {
5887 cmpltr = 9;
5888 }
5889 else if (strcmp (name, ">=") == 0)
5890 {
5891 cmpltr = 10;
5892 }
5893 else if (strcmp (name, ">") == 0)
5894 {
5895 cmpltr = 11;
5896 }
5897 else if (strcasecmp (name, "uv") == 0)
5898 {
5899 cmpltr = 12;
5900 }
5901 else if (strcasecmp (name, "*<>") == 0)
5902 {
5903 cmpltr = 13;
5904 }
5905 else if (strcasecmp (name, "*>=") == 0)
5906 {
5907 cmpltr = 14;
5908 }
5909 else if (strcasecmp (name, "*>") == 0)
5910 {
5911 cmpltr = 15;
5912 }
5913 /* If we have something like addb,n then there is no condition
5914 completer. */
5915 else if (strcasecmp (name, "n") == 0)
5916 {
5917 cmpltr = 0;
5918 nullify = 1;
5919 }
5920 else
5921 {
5922 cmpltr = -1;
5923 }
5924 **s = c;
5925 }
5926
5927 /* Reset pointers if this was really a ,n for a branch instruction. */
5928 if (nullify)
5929 *s = save_s;
5930
5931 return cmpltr;
5932 }
5933
5934 #ifdef OBJ_SOM
5935 /* Handle an alignment directive. Special so that we can update the
5936 alignment of the subspace if necessary. */
5937 static void
5938 pa_align (bytes)
5939 int bytes;
5940 {
5941 /* We must have a valid space and subspace. */
5942 pa_check_current_space_and_subspace ();
5943
5944 /* Let the generic gas code do most of the work. */
5945 s_align_bytes (bytes);
5946
5947 /* If bytes is a power of 2, then update the current subspace's
5948 alignment if necessary. */
5949 if (exact_log2 (bytes) != -1)
5950 record_alignment (current_subspace->ssd_seg, exact_log2 (bytes));
5951 }
5952 #endif
5953
5954 /* Handle a .BLOCK type pseudo-op. */
5955
5956 static void
5957 pa_block (z)
5958 int z ATTRIBUTE_UNUSED;
5959 {
5960 unsigned int temp_size;
5961
5962 #ifdef OBJ_SOM
5963 /* We must have a valid space and subspace. */
5964 pa_check_current_space_and_subspace ();
5965 #endif
5966
5967 temp_size = get_absolute_expression ();
5968
5969 if (temp_size > 0x3FFFFFFF)
5970 {
5971 as_bad (_("Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff"));
5972 temp_size = 0;
5973 }
5974 else
5975 {
5976 /* Always fill with zeros, that's what the HP assembler does. */
5977 char *p = frag_var (rs_fill, 1, 1, 0, NULL, temp_size, NULL);
5978 *p = 0;
5979 }
5980
5981 pa_undefine_label ();
5982 demand_empty_rest_of_line ();
5983 }
5984
5985 /* Handle a .begin_brtab and .end_brtab pseudo-op. */
5986
5987 static void
5988 pa_brtab (begin)
5989 int begin ATTRIBUTE_UNUSED;
5990 {
5991
5992 #ifdef OBJ_SOM
5993 /* The BRTAB relocations are only available in SOM (to denote
5994 the beginning and end of branch tables). */
5995 char *where = frag_more (0);
5996
5997 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5998 NULL, (offsetT) 0, NULL,
5999 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
6000 e_fsel, 0, 0, 0);
6001 #endif
6002
6003 demand_empty_rest_of_line ();
6004 }
6005
6006 /* Handle a .begin_try and .end_try pseudo-op. */
6007
6008 static void
6009 pa_try (begin)
6010 int begin ATTRIBUTE_UNUSED;
6011 {
6012 #ifdef OBJ_SOM
6013 expressionS exp;
6014 char *where = frag_more (0);
6015
6016 if (! begin)
6017 expression (&exp);
6018
6019 /* The TRY relocations are only available in SOM (to denote
6020 the beginning and end of exception handling regions). */
6021
6022 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6023 NULL, (offsetT) 0, begin ? NULL : &exp,
6024 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
6025 e_fsel, 0, 0, 0);
6026 #endif
6027
6028 demand_empty_rest_of_line ();
6029 }
6030
6031 /* Handle a .CALL pseudo-op. This involves storing away information
6032 about where arguments are to be found so the linker can detect
6033 (and correct) argument location mismatches between caller and callee. */
6034
6035 static void
6036 pa_call (unused)
6037 int unused ATTRIBUTE_UNUSED;
6038 {
6039 #ifdef OBJ_SOM
6040 /* We must have a valid space and subspace. */
6041 pa_check_current_space_and_subspace ();
6042 #endif
6043
6044 pa_call_args (&last_call_desc);
6045 demand_empty_rest_of_line ();
6046 }
6047
6048 /* Do the dirty work of building a call descriptor which describes
6049 where the caller placed arguments to a function call. */
6050
6051 static void
6052 pa_call_args (call_desc)
6053 struct call_desc *call_desc;
6054 {
6055 char *name, c, *p;
6056 unsigned int temp, arg_reloc;
6057
6058 while (!is_end_of_statement ())
6059 {
6060 name = input_line_pointer;
6061 c = get_symbol_end ();
6062 /* Process a source argument. */
6063 if ((strncasecmp (name, "argw", 4) == 0))
6064 {
6065 temp = atoi (name + 4);
6066 p = input_line_pointer;
6067 *p = c;
6068 input_line_pointer++;
6069 name = input_line_pointer;
6070 c = get_symbol_end ();
6071 arg_reloc = pa_build_arg_reloc (name);
6072 call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
6073 }
6074 /* Process a return value. */
6075 else if ((strncasecmp (name, "rtnval", 6) == 0))
6076 {
6077 p = input_line_pointer;
6078 *p = c;
6079 input_line_pointer++;
6080 name = input_line_pointer;
6081 c = get_symbol_end ();
6082 arg_reloc = pa_build_arg_reloc (name);
6083 call_desc->arg_reloc |= (arg_reloc & 0x3);
6084 }
6085 else
6086 {
6087 as_bad (_("Invalid .CALL argument: %s"), name);
6088 }
6089 p = input_line_pointer;
6090 *p = c;
6091 if (!is_end_of_statement ())
6092 input_line_pointer++;
6093 }
6094 }
6095
6096 /* Return TRUE if FRAG1 and FRAG2 are the same. */
6097
6098 static int
6099 is_same_frag (frag1, frag2)
6100 fragS *frag1;
6101 fragS *frag2;
6102 {
6103
6104 if (frag1 == NULL)
6105 return (FALSE);
6106 else if (frag2 == NULL)
6107 return (FALSE);
6108 else if (frag1 == frag2)
6109 return (TRUE);
6110 else if (frag2->fr_type == rs_fill && frag2->fr_fix == 0)
6111 return (is_same_frag (frag1, frag2->fr_next));
6112 else
6113 return (FALSE);
6114 }
6115
6116 #ifdef OBJ_ELF
6117 /* Build an entry in the UNWIND subspace from the given function
6118 attributes in CALL_INFO. This is not needed for SOM as using
6119 R_ENTRY and R_EXIT relocations allow the linker to handle building
6120 of the unwind spaces. */
6121
6122 static void
6123 pa_build_unwind_subspace (call_info)
6124 struct call_info *call_info;
6125 {
6126 asection *seg, *save_seg;
6127 subsegT save_subseg;
6128 unsigned int unwind;
6129 int reloc;
6130 char *p;
6131
6132 if ((bfd_get_section_flags (stdoutput, now_seg)
6133 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
6134 != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
6135 return;
6136
6137 reloc = R_PARISC_SEGREL32;
6138 save_seg = now_seg;
6139 save_subseg = now_subseg;
6140 /* Get into the right seg/subseg. This may involve creating
6141 the seg the first time through. Make sure to have the
6142 old seg/subseg so that we can reset things when we are done. */
6143 seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6144 if (seg == ASEC_NULL)
6145 {
6146 seg = subseg_new (UNWIND_SECTION_NAME, 0);
6147 bfd_set_section_flags (stdoutput, seg,
6148 SEC_READONLY | SEC_HAS_CONTENTS
6149 | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6150 bfd_set_section_alignment (stdoutput, seg, 2);
6151 }
6152
6153 subseg_set (seg, 0);
6154
6155 /* Get some space to hold relocation information for the unwind
6156 descriptor. */
6157 p = frag_more (16);
6158
6159 /* Relocation info. for start offset of the function. */
6160 md_number_to_chars (p, 0, 4);
6161 fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6162 call_info->start_symbol, (offsetT) 0,
6163 (expressionS *) NULL, 0, reloc,
6164 e_fsel, 32, 0, 0);
6165
6166 /* Relocation info. for end offset of the function.
6167
6168 Because we allow reductions of 32bit relocations for ELF, this will be
6169 reduced to section_sym + offset which avoids putting the temporary
6170 symbol into the symbol table. It (should) end up giving the same
6171 value as call_info->start_symbol + function size once the linker is
6172 finished with its work. */
6173 md_number_to_chars (p + 4, 0, 4);
6174 fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
6175 call_info->end_symbol, (offsetT) 0,
6176 (expressionS *) NULL, 0, reloc,
6177 e_fsel, 32, 0, 0);
6178
6179 /* Dump the descriptor. */
6180 unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6181 md_number_to_chars (p + 8, unwind, 4);
6182
6183 unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6184 md_number_to_chars (p + 12, unwind, 4);
6185
6186 /* Return back to the original segment/subsegment. */
6187 subseg_set (save_seg, save_subseg);
6188 }
6189 #endif
6190
6191 /* Process a .CALLINFO pseudo-op. This information is used later
6192 to build unwind descriptors and maybe one day to support
6193 .ENTER and .LEAVE. */
6194
6195 static void
6196 pa_callinfo (unused)
6197 int unused ATTRIBUTE_UNUSED;
6198 {
6199 char *name, c, *p;
6200 int temp;
6201
6202 #ifdef OBJ_SOM
6203 /* We must have a valid space and subspace. */
6204 pa_check_current_space_and_subspace ();
6205 #endif
6206
6207 /* .CALLINFO must appear within a procedure definition. */
6208 if (!within_procedure)
6209 as_bad (_(".callinfo is not within a procedure definition"));
6210
6211 /* Mark the fact that we found the .CALLINFO for the
6212 current procedure. */
6213 callinfo_found = TRUE;
6214
6215 /* Iterate over the .CALLINFO arguments. */
6216 while (!is_end_of_statement ())
6217 {
6218 name = input_line_pointer;
6219 c = get_symbol_end ();
6220 /* Frame size specification. */
6221 if ((strncasecmp (name, "frame", 5) == 0))
6222 {
6223 p = input_line_pointer;
6224 *p = c;
6225 input_line_pointer++;
6226 temp = get_absolute_expression ();
6227 if ((temp & 0x3) != 0)
6228 {
6229 as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6230 temp = 0;
6231 }
6232
6233 /* callinfo is in bytes and unwind_desc is in 8 byte units. */
6234 last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6235
6236 }
6237 /* Entry register (GR, GR and SR) specifications. */
6238 else if ((strncasecmp (name, "entry_gr", 8) == 0))
6239 {
6240 p = input_line_pointer;
6241 *p = c;
6242 input_line_pointer++;
6243 temp = get_absolute_expression ();
6244 /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6245 even though %r19 is caller saved. I think this is a bug in
6246 the HP assembler, and we are not going to emulate it. */
6247 if (temp < 3 || temp > 18)
6248 as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6249 last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6250 }
6251 else if ((strncasecmp (name, "entry_fr", 8) == 0))
6252 {
6253 p = input_line_pointer;
6254 *p = c;
6255 input_line_pointer++;
6256 temp = get_absolute_expression ();
6257 /* Similarly the HP assembler takes 31 as the high bound even
6258 though %fr21 is the last callee saved floating point register. */
6259 if (temp < 12 || temp > 21)
6260 as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6261 last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6262 }
6263 else if ((strncasecmp (name, "entry_sr", 8) == 0))
6264 {
6265 p = input_line_pointer;
6266 *p = c;
6267 input_line_pointer++;
6268 temp = get_absolute_expression ();
6269 if (temp != 3)
6270 as_bad (_("Value for ENTRY_SR must be 3\n"));
6271 }
6272 /* Note whether or not this function performs any calls. */
6273 else if ((strncasecmp (name, "calls", 5) == 0) ||
6274 (strncasecmp (name, "caller", 6) == 0))
6275 {
6276 p = input_line_pointer;
6277 *p = c;
6278 }
6279 else if ((strncasecmp (name, "no_calls", 8) == 0))
6280 {
6281 p = input_line_pointer;
6282 *p = c;
6283 }
6284 /* Should RP be saved into the stack. */
6285 else if ((strncasecmp (name, "save_rp", 7) == 0))
6286 {
6287 p = input_line_pointer;
6288 *p = c;
6289 last_call_info->ci_unwind.descriptor.save_rp = 1;
6290 }
6291 /* Likewise for SP. */
6292 else if ((strncasecmp (name, "save_sp", 7) == 0))
6293 {
6294 p = input_line_pointer;
6295 *p = c;
6296 last_call_info->ci_unwind.descriptor.save_sp = 1;
6297 }
6298 /* Is this an unwindable procedure. If so mark it so
6299 in the unwind descriptor. */
6300 else if ((strncasecmp (name, "no_unwind", 9) == 0))
6301 {
6302 p = input_line_pointer;
6303 *p = c;
6304 last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6305 }
6306 /* Is this an interrupt routine. If so mark it in the
6307 unwind descriptor. */
6308 else if ((strncasecmp (name, "hpux_int", 7) == 0))
6309 {
6310 p = input_line_pointer;
6311 *p = c;
6312 last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6313 }
6314 /* Is this a millicode routine. "millicode" isn't in my
6315 assembler manual, but my copy is old. The HP assembler
6316 accepts it, and there's a place in the unwind descriptor
6317 to drop the information, so we'll accept it too. */
6318 else if ((strncasecmp (name, "millicode", 9) == 0))
6319 {
6320 p = input_line_pointer;
6321 *p = c;
6322 last_call_info->ci_unwind.descriptor.millicode = 1;
6323 }
6324 else
6325 {
6326 as_bad (_("Invalid .CALLINFO argument: %s"), name);
6327 *input_line_pointer = c;
6328 }
6329 if (!is_end_of_statement ())
6330 input_line_pointer++;
6331 }
6332
6333 demand_empty_rest_of_line ();
6334 }
6335
6336 #if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
6337 /* Switch to the text space. Like s_text, but delete our
6338 label when finished. */
6339 static void
6340 pa_text (unused)
6341 int unused ATTRIBUTE_UNUSED;
6342 {
6343 #ifdef OBJ_SOM
6344 current_space = is_defined_space ("$TEXT$");
6345 current_subspace
6346 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6347 #endif
6348
6349 s_text (0);
6350 pa_undefine_label ();
6351 }
6352
6353 /* Switch to the data space. As usual delete our label. */
6354 static void
6355 pa_data (unused)
6356 int unused ATTRIBUTE_UNUSED;
6357 {
6358 #ifdef OBJ_SOM
6359 current_space = is_defined_space ("$PRIVATE$");
6360 current_subspace
6361 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6362 #endif
6363 s_data (0);
6364 pa_undefine_label ();
6365 }
6366
6367 /* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6368 the .comm pseudo-op has the following symtax:
6369
6370 <label> .comm <length>
6371
6372 where <label> is optional and is a symbol whose address will be the start of
6373 a block of memory <length> bytes long. <length> must be an absolute
6374 expression. <length> bytes will be allocated in the current space
6375 and subspace.
6376
6377 Also note the label may not even be on the same line as the .comm.
6378
6379 This difference in syntax means the colon function will be called
6380 on the symbol before we arrive in pa_comm. colon will set a number
6381 of attributes of the symbol that need to be fixed here. In particular
6382 the value, section pointer, fragment pointer, flags, etc. What
6383 a pain.
6384
6385 This also makes error detection all but impossible. */
6386
6387 static void
6388 pa_comm (unused)
6389 int unused ATTRIBUTE_UNUSED;
6390 {
6391 unsigned int size;
6392 symbolS *symbol;
6393 label_symbol_struct *label_symbol = pa_get_label ();
6394
6395 if (label_symbol)
6396 symbol = label_symbol->lss_label;
6397 else
6398 symbol = NULL;
6399
6400 SKIP_WHITESPACE ();
6401 size = get_absolute_expression ();
6402
6403 if (symbol)
6404 {
6405 symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
6406 S_SET_VALUE (symbol, size);
6407 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6408 S_SET_EXTERNAL (symbol);
6409
6410 /* colon() has already set the frag to the current location in the
6411 current subspace; we need to reset the fragment to the zero address
6412 fragment. We also need to reset the segment pointer. */
6413 symbol_set_frag (symbol, &zero_address_frag);
6414 }
6415 demand_empty_rest_of_line ();
6416 }
6417 #endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
6418
6419 /* Process a .END pseudo-op. */
6420
6421 static void
6422 pa_end (unused)
6423 int unused ATTRIBUTE_UNUSED;
6424 {
6425 demand_empty_rest_of_line ();
6426 }
6427
6428 /* Process a .ENTER pseudo-op. This is not supported. */
6429 static void
6430 pa_enter (unused)
6431 int unused ATTRIBUTE_UNUSED;
6432 {
6433 #ifdef OBJ_SOM
6434 /* We must have a valid space and subspace. */
6435 pa_check_current_space_and_subspace ();
6436 #endif
6437
6438 as_bad (_("The .ENTER pseudo-op is not supported"));
6439 demand_empty_rest_of_line ();
6440 }
6441
6442 /* Process a .ENTRY pseudo-op. .ENTRY marks the beginning of the
6443 procedure. */
6444 static void
6445 pa_entry (unused)
6446 int unused ATTRIBUTE_UNUSED;
6447 {
6448 #ifdef OBJ_SOM
6449 /* We must have a valid space and subspace. */
6450 pa_check_current_space_and_subspace ();
6451 #endif
6452
6453 if (!within_procedure)
6454 as_bad (_("Misplaced .entry. Ignored."));
6455 else
6456 {
6457 if (!callinfo_found)
6458 as_bad (_("Missing .callinfo."));
6459 }
6460 demand_empty_rest_of_line ();
6461 within_entry_exit = TRUE;
6462
6463 #ifdef OBJ_SOM
6464 /* SOM defers building of unwind descriptors until the link phase.
6465 The assembler is responsible for creating an R_ENTRY relocation
6466 to mark the beginning of a region and hold the unwind bits, and
6467 for creating an R_EXIT relocation to mark the end of the region.
6468
6469 FIXME. ELF should be using the same conventions! The problem
6470 is an unwind requires too much relocation space. Hmmm. Maybe
6471 if we split the unwind bits up between the relocations which
6472 denote the entry and exit points. */
6473 if (last_call_info->start_symbol != NULL)
6474 {
6475 char *where;
6476 unsigned int u;
6477
6478 where = frag_more (0);
6479 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
6480 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6481 NULL, (offsetT) 0, NULL,
6482 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
6483 }
6484 #endif
6485 }
6486
6487 /* Silly nonsense for pa_equ. The only half-sensible use for this is
6488 being able to subtract two register symbols that specify a range of
6489 registers, to get the size of the range. */
6490 static int fudge_reg_expressions;
6491
6492 int
6493 hppa_force_reg_syms_absolute (resultP, op, rightP)
6494 expressionS *resultP;
6495 operatorT op ATTRIBUTE_UNUSED;
6496 expressionS *rightP;
6497 {
6498 if (fudge_reg_expressions
6499 && rightP->X_op == O_register
6500 && resultP->X_op == O_register)
6501 {
6502 rightP->X_op = O_constant;
6503 resultP->X_op = O_constant;
6504 }
6505 return 0; /* Continue normal expr handling. */
6506 }
6507
6508 /* Handle a .EQU pseudo-op. */
6509
6510 static void
6511 pa_equ (reg)
6512 int reg;
6513 {
6514 label_symbol_struct *label_symbol = pa_get_label ();
6515 symbolS *symbol;
6516
6517 if (label_symbol)
6518 {
6519 symbol = label_symbol->lss_label;
6520 if (reg)
6521 {
6522 strict = 1;
6523 if (!pa_parse_number (&input_line_pointer, 0))
6524 as_bad (_(".REG expression must be a register"));
6525 S_SET_VALUE (symbol, pa_number);
6526 S_SET_SEGMENT (symbol, reg_section);
6527 }
6528 else
6529 {
6530 expressionS exp;
6531 segT seg;
6532
6533 fudge_reg_expressions = 1;
6534 seg = expression (&exp);
6535 fudge_reg_expressions = 0;
6536 if (exp.X_op != O_constant
6537 && exp.X_op != O_register)
6538 {
6539 if (exp.X_op != O_absent)
6540 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6541 exp.X_add_number = 0;
6542 seg = absolute_section;
6543 }
6544 S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6545 S_SET_SEGMENT (symbol, seg);
6546 }
6547 }
6548 else
6549 {
6550 if (reg)
6551 as_bad (_(".REG must use a label"));
6552 else
6553 as_bad (_(".EQU must use a label"));
6554 }
6555
6556 pa_undefine_label ();
6557 demand_empty_rest_of_line ();
6558 }
6559
6560 /* Helper function. Does processing for the end of a function. This
6561 usually involves creating some relocations or building special
6562 symbols to mark the end of the function. */
6563
6564 static void
6565 process_exit ()
6566 {
6567 char *where;
6568
6569 where = frag_more (0);
6570
6571 #ifdef OBJ_ELF
6572 /* Mark the end of the function, stuff away the location of the frag
6573 for the end of the function, and finally call pa_build_unwind_subspace
6574 to add an entry in the unwind table. */
6575 hppa_elf_mark_end_of_function ();
6576 pa_build_unwind_subspace (last_call_info);
6577 #else
6578 /* SOM defers building of unwind descriptors until the link phase.
6579 The assembler is responsible for creating an R_ENTRY relocation
6580 to mark the beginning of a region and hold the unwind bits, and
6581 for creating an R_EXIT relocation to mark the end of the region.
6582
6583 FIXME. ELF should be using the same conventions! The problem
6584 is an unwind requires too much relocation space. Hmmm. Maybe
6585 if we split the unwind bits up between the relocations which
6586 denote the entry and exit points. */
6587 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6588 NULL, (offsetT) 0,
6589 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
6590 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
6591 #endif
6592 }
6593
6594 /* Process a .EXIT pseudo-op. */
6595
6596 static void
6597 pa_exit (unused)
6598 int unused ATTRIBUTE_UNUSED;
6599 {
6600 #ifdef OBJ_SOM
6601 /* We must have a valid space and subspace. */
6602 pa_check_current_space_and_subspace ();
6603 #endif
6604
6605 if (!within_procedure)
6606 as_bad (_(".EXIT must appear within a procedure"));
6607 else
6608 {
6609 if (!callinfo_found)
6610 as_bad (_("Missing .callinfo"));
6611 else
6612 {
6613 if (!within_entry_exit)
6614 as_bad (_("No .ENTRY for this .EXIT"));
6615 else
6616 {
6617 within_entry_exit = FALSE;
6618 process_exit ();
6619 }
6620 }
6621 }
6622 demand_empty_rest_of_line ();
6623 }
6624
6625 /* Process a .EXPORT directive. This makes functions external
6626 and provides information such as argument relocation entries
6627 to callers. */
6628
6629 static void
6630 pa_export (unused)
6631 int unused ATTRIBUTE_UNUSED;
6632 {
6633 char *name, c, *p;
6634 symbolS *symbol;
6635
6636 name = input_line_pointer;
6637 c = get_symbol_end ();
6638 /* Make sure the given symbol exists. */
6639 if ((symbol = symbol_find_or_make (name)) == NULL)
6640 {
6641 as_bad (_("Cannot define export symbol: %s\n"), name);
6642 p = input_line_pointer;
6643 *p = c;
6644 input_line_pointer++;
6645 }
6646 else
6647 {
6648 /* OK. Set the external bits and process argument relocations.
6649 For the HP, weak and global are not mutually exclusive.
6650 S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6651 Call S_SET_EXTERNAL to get the other processing. Manually
6652 set BSF_GLOBAL when we get back. */
6653 S_SET_EXTERNAL (symbol);
6654 symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
6655 p = input_line_pointer;
6656 *p = c;
6657 if (!is_end_of_statement ())
6658 {
6659 input_line_pointer++;
6660 pa_type_args (symbol, 1);
6661 }
6662 }
6663
6664 demand_empty_rest_of_line ();
6665 }
6666
6667 /* Helper function to process arguments to a .EXPORT pseudo-op. */
6668
6669 static void
6670 pa_type_args (symbolP, is_export)
6671 symbolS *symbolP;
6672 int is_export;
6673 {
6674 char *name, c, *p;
6675 unsigned int temp, arg_reloc;
6676 pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
6677 asymbol *bfdsym = symbol_get_bfdsym (symbolP);
6678
6679 if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6680
6681 {
6682 input_line_pointer += 8;
6683 bfdsym->flags &= ~BSF_FUNCTION;
6684 S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6685 type = SYMBOL_TYPE_ABSOLUTE;
6686 }
6687 else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6688 {
6689 input_line_pointer += 4;
6690 /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6691 instead one should be IMPORTing/EXPORTing ENTRY types.
6692
6693 Complain if one tries to EXPORT a CODE type since that's never
6694 done. Both GCC and HP C still try to IMPORT CODE types, so
6695 silently fix them to be ENTRY types. */
6696 if (S_IS_FUNCTION (symbolP))
6697 {
6698 if (is_export)
6699 as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6700 S_GET_NAME (symbolP));
6701
6702 bfdsym->flags |= BSF_FUNCTION;
6703 type = SYMBOL_TYPE_ENTRY;
6704 }
6705 else
6706 {
6707 bfdsym->flags &= ~BSF_FUNCTION;
6708 type = SYMBOL_TYPE_CODE;
6709 }
6710 }
6711 else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6712 {
6713 input_line_pointer += 4;
6714 bfdsym->flags &= ~BSF_FUNCTION;
6715 bfdsym->flags |= BSF_OBJECT;
6716 type = SYMBOL_TYPE_DATA;
6717 }
6718 else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6719 {
6720 input_line_pointer += 5;
6721 bfdsym->flags |= BSF_FUNCTION;
6722 type = SYMBOL_TYPE_ENTRY;
6723 }
6724 else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6725 {
6726 input_line_pointer += 9;
6727 bfdsym->flags |= BSF_FUNCTION;
6728 #ifdef OBJ_ELF
6729 {
6730 elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6731 elfsym->internal_elf_sym.st_info =
6732 ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6733 STT_PARISC_MILLI);
6734 }
6735 #endif
6736 type = SYMBOL_TYPE_MILLICODE;
6737 }
6738 else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6739 {
6740 input_line_pointer += 6;
6741 bfdsym->flags &= ~BSF_FUNCTION;
6742 type = SYMBOL_TYPE_PLABEL;
6743 }
6744 else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6745 {
6746 input_line_pointer += 8;
6747 bfdsym->flags |= BSF_FUNCTION;
6748 type = SYMBOL_TYPE_PRI_PROG;
6749 }
6750 else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6751 {
6752 input_line_pointer += 8;
6753 bfdsym->flags |= BSF_FUNCTION;
6754 type = SYMBOL_TYPE_SEC_PROG;
6755 }
6756
6757 /* SOM requires much more information about symbol types
6758 than BFD understands. This is how we get this information
6759 to the SOM BFD backend. */
6760 #ifdef obj_set_symbol_type
6761 obj_set_symbol_type (bfdsym, (int) type);
6762 #endif
6763
6764 /* Now that the type of the exported symbol has been handled,
6765 handle any argument relocation information. */
6766 while (!is_end_of_statement ())
6767 {
6768 if (*input_line_pointer == ',')
6769 input_line_pointer++;
6770 name = input_line_pointer;
6771 c = get_symbol_end ();
6772 /* Argument sources. */
6773 if ((strncasecmp (name, "argw", 4) == 0))
6774 {
6775 p = input_line_pointer;
6776 *p = c;
6777 input_line_pointer++;
6778 temp = atoi (name + 4);
6779 name = input_line_pointer;
6780 c = get_symbol_end ();
6781 arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
6782 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6783 symbol_arg_reloc_info (symbolP) |= arg_reloc;
6784 #endif
6785 *input_line_pointer = c;
6786 }
6787 /* The return value. */
6788 else if ((strncasecmp (name, "rtnval", 6)) == 0)
6789 {
6790 p = input_line_pointer;
6791 *p = c;
6792 input_line_pointer++;
6793 name = input_line_pointer;
6794 c = get_symbol_end ();
6795 arg_reloc = pa_build_arg_reloc (name);
6796 #if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
6797 symbol_arg_reloc_info (symbolP) |= arg_reloc;
6798 #endif
6799 *input_line_pointer = c;
6800 }
6801 /* Privilege level. */
6802 else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6803 {
6804 p = input_line_pointer;
6805 *p = c;
6806 input_line_pointer++;
6807 temp = atoi (input_line_pointer);
6808 #ifdef OBJ_SOM
6809 ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
6810 #endif
6811 c = get_symbol_end ();
6812 *input_line_pointer = c;
6813 }
6814 else
6815 {
6816 as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6817 p = input_line_pointer;
6818 *p = c;
6819 }
6820 if (!is_end_of_statement ())
6821 input_line_pointer++;
6822 }
6823 }
6824
6825 /* Handle an .IMPORT pseudo-op. Any symbol referenced in a given
6826 assembly file must either be defined in the assembly file, or
6827 explicitly IMPORTED from another. */
6828
6829 static void
6830 pa_import (unused)
6831 int unused ATTRIBUTE_UNUSED;
6832 {
6833 char *name, c, *p;
6834 symbolS *symbol;
6835
6836 name = input_line_pointer;
6837 c = get_symbol_end ();
6838
6839 symbol = symbol_find (name);
6840 /* Ugh. We might be importing a symbol defined earlier in the file,
6841 in which case all the code below will really screw things up
6842 (set the wrong segment, symbol flags & type, etc). */
6843 if (symbol == NULL || !S_IS_DEFINED (symbol))
6844 {
6845 symbol = symbol_find_or_make (name);
6846 p = input_line_pointer;
6847 *p = c;
6848
6849 if (!is_end_of_statement ())
6850 {
6851 input_line_pointer++;
6852 pa_type_args (symbol, 0);
6853 }
6854 else
6855 {
6856 /* Sigh. To be compatible with the HP assembler and to help
6857 poorly written assembly code, we assign a type based on
6858 the current segment. Note only BSF_FUNCTION really
6859 matters, we do not need to set the full SYMBOL_TYPE_* info. */
6860 if (now_seg == text_section)
6861 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
6862
6863 /* If the section is undefined, then the symbol is undefined
6864 Since this is an import, leave the section undefined. */
6865 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6866 }
6867 }
6868 else
6869 {
6870 /* The symbol was already defined. Just eat everything up to
6871 the end of the current statement. */
6872 while (!is_end_of_statement ())
6873 input_line_pointer++;
6874 }
6875
6876 demand_empty_rest_of_line ();
6877 }
6878
6879 /* Handle a .LABEL pseudo-op. */
6880
6881 static void
6882 pa_label (unused)
6883 int unused ATTRIBUTE_UNUSED;
6884 {
6885 char *name, c, *p;
6886
6887 name = input_line_pointer;
6888 c = get_symbol_end ();
6889
6890 if (strlen (name) > 0)
6891 {
6892 colon (name);
6893 p = input_line_pointer;
6894 *p = c;
6895 }
6896 else
6897 {
6898 as_warn (_("Missing label name on .LABEL"));
6899 }
6900
6901 if (!is_end_of_statement ())
6902 {
6903 as_warn (_("extra .LABEL arguments ignored."));
6904 ignore_rest_of_line ();
6905 }
6906 demand_empty_rest_of_line ();
6907 }
6908
6909 /* Handle a .LEAVE pseudo-op. This is not supported yet. */
6910
6911 static void
6912 pa_leave (unused)
6913 int unused ATTRIBUTE_UNUSED;
6914 {
6915 #ifdef OBJ_SOM
6916 /* We must have a valid space and subspace. */
6917 pa_check_current_space_and_subspace ();
6918 #endif
6919
6920 as_bad (_("The .LEAVE pseudo-op is not supported"));
6921 demand_empty_rest_of_line ();
6922 }
6923
6924 /* Handle a .LEVEL pseudo-op. */
6925
6926 static void
6927 pa_level (unused)
6928 int unused ATTRIBUTE_UNUSED;
6929 {
6930 char *level;
6931
6932 level = input_line_pointer;
6933 if (strncmp (level, "1.0", 3) == 0)
6934 {
6935 input_line_pointer += 3;
6936 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6937 as_warn (_("could not set architecture and machine"));
6938 }
6939 else if (strncmp (level, "1.1", 3) == 0)
6940 {
6941 input_line_pointer += 3;
6942 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6943 as_warn (_("could not set architecture and machine"));
6944 }
6945 else if (strncmp (level, "2.0w", 4) == 0)
6946 {
6947 input_line_pointer += 4;
6948 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6949 as_warn (_("could not set architecture and machine"));
6950 }
6951 else if (strncmp (level, "2.0", 3) == 0)
6952 {
6953 input_line_pointer += 3;
6954 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6955 as_warn (_("could not set architecture and machine"));
6956 }
6957 else
6958 {
6959 as_bad (_("Unrecognized .LEVEL argument\n"));
6960 ignore_rest_of_line ();
6961 }
6962 demand_empty_rest_of_line ();
6963 }
6964
6965 /* Handle a .ORIGIN pseudo-op. */
6966
6967 static void
6968 pa_origin (unused)
6969 int unused ATTRIBUTE_UNUSED;
6970 {
6971 #ifdef OBJ_SOM
6972 /* We must have a valid space and subspace. */
6973 pa_check_current_space_and_subspace ();
6974 #endif
6975
6976 s_org (0);
6977 pa_undefine_label ();
6978 }
6979
6980 /* Handle a .PARAM pseudo-op. This is much like a .EXPORT, except it
6981 is for static functions. FIXME. Should share more code with .EXPORT. */
6982
6983 static void
6984 pa_param (unused)
6985 int unused ATTRIBUTE_UNUSED;
6986 {
6987 char *name, c, *p;
6988 symbolS *symbol;
6989
6990 name = input_line_pointer;
6991 c = get_symbol_end ();
6992
6993 if ((symbol = symbol_find_or_make (name)) == NULL)
6994 {
6995 as_bad (_("Cannot define static symbol: %s\n"), name);
6996 p = input_line_pointer;
6997 *p = c;
6998 input_line_pointer++;
6999 }
7000 else
7001 {
7002 S_CLEAR_EXTERNAL (symbol);
7003 p = input_line_pointer;
7004 *p = c;
7005 if (!is_end_of_statement ())
7006 {
7007 input_line_pointer++;
7008 pa_type_args (symbol, 0);
7009 }
7010 }
7011
7012 demand_empty_rest_of_line ();
7013 }
7014
7015 /* Handle a .PROC pseudo-op. It is used to mark the beginning
7016 of a procedure from a syntactical point of view. */
7017
7018 static void
7019 pa_proc (unused)
7020 int unused ATTRIBUTE_UNUSED;
7021 {
7022 struct call_info *call_info;
7023
7024 #ifdef OBJ_SOM
7025 /* We must have a valid space and subspace. */
7026 pa_check_current_space_and_subspace ();
7027 #endif
7028
7029 if (within_procedure)
7030 as_fatal (_("Nested procedures"));
7031
7032 /* Reset global variables for new procedure. */
7033 callinfo_found = FALSE;
7034 within_procedure = TRUE;
7035
7036 /* Create another call_info structure. */
7037 call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
7038
7039 if (!call_info)
7040 as_fatal (_("Cannot allocate unwind descriptor\n"));
7041
7042 memset (call_info, 0, sizeof (struct call_info));
7043
7044 call_info->ci_next = NULL;
7045
7046 if (call_info_root == NULL)
7047 {
7048 call_info_root = call_info;
7049 last_call_info = call_info;
7050 }
7051 else
7052 {
7053 last_call_info->ci_next = call_info;
7054 last_call_info = call_info;
7055 }
7056
7057 /* set up defaults on call_info structure */
7058
7059 call_info->ci_unwind.descriptor.cannot_unwind = 0;
7060 call_info->ci_unwind.descriptor.region_desc = 1;
7061 call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
7062
7063 /* If we got a .PROC pseudo-op, we know that the function is defined
7064 locally. Make sure it gets into the symbol table. */
7065 {
7066 label_symbol_struct *label_symbol = pa_get_label ();
7067
7068 if (label_symbol)
7069 {
7070 if (label_symbol->lss_label)
7071 {
7072 last_call_info->start_symbol = label_symbol->lss_label;
7073 symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
7074 }
7075 else
7076 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7077 }
7078 else
7079 last_call_info->start_symbol = NULL;
7080 }
7081
7082 demand_empty_rest_of_line ();
7083 }
7084
7085 /* Process the syntactical end of a procedure. Make sure all the
7086 appropriate pseudo-ops were found within the procedure. */
7087
7088 static void
7089 pa_procend (unused)
7090 int unused ATTRIBUTE_UNUSED;
7091 {
7092
7093 #ifdef OBJ_SOM
7094 /* We must have a valid space and subspace. */
7095 pa_check_current_space_and_subspace ();
7096 #endif
7097
7098 /* If we are within a procedure definition, make sure we've
7099 defined a label for the procedure; handle case where the
7100 label was defined after the .PROC directive.
7101
7102 Note there's not need to diddle with the segment or fragment
7103 for the label symbol in this case. We have already switched
7104 into the new $CODE$ subspace at this point. */
7105 if (within_procedure && last_call_info->start_symbol == NULL)
7106 {
7107 label_symbol_struct *label_symbol = pa_get_label ();
7108
7109 if (label_symbol)
7110 {
7111 if (label_symbol->lss_label)
7112 {
7113 last_call_info->start_symbol = label_symbol->lss_label;
7114 symbol_get_bfdsym (label_symbol->lss_label)->flags
7115 |= BSF_FUNCTION;
7116 #ifdef OBJ_SOM
7117 /* Also handle allocation of a fixup to hold the unwind
7118 information when the label appears after the proc/procend. */
7119 if (within_entry_exit)
7120 {
7121 char *where;
7122 unsigned int u;
7123
7124 where = frag_more (0);
7125 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
7126 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7127 NULL, (offsetT) 0, NULL,
7128 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
7129 }
7130 #endif
7131 }
7132 else
7133 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7134 }
7135 else
7136 as_bad (_("Missing function name for .PROC"));
7137 }
7138
7139 if (!within_procedure)
7140 as_bad (_("misplaced .procend"));
7141
7142 if (!callinfo_found)
7143 as_bad (_("Missing .callinfo for this procedure"));
7144
7145 if (within_entry_exit)
7146 as_bad (_("Missing .EXIT for a .ENTRY"));
7147
7148 #ifdef OBJ_ELF
7149 /* ELF needs to mark the end of each function so that it can compute
7150 the size of the function (apparently its needed in the symbol table). */
7151 hppa_elf_mark_end_of_function ();
7152 #endif
7153
7154 within_procedure = FALSE;
7155 demand_empty_rest_of_line ();
7156 pa_undefine_label ();
7157 }
7158
7159 #ifdef OBJ_SOM
7160 /* If VALUE is an exact power of two between zero and 2^31, then
7161 return log2 (VALUE). Else return -1. */
7162
7163 static int
7164 exact_log2 (value)
7165 int value;
7166 {
7167 int shift = 0;
7168
7169 while ((1 << shift) != value && shift < 32)
7170 shift++;
7171
7172 if (shift >= 32)
7173 return -1;
7174 else
7175 return shift;
7176 }
7177
7178 /* Check to make sure we have a valid space and subspace. */
7179
7180 static void
7181 pa_check_current_space_and_subspace ()
7182 {
7183 if (current_space == NULL)
7184 as_fatal (_("Not in a space.\n"));
7185
7186 if (current_subspace == NULL)
7187 as_fatal (_("Not in a subspace.\n"));
7188 }
7189
7190 /* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7191 then create a new space entry to hold the information specified
7192 by the parameters to the .SPACE directive. */
7193
7194 static sd_chain_struct *
7195 pa_parse_space_stmt (space_name, create_flag)
7196 char *space_name;
7197 int create_flag;
7198 {
7199 char *name, *ptemp, c;
7200 char loadable, defined, private, sort;
7201 int spnum;
7202 asection *seg = NULL;
7203 sd_chain_struct *space;
7204
7205 /* load default values */
7206 spnum = 0;
7207 sort = 0;
7208 loadable = TRUE;
7209 defined = TRUE;
7210 private = FALSE;
7211 if (strcmp (space_name, "$TEXT$") == 0)
7212 {
7213 seg = pa_def_spaces[0].segment;
7214 defined = pa_def_spaces[0].defined;
7215 private = pa_def_spaces[0].private;
7216 sort = pa_def_spaces[0].sort;
7217 spnum = pa_def_spaces[0].spnum;
7218 }
7219 else if (strcmp (space_name, "$PRIVATE$") == 0)
7220 {
7221 seg = pa_def_spaces[1].segment;
7222 defined = pa_def_spaces[1].defined;
7223 private = pa_def_spaces[1].private;
7224 sort = pa_def_spaces[1].sort;
7225 spnum = pa_def_spaces[1].spnum;
7226 }
7227
7228 if (!is_end_of_statement ())
7229 {
7230 print_errors = FALSE;
7231 ptemp = input_line_pointer + 1;
7232 /* First see if the space was specified as a number rather than
7233 as a name. According to the PA assembly manual the rest of
7234 the line should be ignored. */
7235 strict = 0;
7236 pa_parse_number (&ptemp, 0);
7237 if (pa_number >= 0)
7238 {
7239 spnum = pa_number;
7240 input_line_pointer = ptemp;
7241 }
7242 else
7243 {
7244 while (!is_end_of_statement ())
7245 {
7246 input_line_pointer++;
7247 name = input_line_pointer;
7248 c = get_symbol_end ();
7249 if ((strncasecmp (name, "spnum", 5) == 0))
7250 {
7251 *input_line_pointer = c;
7252 input_line_pointer++;
7253 spnum = get_absolute_expression ();
7254 }
7255 else if ((strncasecmp (name, "sort", 4) == 0))
7256 {
7257 *input_line_pointer = c;
7258 input_line_pointer++;
7259 sort = get_absolute_expression ();
7260 }
7261 else if ((strncasecmp (name, "unloadable", 10) == 0))
7262 {
7263 *input_line_pointer = c;
7264 loadable = FALSE;
7265 }
7266 else if ((strncasecmp (name, "notdefined", 10) == 0))
7267 {
7268 *input_line_pointer = c;
7269 defined = FALSE;
7270 }
7271 else if ((strncasecmp (name, "private", 7) == 0))
7272 {
7273 *input_line_pointer = c;
7274 private = TRUE;
7275 }
7276 else
7277 {
7278 as_bad (_("Invalid .SPACE argument"));
7279 *input_line_pointer = c;
7280 if (!is_end_of_statement ())
7281 input_line_pointer++;
7282 }
7283 }
7284 }
7285 print_errors = TRUE;
7286 }
7287
7288 if (create_flag && seg == NULL)
7289 seg = subseg_new (space_name, 0);
7290
7291 /* If create_flag is nonzero, then create the new space with
7292 the attributes computed above. Else set the values in
7293 an already existing space -- this can only happen for
7294 the first occurrence of a built-in space. */
7295 if (create_flag)
7296 space = create_new_space (space_name, spnum, loadable, defined,
7297 private, sort, seg, 1);
7298 else
7299 {
7300 space = is_defined_space (space_name);
7301 SPACE_SPNUM (space) = spnum;
7302 SPACE_DEFINED (space) = defined & 1;
7303 SPACE_USER_DEFINED (space) = 1;
7304 }
7305
7306 #ifdef obj_set_section_attributes
7307 obj_set_section_attributes (seg, defined, private, sort, spnum);
7308 #endif
7309
7310 return space;
7311 }
7312
7313 /* Handle a .SPACE pseudo-op; this switches the current space to the
7314 given space, creating the new space if necessary. */
7315
7316 static void
7317 pa_space (unused)
7318 int unused ATTRIBUTE_UNUSED;
7319 {
7320 char *name, c, *space_name, *save_s;
7321 sd_chain_struct *sd_chain;
7322
7323 if (within_procedure)
7324 {
7325 as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7326 ignore_rest_of_line ();
7327 }
7328 else
7329 {
7330 /* Check for some of the predefined spaces. FIXME: most of the code
7331 below is repeated several times, can we extract the common parts
7332 and place them into a subroutine or something similar? */
7333 /* FIXME Is this (and the next IF stmt) really right?
7334 What if INPUT_LINE_POINTER points to "$TEXT$FOO"? */
7335 if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7336 {
7337 input_line_pointer += 6;
7338 sd_chain = is_defined_space ("$TEXT$");
7339 if (sd_chain == NULL)
7340 sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7341 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7342 sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7343
7344 current_space = sd_chain;
7345 subseg_set (text_section, sd_chain->sd_last_subseg);
7346 current_subspace
7347 = pa_subsegment_to_subspace (text_section,
7348 sd_chain->sd_last_subseg);
7349 demand_empty_rest_of_line ();
7350 return;
7351 }
7352 if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7353 {
7354 input_line_pointer += 9;
7355 sd_chain = is_defined_space ("$PRIVATE$");
7356 if (sd_chain == NULL)
7357 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7358 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7359 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7360
7361 current_space = sd_chain;
7362 subseg_set (data_section, sd_chain->sd_last_subseg);
7363 current_subspace
7364 = pa_subsegment_to_subspace (data_section,
7365 sd_chain->sd_last_subseg);
7366 demand_empty_rest_of_line ();
7367 return;
7368 }
7369 if (!strncasecmp (input_line_pointer,
7370 GDB_DEBUG_SPACE_NAME,
7371 strlen (GDB_DEBUG_SPACE_NAME)))
7372 {
7373 input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7374 sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7375 if (sd_chain == NULL)
7376 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7377 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7378 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7379
7380 current_space = sd_chain;
7381
7382 {
7383 asection *gdb_section
7384 = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7385
7386 subseg_set (gdb_section, sd_chain->sd_last_subseg);
7387 current_subspace
7388 = pa_subsegment_to_subspace (gdb_section,
7389 sd_chain->sd_last_subseg);
7390 }
7391 demand_empty_rest_of_line ();
7392 return;
7393 }
7394
7395 /* It could be a space specified by number. */
7396 print_errors = 0;
7397 save_s = input_line_pointer;
7398 strict = 0;
7399 pa_parse_number (&input_line_pointer, 0);
7400 if (pa_number >= 0)
7401 {
7402 if ((sd_chain = pa_find_space_by_number (pa_number)))
7403 {
7404 current_space = sd_chain;
7405
7406 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7407 current_subspace
7408 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7409 sd_chain->sd_last_subseg);
7410 demand_empty_rest_of_line ();
7411 return;
7412 }
7413 }
7414
7415 /* Not a number, attempt to create a new space. */
7416 print_errors = 1;
7417 input_line_pointer = save_s;
7418 name = input_line_pointer;
7419 c = get_symbol_end ();
7420 space_name = xmalloc (strlen (name) + 1);
7421 strcpy (space_name, name);
7422 *input_line_pointer = c;
7423
7424 sd_chain = pa_parse_space_stmt (space_name, 1);
7425 current_space = sd_chain;
7426
7427 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7428 current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7429 sd_chain->sd_last_subseg);
7430 demand_empty_rest_of_line ();
7431 }
7432 }
7433
7434 /* Switch to a new space. (I think). FIXME. */
7435
7436 static void
7437 pa_spnum (unused)
7438 int unused ATTRIBUTE_UNUSED;
7439 {
7440 char *name;
7441 char c;
7442 char *p;
7443 sd_chain_struct *space;
7444
7445 name = input_line_pointer;
7446 c = get_symbol_end ();
7447 space = is_defined_space (name);
7448 if (space)
7449 {
7450 p = frag_more (4);
7451 md_number_to_chars (p, SPACE_SPNUM (space), 4);
7452 }
7453 else
7454 as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7455
7456 *input_line_pointer = c;
7457 demand_empty_rest_of_line ();
7458 }
7459
7460 /* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7461 given subspace, creating the new subspace if necessary.
7462
7463 FIXME. Should mirror pa_space more closely, in particular how
7464 they're broken up into subroutines. */
7465
7466 static void
7467 pa_subspace (create_new)
7468 int create_new;
7469 {
7470 char *name, *ss_name, c;
7471 char loadable, code_only, comdat, common, dup_common, zero, sort;
7472 int i, access, space_index, alignment, quadrant, applicable, flags;
7473 sd_chain_struct *space;
7474 ssd_chain_struct *ssd;
7475 asection *section;
7476
7477 if (current_space == NULL)
7478 as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7479
7480 if (within_procedure)
7481 {
7482 as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7483 ignore_rest_of_line ();
7484 }
7485 else
7486 {
7487 name = input_line_pointer;
7488 c = get_symbol_end ();
7489 ss_name = xmalloc (strlen (name) + 1);
7490 strcpy (ss_name, name);
7491 *input_line_pointer = c;
7492
7493 /* Load default values. */
7494 sort = 0;
7495 access = 0x7f;
7496 loadable = 1;
7497 comdat = 0;
7498 common = 0;
7499 dup_common = 0;
7500 code_only = 0;
7501 zero = 0;
7502 space_index = ~0;
7503 alignment = 1;
7504 quadrant = 0;
7505
7506 space = current_space;
7507 if (create_new)
7508 ssd = NULL;
7509 else
7510 ssd = is_defined_subspace (ss_name);
7511 /* Allow user to override the builtin attributes of subspaces. But
7512 only allow the attributes to be changed once! */
7513 if (ssd && SUBSPACE_DEFINED (ssd))
7514 {
7515 subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7516 current_subspace = ssd;
7517 if (!is_end_of_statement ())
7518 as_warn (_("Parameters of an existing subspace can\'t be modified"));
7519 demand_empty_rest_of_line ();
7520 return;
7521 }
7522 else
7523 {
7524 /* A new subspace. Load default values if it matches one of
7525 the builtin subspaces. */
7526 i = 0;
7527 while (pa_def_subspaces[i].name)
7528 {
7529 if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7530 {
7531 loadable = pa_def_subspaces[i].loadable;
7532 comdat = pa_def_subspaces[i].comdat;
7533 common = pa_def_subspaces[i].common;
7534 dup_common = pa_def_subspaces[i].dup_common;
7535 code_only = pa_def_subspaces[i].code_only;
7536 zero = pa_def_subspaces[i].zero;
7537 space_index = pa_def_subspaces[i].space_index;
7538 alignment = pa_def_subspaces[i].alignment;
7539 quadrant = pa_def_subspaces[i].quadrant;
7540 access = pa_def_subspaces[i].access;
7541 sort = pa_def_subspaces[i].sort;
7542 break;
7543 }
7544 i++;
7545 }
7546 }
7547
7548 /* We should be working with a new subspace now. Fill in
7549 any information as specified by the user. */
7550 if (!is_end_of_statement ())
7551 {
7552 input_line_pointer++;
7553 while (!is_end_of_statement ())
7554 {
7555 name = input_line_pointer;
7556 c = get_symbol_end ();
7557 if ((strncasecmp (name, "quad", 4) == 0))
7558 {
7559 *input_line_pointer = c;
7560 input_line_pointer++;
7561 quadrant = get_absolute_expression ();
7562 }
7563 else if ((strncasecmp (name, "align", 5) == 0))
7564 {
7565 *input_line_pointer = c;
7566 input_line_pointer++;
7567 alignment = get_absolute_expression ();
7568 if (exact_log2 (alignment) == -1)
7569 {
7570 as_bad (_("Alignment must be a power of 2"));
7571 alignment = 1;
7572 }
7573 }
7574 else if ((strncasecmp (name, "access", 6) == 0))
7575 {
7576 *input_line_pointer = c;
7577 input_line_pointer++;
7578 access = get_absolute_expression ();
7579 }
7580 else if ((strncasecmp (name, "sort", 4) == 0))
7581 {
7582 *input_line_pointer = c;
7583 input_line_pointer++;
7584 sort = get_absolute_expression ();
7585 }
7586 else if ((strncasecmp (name, "code_only", 9) == 0))
7587 {
7588 *input_line_pointer = c;
7589 code_only = 1;
7590 }
7591 else if ((strncasecmp (name, "unloadable", 10) == 0))
7592 {
7593 *input_line_pointer = c;
7594 loadable = 0;
7595 }
7596 else if ((strncasecmp (name, "comdat", 6) == 0))
7597 {
7598 *input_line_pointer = c;
7599 comdat = 1;
7600 }
7601 else if ((strncasecmp (name, "common", 6) == 0))
7602 {
7603 *input_line_pointer = c;
7604 common = 1;
7605 }
7606 else if ((strncasecmp (name, "dup_comm", 8) == 0))
7607 {
7608 *input_line_pointer = c;
7609 dup_common = 1;
7610 }
7611 else if ((strncasecmp (name, "zero", 4) == 0))
7612 {
7613 *input_line_pointer = c;
7614 zero = 1;
7615 }
7616 else if ((strncasecmp (name, "first", 5) == 0))
7617 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7618 else
7619 as_bad (_("Invalid .SUBSPACE argument"));
7620 if (!is_end_of_statement ())
7621 input_line_pointer++;
7622 }
7623 }
7624
7625 /* Compute a reasonable set of BFD flags based on the information
7626 in the .subspace directive. */
7627 applicable = bfd_applicable_section_flags (stdoutput);
7628 flags = 0;
7629 if (loadable)
7630 flags |= (SEC_ALLOC | SEC_LOAD);
7631 if (code_only)
7632 flags |= SEC_CODE;
7633
7634 /* These flags are used to implement various flavors of initialized
7635 common. The SOM linker discards duplicate subspaces when they
7636 have the same "key" symbol name. This support is more like
7637 GNU linkonce than BFD common. Further, pc-relative relocations
7638 are converted to section relative relocations in BFD common
7639 sections. This complicates the handling of relocations in
7640 common sections containing text and isn't currently supported
7641 correctly in the SOM BFD backend. */
7642 if (comdat || common || dup_common)
7643 flags |= SEC_LINK_ONCE;
7644
7645 flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7646
7647 /* This is a zero-filled subspace (eg BSS). */
7648 if (zero)
7649 flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7650
7651 applicable &= flags;
7652
7653 /* If this is an existing subspace, then we want to use the
7654 segment already associated with the subspace.
7655
7656 FIXME NOW! ELF BFD doesn't appear to be ready to deal with
7657 lots of sections. It might be a problem in the PA ELF
7658 code, I do not know yet. For now avoid creating anything
7659 but the "standard" sections for ELF. */
7660 if (create_new)
7661 section = subseg_force_new (ss_name, 0);
7662 else if (ssd)
7663 section = ssd->ssd_seg;
7664 else
7665 section = subseg_new (ss_name, 0);
7666
7667 if (zero)
7668 seg_info (section)->bss = 1;
7669
7670 /* Now set the flags. */
7671 bfd_set_section_flags (stdoutput, section, applicable);
7672
7673 /* Record any alignment request for this section. */
7674 record_alignment (section, exact_log2 (alignment));
7675
7676 /* Set the starting offset for this section. */
7677 bfd_set_section_vma (stdoutput, section,
7678 pa_subspace_start (space, quadrant));
7679
7680 /* Now that all the flags are set, update an existing subspace,
7681 or create a new one. */
7682 if (ssd)
7683
7684 current_subspace = update_subspace (space, ss_name, loadable,
7685 code_only, comdat, common,
7686 dup_common, sort, zero, access,
7687 space_index, alignment, quadrant,
7688 section);
7689 else
7690 current_subspace = create_new_subspace (space, ss_name, loadable,
7691 code_only, comdat, common,
7692 dup_common, zero, sort,
7693 access, space_index,
7694 alignment, quadrant, section);
7695
7696 demand_empty_rest_of_line ();
7697 current_subspace->ssd_seg = section;
7698 subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7699 }
7700 SUBSPACE_DEFINED (current_subspace) = 1;
7701 }
7702
7703 /* Create default space and subspace dictionaries. */
7704
7705 static void
7706 pa_spaces_begin ()
7707 {
7708 int i;
7709
7710 space_dict_root = NULL;
7711 space_dict_last = NULL;
7712
7713 i = 0;
7714 while (pa_def_spaces[i].name)
7715 {
7716 char *name;
7717
7718 /* Pick the right name to use for the new section. */
7719 name = pa_def_spaces[i].name;
7720
7721 pa_def_spaces[i].segment = subseg_new (name, 0);
7722 create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7723 pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7724 pa_def_spaces[i].private, pa_def_spaces[i].sort,
7725 pa_def_spaces[i].segment, 0);
7726 i++;
7727 }
7728
7729 i = 0;
7730 while (pa_def_subspaces[i].name)
7731 {
7732 char *name;
7733 int applicable, subsegment;
7734 asection *segment = NULL;
7735 sd_chain_struct *space;
7736
7737 /* Pick the right name for the new section and pick the right
7738 subsegment number. */
7739 name = pa_def_subspaces[i].name;
7740 subsegment = 0;
7741
7742 /* Create the new section. */
7743 segment = subseg_new (name, subsegment);
7744
7745 /* For SOM we want to replace the standard .text, .data, and .bss
7746 sections with our own. We also want to set BFD flags for
7747 all the built-in subspaces. */
7748 if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
7749 {
7750 text_section = segment;
7751 applicable = bfd_applicable_section_flags (stdoutput);
7752 bfd_set_section_flags (stdoutput, segment,
7753 applicable & (SEC_ALLOC | SEC_LOAD
7754 | SEC_RELOC | SEC_CODE
7755 | SEC_READONLY
7756 | SEC_HAS_CONTENTS));
7757 }
7758 else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
7759 {
7760 data_section = segment;
7761 applicable = bfd_applicable_section_flags (stdoutput);
7762 bfd_set_section_flags (stdoutput, segment,
7763 applicable & (SEC_ALLOC | SEC_LOAD
7764 | SEC_RELOC
7765 | SEC_HAS_CONTENTS));
7766
7767 }
7768 else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
7769 {
7770 bss_section = segment;
7771 applicable = bfd_applicable_section_flags (stdoutput);
7772 bfd_set_section_flags (stdoutput, segment,
7773 applicable & SEC_ALLOC);
7774 }
7775 else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
7776 {
7777 applicable = bfd_applicable_section_flags (stdoutput);
7778 bfd_set_section_flags (stdoutput, segment,
7779 applicable & (SEC_ALLOC | SEC_LOAD
7780 | SEC_RELOC
7781 | SEC_READONLY
7782 | SEC_HAS_CONTENTS));
7783 }
7784 else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
7785 {
7786 applicable = bfd_applicable_section_flags (stdoutput);
7787 bfd_set_section_flags (stdoutput, segment,
7788 applicable & (SEC_ALLOC | SEC_LOAD
7789 | SEC_RELOC
7790 | SEC_READONLY
7791 | SEC_HAS_CONTENTS));
7792 }
7793 else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
7794 {
7795 applicable = bfd_applicable_section_flags (stdoutput);
7796 bfd_set_section_flags (stdoutput, segment,
7797 applicable & (SEC_ALLOC | SEC_LOAD
7798 | SEC_RELOC
7799 | SEC_READONLY
7800 | SEC_HAS_CONTENTS));
7801 }
7802
7803 /* Find the space associated with this subspace. */
7804 space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7805 def_space_index].segment);
7806 if (space == NULL)
7807 {
7808 as_fatal (_("Internal error: Unable to find containing space for %s."),
7809 pa_def_subspaces[i].name);
7810 }
7811
7812 create_new_subspace (space, name,
7813 pa_def_subspaces[i].loadable,
7814 pa_def_subspaces[i].code_only,
7815 pa_def_subspaces[i].comdat,
7816 pa_def_subspaces[i].common,
7817 pa_def_subspaces[i].dup_common,
7818 pa_def_subspaces[i].zero,
7819 pa_def_subspaces[i].sort,
7820 pa_def_subspaces[i].access,
7821 pa_def_subspaces[i].space_index,
7822 pa_def_subspaces[i].alignment,
7823 pa_def_subspaces[i].quadrant,
7824 segment);
7825 i++;
7826 }
7827 }
7828
7829 /* Create a new space NAME, with the appropriate flags as defined
7830 by the given parameters. */
7831
7832 static sd_chain_struct *
7833 create_new_space (name, spnum, loadable, defined, private,
7834 sort, seg, user_defined)
7835 char *name;
7836 int spnum;
7837 int loadable ATTRIBUTE_UNUSED;
7838 int defined;
7839 int private;
7840 int sort;
7841 asection *seg;
7842 int user_defined;
7843 {
7844 sd_chain_struct *chain_entry;
7845
7846 chain_entry = (sd_chain_struct *) xmalloc (sizeof (sd_chain_struct));
7847 if (!chain_entry)
7848 as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7849 name);
7850
7851 SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7852 strcpy (SPACE_NAME (chain_entry), name);
7853 SPACE_DEFINED (chain_entry) = defined;
7854 SPACE_USER_DEFINED (chain_entry) = user_defined;
7855 SPACE_SPNUM (chain_entry) = spnum;
7856
7857 chain_entry->sd_seg = seg;
7858 chain_entry->sd_last_subseg = -1;
7859 chain_entry->sd_subspaces = NULL;
7860 chain_entry->sd_next = NULL;
7861
7862 /* Find spot for the new space based on its sort key. */
7863 if (!space_dict_last)
7864 space_dict_last = chain_entry;
7865
7866 if (space_dict_root == NULL)
7867 space_dict_root = chain_entry;
7868 else
7869 {
7870 sd_chain_struct *chain_pointer;
7871 sd_chain_struct *prev_chain_pointer;
7872
7873 chain_pointer = space_dict_root;
7874 prev_chain_pointer = NULL;
7875
7876 while (chain_pointer)
7877 {
7878 prev_chain_pointer = chain_pointer;
7879 chain_pointer = chain_pointer->sd_next;
7880 }
7881
7882 /* At this point we've found the correct place to add the new
7883 entry. So add it and update the linked lists as appropriate. */
7884 if (prev_chain_pointer)
7885 {
7886 chain_entry->sd_next = chain_pointer;
7887 prev_chain_pointer->sd_next = chain_entry;
7888 }
7889 else
7890 {
7891 space_dict_root = chain_entry;
7892 chain_entry->sd_next = chain_pointer;
7893 }
7894
7895 if (chain_entry->sd_next == NULL)
7896 space_dict_last = chain_entry;
7897 }
7898
7899 /* This is here to catch predefined spaces which do not get
7900 modified by the user's input. Another call is found at
7901 the bottom of pa_parse_space_stmt to handle cases where
7902 the user modifies a predefined space. */
7903 #ifdef obj_set_section_attributes
7904 obj_set_section_attributes (seg, defined, private, sort, spnum);
7905 #endif
7906
7907 return chain_entry;
7908 }
7909
7910 /* Create a new subspace NAME, with the appropriate flags as defined
7911 by the given parameters.
7912
7913 Add the new subspace to the subspace dictionary chain in numerical
7914 order as defined by the SORT entries. */
7915
7916 static ssd_chain_struct *
7917 create_new_subspace (space, name, loadable, code_only, comdat, common,
7918 dup_common, is_zero, sort, access, space_index,
7919 alignment, quadrant, seg)
7920 sd_chain_struct *space;
7921 char *name;
7922 int loadable ATTRIBUTE_UNUSED;
7923 int code_only ATTRIBUTE_UNUSED;
7924 int comdat, common, dup_common;
7925 int is_zero ATTRIBUTE_UNUSED;
7926 int sort;
7927 int access;
7928 int space_index ATTRIBUTE_UNUSED;
7929 int alignment ATTRIBUTE_UNUSED;
7930 int quadrant;
7931 asection *seg;
7932 {
7933 ssd_chain_struct *chain_entry;
7934
7935 chain_entry = (ssd_chain_struct *) xmalloc (sizeof (ssd_chain_struct));
7936 if (!chain_entry)
7937 as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
7938
7939 SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7940 strcpy (SUBSPACE_NAME (chain_entry), name);
7941
7942 /* Initialize subspace_defined. When we hit a .subspace directive
7943 we'll set it to 1 which "locks-in" the subspace attributes. */
7944 SUBSPACE_DEFINED (chain_entry) = 0;
7945
7946 chain_entry->ssd_subseg = 0;
7947 chain_entry->ssd_seg = seg;
7948 chain_entry->ssd_next = NULL;
7949
7950 /* Find spot for the new subspace based on its sort key. */
7951 if (space->sd_subspaces == NULL)
7952 space->sd_subspaces = chain_entry;
7953 else
7954 {
7955 ssd_chain_struct *chain_pointer;
7956 ssd_chain_struct *prev_chain_pointer;
7957
7958 chain_pointer = space->sd_subspaces;
7959 prev_chain_pointer = NULL;
7960
7961 while (chain_pointer)
7962 {
7963 prev_chain_pointer = chain_pointer;
7964 chain_pointer = chain_pointer->ssd_next;
7965 }
7966
7967 /* Now we have somewhere to put the new entry. Insert it and update
7968 the links. */
7969 if (prev_chain_pointer)
7970 {
7971 chain_entry->ssd_next = chain_pointer;
7972 prev_chain_pointer->ssd_next = chain_entry;
7973 }
7974 else
7975 {
7976 space->sd_subspaces = chain_entry;
7977 chain_entry->ssd_next = chain_pointer;
7978 }
7979 }
7980
7981 #ifdef obj_set_subsection_attributes
7982 obj_set_subsection_attributes (seg, space->sd_seg, access, sort,
7983 quadrant, comdat, common, dup_common);
7984 #endif
7985
7986 return chain_entry;
7987 }
7988
7989 /* Update the information for the given subspace based upon the
7990 various arguments. Return the modified subspace chain entry. */
7991
7992 static ssd_chain_struct *
7993 update_subspace (space, name, loadable, code_only, comdat, common, dup_common,
7994 sort, zero, access, space_index, alignment, quadrant, section)
7995 sd_chain_struct *space;
7996 char *name;
7997 int loadable ATTRIBUTE_UNUSED;
7998 int code_only ATTRIBUTE_UNUSED;
7999 int comdat;
8000 int common;
8001 int dup_common;
8002 int zero ATTRIBUTE_UNUSED;
8003 int sort;
8004 int access;
8005 int space_index ATTRIBUTE_UNUSED;
8006 int alignment ATTRIBUTE_UNUSED;
8007 int quadrant;
8008 asection *section;
8009 {
8010 ssd_chain_struct *chain_entry;
8011
8012 chain_entry = is_defined_subspace (name);
8013
8014 #ifdef obj_set_subsection_attributes
8015 obj_set_subsection_attributes (section, space->sd_seg, access, sort,
8016 quadrant, comdat, common, dup_common);
8017 #endif
8018
8019 return chain_entry;
8020 }
8021
8022 /* Return the space chain entry for the space with the name NAME or
8023 NULL if no such space exists. */
8024
8025 static sd_chain_struct *
8026 is_defined_space (name)
8027 char *name;
8028 {
8029 sd_chain_struct *chain_pointer;
8030
8031 for (chain_pointer = space_dict_root;
8032 chain_pointer;
8033 chain_pointer = chain_pointer->sd_next)
8034 {
8035 if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
8036 return chain_pointer;
8037 }
8038
8039 /* No mapping from segment to space was found. Return NULL. */
8040 return NULL;
8041 }
8042
8043 /* Find and return the space associated with the given seg. If no mapping
8044 from the given seg to a space is found, then return NULL.
8045
8046 Unlike subspaces, the number of spaces is not expected to grow much,
8047 so a linear exhaustive search is OK here. */
8048
8049 static sd_chain_struct *
8050 pa_segment_to_space (seg)
8051 asection *seg;
8052 {
8053 sd_chain_struct *space_chain;
8054
8055 /* Walk through each space looking for the correct mapping. */
8056 for (space_chain = space_dict_root;
8057 space_chain;
8058 space_chain = space_chain->sd_next)
8059 {
8060 if (space_chain->sd_seg == seg)
8061 return space_chain;
8062 }
8063
8064 /* Mapping was not found. Return NULL. */
8065 return NULL;
8066 }
8067
8068 /* Return the first space chain entry for the subspace with the name
8069 NAME or NULL if no such subspace exists.
8070
8071 When there are multiple subspaces with the same name, switching to
8072 the first (i.e., default) subspace is preferable in most situations.
8073 For example, it wouldn't be desirable to merge COMDAT data with non
8074 COMDAT data.
8075
8076 Uses a linear search through all the spaces and subspaces, this may
8077 not be appropriate if we ever being placing each function in its
8078 own subspace. */
8079
8080 static ssd_chain_struct *
8081 is_defined_subspace (name)
8082 char *name;
8083 {
8084 sd_chain_struct *space_chain;
8085 ssd_chain_struct *subspace_chain;
8086
8087 /* Walk through each space. */
8088 for (space_chain = space_dict_root;
8089 space_chain;
8090 space_chain = space_chain->sd_next)
8091 {
8092 /* Walk through each subspace looking for a name which matches. */
8093 for (subspace_chain = space_chain->sd_subspaces;
8094 subspace_chain;
8095 subspace_chain = subspace_chain->ssd_next)
8096 if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
8097 return subspace_chain;
8098 }
8099
8100 /* Subspace wasn't found. Return NULL. */
8101 return NULL;
8102 }
8103
8104 /* Find and return the subspace associated with the given seg. If no
8105 mapping from the given seg to a subspace is found, then return NULL.
8106
8107 If we ever put each procedure/function within its own subspace
8108 (to make life easier on the compiler and linker), then this will have
8109 to become more efficient. */
8110
8111 static ssd_chain_struct *
8112 pa_subsegment_to_subspace (seg, subseg)
8113 asection *seg;
8114 subsegT subseg;
8115 {
8116 sd_chain_struct *space_chain;
8117 ssd_chain_struct *subspace_chain;
8118
8119 /* Walk through each space. */
8120 for (space_chain = space_dict_root;
8121 space_chain;
8122 space_chain = space_chain->sd_next)
8123 {
8124 if (space_chain->sd_seg == seg)
8125 {
8126 /* Walk through each subspace within each space looking for
8127 the correct mapping. */
8128 for (subspace_chain = space_chain->sd_subspaces;
8129 subspace_chain;
8130 subspace_chain = subspace_chain->ssd_next)
8131 if (subspace_chain->ssd_subseg == (int) subseg)
8132 return subspace_chain;
8133 }
8134 }
8135
8136 /* No mapping from subsegment to subspace found. Return NULL. */
8137 return NULL;
8138 }
8139
8140 /* Given a number, try and find a space with the name number.
8141
8142 Return a pointer to a space dictionary chain entry for the space
8143 that was found or NULL on failure. */
8144
8145 static sd_chain_struct *
8146 pa_find_space_by_number (number)
8147 int number;
8148 {
8149 sd_chain_struct *space_chain;
8150
8151 for (space_chain = space_dict_root;
8152 space_chain;
8153 space_chain = space_chain->sd_next)
8154 {
8155 if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8156 return space_chain;
8157 }
8158
8159 /* No appropriate space found. Return NULL. */
8160 return NULL;
8161 }
8162
8163 /* Return the starting address for the given subspace. If the starting
8164 address is unknown then return zero. */
8165
8166 static unsigned int
8167 pa_subspace_start (space, quadrant)
8168 sd_chain_struct *space;
8169 int quadrant;
8170 {
8171 /* FIXME. Assumes everyone puts read/write data at 0x4000000, this
8172 is not correct for the PA OSF1 port. */
8173 if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8174 return 0x40000000;
8175 else if (space->sd_seg == data_section && quadrant == 1)
8176 return 0x40000000;
8177 else
8178 return 0;
8179 return 0;
8180 }
8181 #endif
8182
8183 /* Helper function for pa_stringer. Used to find the end of
8184 a string. */
8185
8186 static unsigned int
8187 pa_stringer_aux (s)
8188 char *s;
8189 {
8190 unsigned int c = *s & CHAR_MASK;
8191
8192 switch (c)
8193 {
8194 case '\"':
8195 c = NOT_A_CHAR;
8196 break;
8197 default:
8198 break;
8199 }
8200 return c;
8201 }
8202
8203 /* Handle a .STRING type pseudo-op. */
8204
8205 static void
8206 pa_stringer (append_zero)
8207 int append_zero;
8208 {
8209 char *s, num_buf[4];
8210 unsigned int c;
8211 int i;
8212
8213 /* Preprocess the string to handle PA-specific escape sequences.
8214 For example, \xDD where DD is a hexadecimal number should be
8215 changed to \OOO where OOO is an octal number. */
8216
8217 #ifdef OBJ_SOM
8218 /* We must have a valid space and subspace. */
8219 pa_check_current_space_and_subspace ();
8220 #endif
8221
8222 /* Skip the opening quote. */
8223 s = input_line_pointer + 1;
8224
8225 while (is_a_char (c = pa_stringer_aux (s++)))
8226 {
8227 if (c == '\\')
8228 {
8229 c = *s;
8230 switch (c)
8231 {
8232 /* Handle \x<num>. */
8233 case 'x':
8234 {
8235 unsigned int number;
8236 int num_digit;
8237 char dg;
8238 char *s_start = s;
8239
8240 /* Get past the 'x'. */
8241 s++;
8242 for (num_digit = 0, number = 0, dg = *s;
8243 num_digit < 2
8244 && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
8245 || (dg >= 'A' && dg <= 'F'));
8246 num_digit++)
8247 {
8248 if (ISDIGIT (dg))
8249 number = number * 16 + dg - '0';
8250 else if (dg >= 'a' && dg <= 'f')
8251 number = number * 16 + dg - 'a' + 10;
8252 else
8253 number = number * 16 + dg - 'A' + 10;
8254
8255 s++;
8256 dg = *s;
8257 }
8258 if (num_digit > 0)
8259 {
8260 switch (num_digit)
8261 {
8262 case 1:
8263 sprintf (num_buf, "%02o", number);
8264 break;
8265 case 2:
8266 sprintf (num_buf, "%03o", number);
8267 break;
8268 }
8269 for (i = 0; i <= num_digit; i++)
8270 s_start[i] = num_buf[i];
8271 }
8272 break;
8273 }
8274 /* This might be a "\"", skip over the escaped char. */
8275 default:
8276 s++;
8277 break;
8278 }
8279 }
8280 }
8281 stringer (append_zero);
8282 pa_undefine_label ();
8283 }
8284
8285 /* Handle a .VERSION pseudo-op. */
8286
8287 static void
8288 pa_version (unused)
8289 int unused ATTRIBUTE_UNUSED;
8290 {
8291 obj_version (0);
8292 pa_undefine_label ();
8293 }
8294
8295 #ifdef OBJ_SOM
8296
8297 /* Handle a .COMPILER pseudo-op. */
8298
8299 static void
8300 pa_compiler (unused)
8301 int unused ATTRIBUTE_UNUSED;
8302 {
8303 obj_som_compiler (0);
8304 pa_undefine_label ();
8305 }
8306
8307 #endif
8308
8309 /* Handle a .COPYRIGHT pseudo-op. */
8310
8311 static void
8312 pa_copyright (unused)
8313 int unused ATTRIBUTE_UNUSED;
8314 {
8315 obj_copyright (0);
8316 pa_undefine_label ();
8317 }
8318
8319 /* Just like a normal cons, but when finished we have to undefine
8320 the latest space label. */
8321
8322 static void
8323 pa_cons (nbytes)
8324 int nbytes;
8325 {
8326 cons (nbytes);
8327 pa_undefine_label ();
8328 }
8329
8330 /* Like float_cons, but we need to undefine our label. */
8331
8332 static void
8333 pa_float_cons (float_type)
8334 int float_type;
8335 {
8336 float_cons (float_type);
8337 pa_undefine_label ();
8338 }
8339
8340 /* Like s_fill, but delete our label when finished. */
8341
8342 static void
8343 pa_fill (unused)
8344 int unused ATTRIBUTE_UNUSED;
8345 {
8346 #ifdef OBJ_SOM
8347 /* We must have a valid space and subspace. */
8348 pa_check_current_space_and_subspace ();
8349 #endif
8350
8351 s_fill (0);
8352 pa_undefine_label ();
8353 }
8354
8355 /* Like lcomm, but delete our label when finished. */
8356
8357 static void
8358 pa_lcomm (needs_align)
8359 int needs_align;
8360 {
8361 #ifdef OBJ_SOM
8362 /* We must have a valid space and subspace. */
8363 pa_check_current_space_and_subspace ();
8364 #endif
8365
8366 s_lcomm (needs_align);
8367 pa_undefine_label ();
8368 }
8369
8370 /* Like lsym, but delete our label when finished. */
8371
8372 static void
8373 pa_lsym (unused)
8374 int unused ATTRIBUTE_UNUSED;
8375 {
8376 #ifdef OBJ_SOM
8377 /* We must have a valid space and subspace. */
8378 pa_check_current_space_and_subspace ();
8379 #endif
8380
8381 s_lsym (0);
8382 pa_undefine_label ();
8383 }
8384
8385 /* On the PA relocations which involve function symbols must not be
8386 adjusted. This so that the linker can know when/how to create argument
8387 relocation stubs for indirect calls and calls to static functions.
8388
8389 "T" field selectors create DLT relative fixups for accessing
8390 globals and statics in PIC code; each DLT relative fixup creates
8391 an entry in the DLT table. The entries contain the address of
8392 the final target (eg accessing "foo" would create a DLT entry
8393 with the address of "foo").
8394
8395 Unfortunately, the HP linker doesn't take into account any addend
8396 when generating the DLT; so accessing $LIT$+8 puts the address of
8397 $LIT$ into the DLT rather than the address of $LIT$+8.
8398
8399 The end result is we can't perform relocation symbol reductions for
8400 any fixup which creates entries in the DLT (eg they use "T" field
8401 selectors).
8402
8403 Reject reductions involving symbols with external scope; such
8404 reductions make life a living hell for object file editors.
8405
8406 FIXME. Also reject R_HPPA relocations which are 32bits wide in
8407 the code space. The SOM BFD backend doesn't know how to pull the
8408 right bits out of an instruction. */
8409
8410 int
8411 hppa_fix_adjustable (fixp)
8412 fixS *fixp;
8413 {
8414 #ifdef OBJ_ELF
8415 reloc_type code;
8416 #endif
8417 struct hppa_fix_struct *hppa_fix;
8418
8419 hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8420
8421 #ifdef OBJ_SOM
8422 /* Reject reductions of symbols in 32bit relocs unless they
8423 are fake labels. */
8424 if (fixp->fx_r_type == R_HPPA
8425 && hppa_fix->fx_r_format == 32
8426 && strncmp (S_GET_NAME (fixp->fx_addsy),
8427 FAKE_LABEL_NAME,
8428 strlen (FAKE_LABEL_NAME)))
8429 return 0;
8430 #endif
8431
8432 #ifdef OBJ_ELF
8433 /* LR/RR selectors are implicitly used for a number of different relocation
8434 types. We must ensure that none of these types are adjusted (see below)
8435 even if they occur with a different selector. */
8436 code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8437 hppa_fix->fx_r_format,
8438 hppa_fix->fx_r_field);
8439
8440 switch (code)
8441 {
8442 /* Relocation types which use e_lrsel. */
8443 case R_PARISC_DIR21L:
8444 case R_PARISC_DLTREL21L:
8445 case R_PARISC_DPREL21L:
8446 case R_PARISC_PLTOFF21L:
8447
8448 /* Relocation types which use e_rrsel. */
8449 case R_PARISC_DIR14R:
8450 case R_PARISC_DIR14DR:
8451 case R_PARISC_DIR14WR:
8452 case R_PARISC_DIR17R:
8453 case R_PARISC_DLTREL14R:
8454 case R_PARISC_DLTREL14DR:
8455 case R_PARISC_DLTREL14WR:
8456 case R_PARISC_DPREL14R:
8457 case R_PARISC_DPREL14DR:
8458 case R_PARISC_DPREL14WR:
8459 case R_PARISC_PLTOFF14R:
8460 case R_PARISC_PLTOFF14DR:
8461 case R_PARISC_PLTOFF14WR:
8462
8463 /* Other types that we reject for reduction. */
8464 case R_PARISC_GNU_VTENTRY:
8465 case R_PARISC_GNU_VTINHERIT:
8466 return 0;
8467 default:
8468 break;
8469 }
8470 #endif
8471
8472 /* Reject reductions of symbols in sym1-sym2 expressions when
8473 the fixup will occur in a CODE subspace.
8474
8475 XXX FIXME: Long term we probably want to reject all of these;
8476 for example reducing in the debug section would lose if we ever
8477 supported using the optimizing hp linker. */
8478 if (fixp->fx_addsy
8479 && fixp->fx_subsy
8480 && (hppa_fix->segment->flags & SEC_CODE))
8481 return 0;
8482
8483 /* We can't adjust any relocs that use LR% and RR% field selectors.
8484
8485 If a symbol is reduced to a section symbol, the assembler will
8486 adjust the addend unless the symbol happens to reside right at
8487 the start of the section. Additionally, the linker has no choice
8488 but to manipulate the addends when coalescing input sections for
8489 "ld -r". Since an LR% field selector is defined to round the
8490 addend, we can't change the addend without risking that a LR% and
8491 it's corresponding (possible multiple) RR% field will no longer
8492 sum to the right value.
8493
8494 eg. Suppose we have
8495 . ldil LR%foo+0,%r21
8496 . ldw RR%foo+0(%r21),%r26
8497 . ldw RR%foo+4(%r21),%r25
8498
8499 If foo is at address 4092 (decimal) in section `sect', then after
8500 reducing to the section symbol we get
8501 . LR%sect+4092 == (L%sect)+0
8502 . RR%sect+4092 == (R%sect)+4092
8503 . RR%sect+4096 == (R%sect)-4096
8504 and the last address loses because rounding the addend to 8k
8505 multiples takes us up to 8192 with an offset of -4096.
8506
8507 In cases where the LR% expression is identical to the RR% one we
8508 will never have a problem, but is so happens that gcc rounds
8509 addends involved in LR% field selectors to work around a HP
8510 linker bug. ie. We often have addresses like the last case
8511 above where the LR% expression is offset from the RR% one. */
8512
8513 if (hppa_fix->fx_r_field == e_lrsel
8514 || hppa_fix->fx_r_field == e_rrsel
8515 || hppa_fix->fx_r_field == e_nlrsel)
8516 return 0;
8517
8518 /* Reject reductions of symbols in DLT relative relocs,
8519 relocations with plabels. */
8520 if (hppa_fix->fx_r_field == e_tsel
8521 || hppa_fix->fx_r_field == e_ltsel
8522 || hppa_fix->fx_r_field == e_rtsel
8523 || hppa_fix->fx_r_field == e_psel
8524 || hppa_fix->fx_r_field == e_rpsel
8525 || hppa_fix->fx_r_field == e_lpsel)
8526 return 0;
8527
8528 /* Reject absolute calls (jumps). */
8529 if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8530 return 0;
8531
8532 /* Reject reductions of function symbols. */
8533 if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8534 return 0;
8535
8536 return 1;
8537 }
8538
8539 /* Return nonzero if the fixup in FIXP will require a relocation,
8540 even it if appears that the fixup could be completely handled
8541 within GAS. */
8542
8543 int
8544 hppa_force_relocation (fixp)
8545 struct fix *fixp;
8546 {
8547 struct hppa_fix_struct *hppa_fixp;
8548
8549 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8550 #ifdef OBJ_SOM
8551 if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8552 || fixp->fx_r_type == (int) R_HPPA_EXIT
8553 || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8554 || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8555 || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8556 || fixp->fx_r_type == (int) R_HPPA_END_TRY
8557 || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8558 && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8559 return 1;
8560 #endif
8561 #ifdef OBJ_ELF
8562 if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8563 || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8564 return 1;
8565 #endif
8566
8567 assert (fixp->fx_addsy != NULL);
8568
8569 /* Ensure we emit a relocation for global symbols so that dynamic
8570 linking works. */
8571 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
8572 return 1;
8573
8574 /* It is necessary to force PC-relative calls/jumps to have a relocation
8575 entry if they're going to need either an argument relocation or long
8576 call stub. */
8577 if (fixp->fx_pcrel
8578 && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8579 hppa_fixp->fx_arg_reloc))
8580 return 1;
8581
8582 /* Now check to see if we're going to need a long-branch stub. */
8583 if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8584 {
8585 long pc = md_pcrel_from (fixp);
8586 valueT distance, min_stub_distance;
8587
8588 distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8589
8590 /* Distance to the closest possible stub. This will detect most
8591 but not all circumstances where a stub will not work. */
8592 min_stub_distance = pc + 16;
8593 #ifdef OBJ_SOM
8594 if (last_call_info != NULL)
8595 min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
8596 #endif
8597
8598 if ((distance + 8388608 >= 16777216
8599 && min_stub_distance <= 8388608)
8600 || (hppa_fixp->fx_r_format == 17
8601 && distance + 262144 >= 524288
8602 && min_stub_distance <= 262144)
8603 || (hppa_fixp->fx_r_format == 12
8604 && distance + 8192 >= 16384
8605 && min_stub_distance <= 8192)
8606 )
8607 return 1;
8608 }
8609
8610 if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
8611 return 1;
8612
8613 /* No need (yet) to force another relocations to be emitted. */
8614 return 0;
8615 }
8616
8617 /* Now for some ELF specific code. FIXME. */
8618 #ifdef OBJ_ELF
8619 /* Mark the end of a function so that it's possible to compute
8620 the size of the function in elf_hppa_final_processing. */
8621
8622 static void
8623 hppa_elf_mark_end_of_function ()
8624 {
8625 /* ELF does not have EXIT relocations. All we do is create a
8626 temporary symbol marking the end of the function. */
8627 char *name;
8628
8629 if (last_call_info == NULL || last_call_info->start_symbol == NULL)
8630 {
8631 /* We have already warned about a missing label,
8632 or other problems. */
8633 return;
8634 }
8635
8636 name = (char *) xmalloc (strlen ("L$\001end_")
8637 + strlen (S_GET_NAME (last_call_info->start_symbol))
8638 + 1);
8639 if (name)
8640 {
8641 symbolS *symbolP;
8642
8643 strcpy (name, "L$\001end_");
8644 strcat (name, S_GET_NAME (last_call_info->start_symbol));
8645
8646 /* If we have a .exit followed by a .procend, then the
8647 symbol will have already been defined. */
8648 symbolP = symbol_find (name);
8649 if (symbolP)
8650 {
8651 /* The symbol has already been defined! This can
8652 happen if we have a .exit followed by a .procend.
8653
8654 This is *not* an error. All we want to do is free
8655 the memory we just allocated for the name and continue. */
8656 xfree (name);
8657 }
8658 else
8659 {
8660 /* symbol value should be the offset of the
8661 last instruction of the function */
8662 symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
8663 frag_now);
8664
8665 assert (symbolP);
8666 S_CLEAR_EXTERNAL (symbolP);
8667 symbol_table_insert (symbolP);
8668 }
8669
8670 if (symbolP)
8671 last_call_info->end_symbol = symbolP;
8672 else
8673 as_bad (_("Symbol '%s' could not be created."), name);
8674
8675 }
8676 else
8677 as_bad (_("No memory for symbol name."));
8678
8679 }
8680
8681 /* For ELF, this function serves one purpose: to setup the st_size
8682 field of STT_FUNC symbols. To do this, we need to scan the
8683 call_info structure list, determining st_size in by taking the
8684 difference in the address of the beginning/end marker symbols. */
8685
8686 void
8687 elf_hppa_final_processing ()
8688 {
8689 struct call_info *call_info_pointer;
8690
8691 for (call_info_pointer = call_info_root;
8692 call_info_pointer;
8693 call_info_pointer = call_info_pointer->ci_next)
8694 {
8695 elf_symbol_type *esym
8696 = ((elf_symbol_type *)
8697 symbol_get_bfdsym (call_info_pointer->start_symbol));
8698 esym->internal_elf_sym.st_size =
8699 S_GET_VALUE (call_info_pointer->end_symbol)
8700 - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8701 }
8702 }
8703
8704 static void
8705 pa_vtable_entry (ignore)
8706 int ignore ATTRIBUTE_UNUSED;
8707 {
8708 struct fix *new_fix;
8709
8710 new_fix = obj_elf_vtable_entry (0);
8711
8712 if (new_fix)
8713 {
8714 struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8715 obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8716 hppa_fix->fx_r_type = R_HPPA;
8717 hppa_fix->fx_r_field = e_fsel;
8718 hppa_fix->fx_r_format = 32;
8719 hppa_fix->fx_arg_reloc = 0;
8720 hppa_fix->segment = now_seg;
8721 new_fix->tc_fix_data = (void *) hppa_fix;
8722 new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8723 }
8724 }
8725
8726 static void
8727 pa_vtable_inherit (ignore)
8728 int ignore ATTRIBUTE_UNUSED;
8729 {
8730 struct fix *new_fix;
8731
8732 new_fix = obj_elf_vtable_inherit (0);
8733
8734 if (new_fix)
8735 {
8736 struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8737 obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8738 hppa_fix->fx_r_type = R_HPPA;
8739 hppa_fix->fx_r_field = e_fsel;
8740 hppa_fix->fx_r_format = 32;
8741 hppa_fix->fx_arg_reloc = 0;
8742 hppa_fix->segment = now_seg;
8743 new_fix->tc_fix_data = (void *) hppa_fix;
8744 new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8745 }
8746 }
8747 #endif
GDB Binutils - Deliverables
This page took 0.228778 seconds and 5 git commands to generate.