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