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