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