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