projects / binutils-gdb.git / blob
? search:


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