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