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