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