projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add mangled names to addr2line -i output.
[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 3068 case '#':
71e17562
DA		 3069 if (bfd_get_mach (stdoutput) != pa20)
3070 break;
61dd1d31
JL		 3071 the_insn.field_selector = pa_chk_field_selector (&s);
3072 get_expression (s);
3073 s = expr_end;
3074 if (the_insn.exp.X_op == O_constant)
3075 {
3076 num = evaluate_absolute (&the_insn);
3077 if (num & 0x7)
3078 break;
3079 CHECK_FIELD (num, 8191, -8192, 0);
3080 if (num < 0)
3081 opcode |= 1;
3082 num &= 0x1fff;
3083 num >>= 3;
3084 INSERT_FIELD_AND_CONTINUE (opcode, num, 4);
3085 }
3086 else
3087 {
3088 if (is_DP_relative (the_insn.exp))
3089 the_insn.reloc = R_HPPA_GOTOFF;
3090 else if (is_PC_relative (the_insn.exp))
3091 the_insn.reloc = R_HPPA_PCREL_CALL;
3092 else
3093 the_insn.reloc = R_HPPA;
3094 the_insn.format = 14;
3095 continue;
3096 }
3097 break;
3098
3099 /* Handle 14 bit immediate, shifted left twice. */
3100 case 'd':
3101 the_insn.field_selector = pa_chk_field_selector (&s);
3102 get_expression (s);
3103 s = expr_end;
3104 if (the_insn.exp.X_op == O_constant)
3105 {
3106 num = evaluate_absolute (&the_insn);
3107 if (num & 0x3)
3108 break;
3109 CHECK_FIELD (num, 8191, -8192, 0);
3110 if (num < 0)
3111 opcode |= 1;
3112 num &= 0x1fff;
3113 num >>= 2;
3114 INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
3115 }
3116 else
3117 {
3118 if (is_DP_relative (the_insn.exp))
3119 the_insn.reloc = R_HPPA_GOTOFF;
3120 else if (is_PC_relative (the_insn.exp))
3121 the_insn.reloc = R_HPPA_PCREL_CALL;
3122 else
3123 the_insn.reloc = R_HPPA;
3124 the_insn.format = 14;
3125 continue;
3126 }
252b5132
RH		 3127
3128 /* Handle a 14 bit immediate at 31. */
3129 case 'j':
3130 the_insn.field_selector = pa_chk_field_selector (&s);
3131 get_expression (s);
3132 s = expr_end;
3133 if (the_insn.exp.X_op == O_constant)
3134 {
3135 num = evaluate_absolute (&the_insn);
3136 CHECK_FIELD (num, 8191, -8192, 0);
3f9b03b5 3137 num = low_sign_unext (num, 14);
252b5132
RH		 3138 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3139 }
3140 else
3141 {
3142 if (is_DP_relative (the_insn.exp))
3143 the_insn.reloc = R_HPPA_GOTOFF;
3144 else if (is_PC_relative (the_insn.exp))
3145 the_insn.reloc = R_HPPA_PCREL_CALL;
3146 else
3147 the_insn.reloc = R_HPPA;
3148 the_insn.format = 14;
3149 continue;
3150 }
3151
3152 /* Handle a 21 bit immediate at 31. */
3153 case 'k':
3154 the_insn.field_selector = pa_chk_field_selector (&s);
3155 get_expression (s);
3156 s = expr_end;
3157 if (the_insn.exp.X_op == O_constant)
3158 {
3159 num = evaluate_absolute (&the_insn);
3160 CHECK_FIELD (num >> 11, 1048575, -1048576, 0);
ad1079af 3161 opcode |= re_assemble_21 (num);
3f9b03b5 3162 continue;
252b5132
RH		 3163 }
3164 else
3165 {
3166 if (is_DP_relative (the_insn.exp))
3167 the_insn.reloc = R_HPPA_GOTOFF;
3168 else if (is_PC_relative (the_insn.exp))
3169 the_insn.reloc = R_HPPA_PCREL_CALL;
3170 else
3171 the_insn.reloc = R_HPPA;
3172 the_insn.format = 21;
3173 continue;
3174 }
3175
a02fab7e
JL		 3176 /* Handle a 16 bit immediate at 31 (PA 2.0 wide mode only). */
3177 case 'l':
3178 the_insn.field_selector = pa_chk_field_selector (&s);
3179 get_expression (s);
3180 s = expr_end;
3181 if (the_insn.exp.X_op == O_constant)
3182 {
a02fab7e
JL		 3183 num = evaluate_absolute (&the_insn);
3184 CHECK_FIELD (num, 32767, -32768, 0);
ad1079af 3185 opcode |= re_assemble_16 (num);
3f9b03b5 3186 continue;
a02fab7e
JL		 3187 }
3188 else
3189 {
3190 /* ??? Is this valid for wide mode? */
3191 if (is_DP_relative (the_insn.exp))
3192 the_insn.reloc = R_HPPA_GOTOFF;
3193 else if (is_PC_relative (the_insn.exp))
3194 the_insn.reloc = R_HPPA_PCREL_CALL;
3195 else
3196 the_insn.reloc = R_HPPA;
3197 the_insn.format = 14;
3198 continue;
3199 }
3200
3201 /* Handle a word-aligned 16-bit imm. at 31 (PA2.0 wide). */
3202 case 'y':
3203 the_insn.field_selector = pa_chk_field_selector (&s);
3204 get_expression (s);
3205 s = expr_end;
3206 if (the_insn.exp.X_op == O_constant)
3207 {
a02fab7e
JL		 3208 num = evaluate_absolute (&the_insn);
3209 CHECK_FIELD (num, 32767, -32768, 0);
3210 CHECK_ALIGN (num, 4, 0);
ad1079af 3211 opcode |= re_assemble_16 (num);
3f9b03b5 3212 continue;
a02fab7e
JL		 3213 }
3214 else
3215 {
3216 /* ??? Is this valid for wide mode? */
3217 if (is_DP_relative (the_insn.exp))
3218 the_insn.reloc = R_HPPA_GOTOFF;
3219 else if (is_PC_relative (the_insn.exp))
3220 the_insn.reloc = R_HPPA_PCREL_CALL;
3221 else
3222 the_insn.reloc = R_HPPA;
3223 the_insn.format = 14;
3224 continue;
3225 }
3226
3227 /* Handle a dword-aligned 16-bit imm. at 31 (PA2.0 wide). */
3228 case '&':
3229 the_insn.field_selector = pa_chk_field_selector (&s);
3230 get_expression (s);
3231 s = expr_end;
3232 if (the_insn.exp.X_op == O_constant)
3233 {
a02fab7e
JL		 3234 num = evaluate_absolute (&the_insn);
3235 CHECK_FIELD (num, 32767, -32768, 0);
3236 CHECK_ALIGN (num, 8, 0);
ad1079af 3237 opcode |= re_assemble_16 (num);
3f9b03b5 3238 continue;
a02fab7e
JL		 3239 }
3240 else
3241 {
3242 /* ??? Is this valid for wide mode? */
3243 if (is_DP_relative (the_insn.exp))
3244 the_insn.reloc = R_HPPA_GOTOFF;
3245 else if (is_PC_relative (the_insn.exp))
3246 the_insn.reloc = R_HPPA_PCREL_CALL;
3247 else
3248 the_insn.reloc = R_HPPA;
3249 the_insn.format = 14;
3250 continue;
3251 }
3252
252b5132
RH		 3253 /* Handle a 12 bit branch displacement. */
3254 case 'w':
3255 the_insn.field_selector = pa_chk_field_selector (&s);
3256 get_expression (s);
3257 s = expr_end;
3258 the_insn.pcrel = 1;
22862cde
AM		 3259 if (!the_insn.exp.X_add_symbol
3260 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
ec8b3afd 3261 FAKE_LABEL_NAME))
252b5132 3262 {
252b5132
RH		 3263 num = evaluate_absolute (&the_insn);
3264 if (num % 4)
3265 {
3266 as_bad (_("Branch to unaligned address"));
3267 break;
3268 }
22862cde
AM		 3269 if (the_insn.exp.X_add_symbol)
3270 num -= 8;
3271 CHECK_FIELD (num, 8191, -8192, 0);
3272 opcode |= re_assemble_12 (num >> 2);
3f9b03b5 3273 continue;
252b5132
RH		 3274 }
3275 else
3276 {
3277 the_insn.reloc = R_HPPA_PCREL_CALL;
3278 the_insn.format = 12;
3279 the_insn.arg_reloc = last_call_desc.arg_reloc;
3280 memset (&last_call_desc, 0, sizeof (struct call_desc));
3281 s = expr_end;
3282 continue;
3283 }
3284
3285 /* Handle a 17 bit branch displacement. */
3286 case 'W':
3287 the_insn.field_selector = pa_chk_field_selector (&s);
3288 get_expression (s);
3289 s = expr_end;
3290 the_insn.pcrel = 1;
3291 if (!the_insn.exp.X_add_symbol
3292 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
ec8b3afd 3293 FAKE_LABEL_NAME))
252b5132 3294 {
252b5132
RH		 3295 num = evaluate_absolute (&the_insn);
3296 if (num % 4)
3297 {
3298 as_bad (_("Branch to unaligned address"));
3299 break;
3300 }
252b5132
RH		 3301 if (the_insn.exp.X_add_symbol)
3302 num -= 8;
22862cde 3303 CHECK_FIELD (num, 262143, -262144, 0);
ad1079af 3304 opcode |= re_assemble_17 (num >> 2);
3f9b03b5 3305 continue;
252b5132
RH		 3306 }
3307 else
3308 {
3309 the_insn.reloc = R_HPPA_PCREL_CALL;
3310 the_insn.format = 17;
3311 the_insn.arg_reloc = last_call_desc.arg_reloc;
3312 memset (&last_call_desc, 0, sizeof (struct call_desc));
3313 continue;
3314 }
3315
77c02e18
JL		 3316 /* Handle a 22 bit branch displacement. */
3317 case 'X':
3318 the_insn.field_selector = pa_chk_field_selector (&s);
3319 get_expression (s);
3320 s = expr_end;
3321 the_insn.pcrel = 1;
3322 if (!the_insn.exp.X_add_symbol
3323 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
ec8b3afd 3324 FAKE_LABEL_NAME))
77c02e18 3325 {
77c02e18
JL		 3326 num = evaluate_absolute (&the_insn);
3327 if (num % 4)
3328 {
3329 as_bad (_("Branch to unaligned address"));
3330 break;
3331 }
77c02e18
JL		 3332 if (the_insn.exp.X_add_symbol)
3333 num -= 8;
22862cde 3334 CHECK_FIELD (num, 8388607, -8388608, 0);
ad1079af 3335 opcode |= re_assemble_22 (num >> 2);
77c02e18
JL		 3336 }
3337 else
3338 {
3339 the_insn.reloc = R_HPPA_PCREL_CALL;
3340 the_insn.format = 22;
3341 the_insn.arg_reloc = last_call_desc.arg_reloc;
3342 memset (&last_call_desc, 0, sizeof (struct call_desc));
3343 continue;
3344 }
3345
252b5132
RH		 3346 /* Handle an absolute 17 bit branch target. */
3347 case 'z':
3348 the_insn.field_selector = pa_chk_field_selector (&s);
3349 get_expression (s);
3350 s = expr_end;
3351 the_insn.pcrel = 0;
3352 if (!the_insn.exp.X_add_symbol
3353 || !strcmp (S_GET_NAME (the_insn.exp.X_add_symbol),
ec8b3afd 3354 FAKE_LABEL_NAME))
252b5132 3355 {
252b5132
RH		 3356 num = evaluate_absolute (&the_insn);
3357 if (num % 4)
3358 {
3359 as_bad (_("Branch to unaligned address"));
3360 break;
3361 }
252b5132
RH		 3362 if (the_insn.exp.X_add_symbol)
3363 num -= 8;
22862cde 3364 CHECK_FIELD (num, 262143, -262144, 0);
ad1079af 3365 opcode |= re_assemble_17 (num >> 2);
3f9b03b5 3366 continue;
252b5132
RH		 3367 }
3368 else
3369 {
3370 the_insn.reloc = R_HPPA_ABS_CALL;
3371 the_insn.format = 17;
3372 the_insn.arg_reloc = last_call_desc.arg_reloc;
3373 memset (&last_call_desc, 0, sizeof (struct call_desc));
3374 continue;
3375 }
3376
4964086a
JL		 3377 /* Handle '%r1' implicit operand of addil instruction. */
3378 case 'Z':
3379 if (*s == ',' && *(s + 1) == '%' && *(s + 3) == '1'
3380 && (*(s + 2) == 'r' || *(s + 2) == 'R'))
3381 {
3382 s += 4;
3383 continue;
3384 }
3385 else
3386 break;
3387
ce674324
JL		 3388 /* Handle '%sr0,%r31' implicit operand of be,l instruction. */
3389 case 'Y':
3390 if (strncasecmp (s, "%sr0,%r31", 9) != 0)
3391 break;
3392 s += 9;
3393 continue;
3394
d53d2751
JL		 3395 /* Handle immediate value of 0 for ordered load/store instructions. */
3396 case '@':
3397 if (*s != '0')
3398 break;
3399 s++;
3400 continue;
3401
a97685e9
JL		 3402 /* Handle a 2 bit shift count at 25. */
3403 case '.':
3404 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3405 if (strict && the_insn.exp.X_op != O_constant)
3406 break;
a97685e9 3407 s = expr_end;
0f4f8b56 3408 CHECK_FIELD (num, 3, 1, strict);
a97685e9
JL		 3409 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3410
413c94ba
JL		 3411 /* Handle a 4 bit shift count at 25. */
3412 case '*':
3413 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3414 if (strict && the_insn.exp.X_op != O_constant)
3415 break;
413c94ba 3416 s = expr_end;
0f4f8b56 3417 CHECK_FIELD (num, 15, 0, strict);
413c94ba
JL		 3418 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3419
252b5132
RH		 3420 /* Handle a 5 bit shift count at 26. */
3421 case 'p':
3422 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3423 if (strict && the_insn.exp.X_op != O_constant)
3424 break;
252b5132 3425 s = expr_end;
0f4f8b56 3426 CHECK_FIELD (num, 31, 0, strict);
252b5132
RH		 3427 INSERT_FIELD_AND_CONTINUE (opcode, 31 - num, 5);
3428
a97685e9
JL		 3429 /* Handle a 6 bit shift count at 20,22:26. */
3430 case '~':
3431 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3432 if (strict && the_insn.exp.X_op != O_constant)
3433 break;
a97685e9 3434 s = expr_end;
0f4f8b56 3435 CHECK_FIELD (num, 63, 0, strict);
a97685e9
JL		 3436 num = 63 - num;
3437 opcode |= (num & 0x20) << 6;
3438 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
3439
9e4f2d3a
JL		 3440 /* Handle a 6 bit field length at 23,27:31. */
3441 case '%':
3442 flag = 0;
3443 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3444 if (strict && the_insn.exp.X_op != O_constant)
3445 break;
9e4f2d3a 3446 s = expr_end;
0f4f8b56 3447 CHECK_FIELD (num, 64, 1, strict);
9e4f2d3a
JL		 3448 num--;
3449 opcode |= (num & 0x20) << 3;
3450 num = 31 - (num & 0x1f);
3451 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3452
3453 /* Handle a 6 bit field length at 19,27:31. */
3454 case '|':
3455 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3456 if (strict && the_insn.exp.X_op != O_constant)
3457 break;
9e4f2d3a 3458 s = expr_end;
0f4f8b56 3459 CHECK_FIELD (num, 64, 1, strict);
9e4f2d3a
JL		 3460 num--;
3461 opcode |= (num & 0x20) << 7;
3462 num = 31 - (num & 0x1f);
3463 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3464
252b5132
RH		 3465 /* Handle a 5 bit bit position at 26. */
3466 case 'P':
3467 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3468 if (strict && the_insn.exp.X_op != O_constant)
3469 break;
252b5132 3470 s = expr_end;
0f4f8b56 3471 CHECK_FIELD (num, 31, 0, strict);
252b5132
RH		 3472 INSERT_FIELD_AND_CONTINUE (opcode, num, 5);
3473
9e4f2d3a
JL		 3474 /* Handle a 6 bit bit position at 20,22:26. */
3475 case 'q':
3476 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3477 if (strict && the_insn.exp.X_op != O_constant)
3478 break;
9e4f2d3a 3479 s = expr_end;
0f4f8b56 3480 CHECK_FIELD (num, 63, 0, strict);
9e4f2d3a
JL		 3481 opcode |= (num & 0x20) << 6;
3482 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 5);
3483
afbf211f
JL		 3484 /* Handle a 5 bit immediate at 10 with 'd' as the complement
3485 of the high bit of the immediate. */
3486 case 'B':
3487 num = pa_get_absolute_expression (&the_insn, &s);
3488 if (strict && the_insn.exp.X_op != O_constant)
3489 break;
3490 s = expr_end;
3491 CHECK_FIELD (num, 63, 0, strict);
3492 if (num & 0x20)
3493 ;
3494 else
3495 opcode |= (1 << 13);
3496 INSERT_FIELD_AND_CONTINUE (opcode, num & 0x1f, 21);
3497
252b5132
RH		 3498 /* Handle a 5 bit immediate at 10. */
3499 case 'Q':
252b5132 3500 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3501 if (strict && the_insn.exp.X_op != O_constant)
3502 break;
252b5132 3503 s = expr_end;
0f4f8b56 3504 CHECK_FIELD (num, 31, 0, strict);
252b5132
RH		 3505 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
3506
a97685e9
JL		 3507 /* Handle a 9 bit immediate at 28. */
3508 case '$':
3509 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3510 if (strict && the_insn.exp.X_op != O_constant)
3511 break;
a97685e9 3512 s = expr_end;
0f4f8b56 3513 CHECK_FIELD (num, 511, 1, strict);
a97685e9 3514 INSERT_FIELD_AND_CONTINUE (opcode, num, 3);
d53d2751 3515
252b5132
RH		 3516 /* Handle a 13 bit immediate at 18. */
3517 case 'A':
3518 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3519 if (strict && the_insn.exp.X_op != O_constant)
3520 break;
252b5132 3521 s = expr_end;
0f4f8b56 3522 CHECK_FIELD (num, 8191, 0, strict);
252b5132
RH		 3523 INSERT_FIELD_AND_CONTINUE (opcode, num, 13);
3524
3525 /* Handle a 26 bit immediate at 31. */
3526 case 'D':
3527 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3528 if (strict && the_insn.exp.X_op != O_constant)
3529 break;
252b5132 3530 s = expr_end;
0485cba3 3531 CHECK_FIELD (num, 67108863, 0, strict);
252b5132
RH		 3532 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3533
3534 /* Handle a 3 bit SFU identifier at 25. */
97e1581b 3535 case 'v':
252b5132
RH		 3536 if (*s++ != ',')
3537 as_bad (_("Invalid SFU identifier"));
3538 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3539 if (strict && the_insn.exp.X_op != O_constant)
3540 break;
252b5132 3541 s = expr_end;
0f4f8b56 3542 CHECK_FIELD (num, 7, 0, strict);
252b5132
RH		 3543 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3544
3545 /* Handle a 20 bit SOP field for spop0. */
3546 case 'O':
3547 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3548 if (strict && the_insn.exp.X_op != O_constant)
3549 break;
252b5132 3550 s = expr_end;
0f4f8b56 3551 CHECK_FIELD (num, 1048575, 0, strict);
252b5132
RH		 3552 num = (num & 0x1f) | ((num & 0x000fffe0) << 6);
3553 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3554
3555 /* Handle a 15bit SOP field for spop1. */
3556 case 'o':
3557 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3558 if (strict && the_insn.exp.X_op != O_constant)
3559 break;
252b5132 3560 s = expr_end;
0f4f8b56 3561 CHECK_FIELD (num, 32767, 0, strict);
252b5132
RH		 3562 INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
3563
3564 /* Handle a 10bit SOP field for spop3. */
3565 case '0':
3566 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3567 if (strict && the_insn.exp.X_op != O_constant)
3568 break;
252b5132 3569 s = expr_end;
0f4f8b56 3570 CHECK_FIELD (num, 1023, 0, strict);
252b5132
RH		 3571 num = (num & 0x1f) | ((num & 0x000003e0) << 6);
3572 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3573
3574 /* Handle a 15 bit SOP field for spop2. */
3575 case '1':
3576 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3577 if (strict && the_insn.exp.X_op != O_constant)
3578 break;
252b5132 3579 s = expr_end;
0f4f8b56 3580 CHECK_FIELD (num, 32767, 0, strict);
252b5132
RH		 3581 num = (num & 0x1f) | ((num & 0x00007fe0) << 6);
3582 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3583
3584 /* Handle a 3-bit co-processor ID field. */
3585 case 'u':
3586 if (*s++ != ',')
3587 as_bad (_("Invalid COPR identifier"));
3588 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3589 if (strict && the_insn.exp.X_op != O_constant)
3590 break;
252b5132 3591 s = expr_end;
0f4f8b56 3592 CHECK_FIELD (num, 7, 0, strict);
252b5132
RH		 3593 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
3594
3595 /* Handle a 22bit SOP field for copr. */
3596 case '2':
3597 num = pa_get_absolute_expression (&the_insn, &s);
0f4f8b56
JL		 3598 if (strict && the_insn.exp.X_op != O_constant)
3599 break;
252b5132 3600 s = expr_end;
0f4f8b56 3601 CHECK_FIELD (num, 4194303, 0, strict);
252b5132
RH		 3602 num = (num & 0x1f) | ((num & 0x003fffe0) << 4);
3603 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
3604
1cf6ae67
JL		 3605 /* Handle a source FP operand format completer. */
3606 case '{':
3607 if (*s == ',' && *(s+1) == 't')
3608 {
3609 the_insn.trunc = 1;
3610 s += 2;
3611 }
3612 else
3613 the_insn.trunc = 0;
3614 flag = pa_parse_fp_cnv_format (&s);
3615 the_insn.fpof1 = flag;
3616 if (flag == W || flag == UW)
3617 flag = SGL;
3618 if (flag == DW || flag == UDW)
3619 flag = DBL;
3620 if (flag == QW || flag == UQW)
3621 flag = QUAD;
3622 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3623
3624 /* Handle a destination FP operand format completer. */
3625 case '_':
3626 /* pa_parse_format needs the ',' prefix. */
3627 s--;
3628 flag = pa_parse_fp_cnv_format (&s);
3629 the_insn.fpof2 = flag;
3630 if (flag == W || flag == UW)
3631 flag = SGL;
3632 if (flag == DW || flag == UDW)
3633 flag = DBL;
3634 if (flag == QW || flag == UQW)
3635 flag = QUAD;
3636 opcode |= flag << 13;
3637 if (the_insn.fpof1 == SGL
d53d2751 3638 || the_insn.fpof1 == DBL
1cf6ae67
JL		 3639 || the_insn.fpof1 == QUAD)
3640 {
3641 if (the_insn.fpof2 == SGL
3642 || the_insn.fpof2 == DBL
3643 || the_insn.fpof2 == QUAD)
3644 flag = 0;
3645 else if (the_insn.fpof2 == W
3646 || the_insn.fpof2 == DW
3647 || the_insn.fpof2 == QW)
3648 flag = 2;
3649 else if (the_insn.fpof2 == UW
3650 || the_insn.fpof2 == UDW
3651 || the_insn.fpof2 == UQW)
3652 flag = 6;
3653 else
3654 abort ();
3655 }
3656 else if (the_insn.fpof1 == W
d53d2751 3657 || the_insn.fpof1 == DW
1cf6ae67
JL		 3658 || the_insn.fpof1 == QW)
3659 {
3660 if (the_insn.fpof2 == SGL
3661 || the_insn.fpof2 == DBL
3662 || the_insn.fpof2 == QUAD)
3663 flag = 1;
3664 else
3665 abort ();
3666 }
3667 else if (the_insn.fpof1 == UW
d53d2751 3668 || the_insn.fpof1 == UDW
1cf6ae67
JL		 3669 || the_insn.fpof1 == UQW)
3670 {
3671 if (the_insn.fpof2 == SGL
3672 || the_insn.fpof2 == DBL
3673 || the_insn.fpof2 == QUAD)
3674 flag = 5;
3675 else
3676 abort ();
3677 }
3678 flag |= the_insn.trunc;
3679 INSERT_FIELD_AND_CONTINUE (opcode, flag, 15);
252b5132
RH		 3680
3681 /* Handle a source FP operand format completer. */
3682 case 'F':
3683 flag = pa_parse_fp_format (&s);
3684 the_insn.fpof1 = flag;
3685 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3686
3687 /* Handle a destination FP operand format completer. */
3688 case 'G':
3689 /* pa_parse_format needs the ',' prefix. */
3690 s--;
3691 flag = pa_parse_fp_format (&s);
3692 the_insn.fpof2 = flag;
3693 INSERT_FIELD_AND_CONTINUE (opcode, flag, 13);
3694
9ecc05f0
JL		 3695 /* Handle a source FP operand format completer at 20. */
3696 case 'I':
3697 flag = pa_parse_fp_format (&s);
3698 the_insn.fpof1 = flag;
3699 INSERT_FIELD_AND_CONTINUE (opcode, flag, 11);
3700
97e1581b
JL		 3701 /* Handle a floating point operand format at 26.
3702 Only allows single and double precision. */
3703 case 'H':
3704 flag = pa_parse_fp_format (&s);
3705 switch (flag)
3706 {
3707 case SGL:
3708 opcode |= 0x20;
3709 case DBL:
3710 the_insn.fpof1 = flag;
3711 continue;
252b5132 3712
97e1581b
JL		 3713 case QUAD:
3714 case ILLEGAL_FMT:
3715 default:
3716 as_bad (_("Invalid Floating Point Operand Format."));
3717 }
3718 break;
252b5132 3719
97e1581b
JL		 3720 /* Handle all floating point registers. */
3721 case 'f':
3722 switch (*++args)
3723 {
3724 /* Float target register. */
3725 case 't':
ecacdc7a 3726 if (!pa_parse_number (&s, 3))
0f4f8b56 3727 break;
ecacdc7a 3728 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
97e1581b
JL		 3729 CHECK_FIELD (num, 31, 0, 0);
3730 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
252b5132 3731
97e1581b
JL		 3732 /* Float target register with L/R selection. */
3733 case 'T':
252b5132 3734 {
ecacdc7a 3735 if (!pa_parse_number (&s, 1))
0f4f8b56 3736 break;
ecacdc7a
AM		 3737 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3738 CHECK_FIELD (num, 31, 0, 0);
3739 opcode |= num;
b53fcc20 3740
97e1581b
JL		 3741 /* 0x30 opcodes are FP arithmetic operation opcodes
3742 and need to be turned into 0x38 opcodes. This
3743 is not necessary for loads/stores. */
ecacdc7a 3744 if (need_pa11_opcode ()
97e1581b
JL		 3745 && ((opcode & 0xfc000000) == 0x30000000))
3746 opcode |= 1 << 27;
b53fcc20 3747
ecacdc7a
AM		 3748 opcode |= (pa_number & FP_REG_RSEL ? 1 << 6 : 0);
3749 continue;
97e1581b 3750 }
252b5132 3751
97e1581b
JL		 3752 /* Float operand 1. */
3753 case 'a':
3754 {
ecacdc7a 3755 if (!pa_parse_number (&s, 1))
0f4f8b56 3756 break;
ecacdc7a
AM		 3757 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3758 CHECK_FIELD (num, 31, 0, 0);
3759 opcode |= num << 21;
3760 if (need_pa11_opcode ())
97e1581b 3761 {
ecacdc7a 3762 opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
97e1581b
JL		 3763 opcode |= 1 << 27;
3764 }
3765 continue;
3766 }
252b5132 3767
97e1581b 3768 /* Float operand 1 with L/R selection. */
e061d86f 3769 case 'X':
97e1581b 3770 case 'A':
252b5132 3771 {
ecacdc7a 3772 if (!pa_parse_number (&s, 1))
0f4f8b56 3773 break;
ecacdc7a
AM		 3774 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3775 CHECK_FIELD (num, 31, 0, 0);
3776 opcode |= num << 21;
3777 opcode |= (pa_number & FP_REG_RSEL ? 1 << 7 : 0);
97e1581b 3778 continue;
252b5132 3779 }
252b5132 3780
97e1581b
JL		 3781 /* Float operand 2. */
3782 case 'b':
3783 {
ecacdc7a 3784 if (!pa_parse_number (&s, 1))
0f4f8b56 3785 break;
ecacdc7a
AM		 3786 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3787 CHECK_FIELD (num, 31, 0, 0);
3788 opcode |= num << 16;
3789 if (need_pa11_opcode ())
97e1581b 3790 {
ecacdc7a 3791 opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
97e1581b
JL		 3792 opcode |= 1 << 27;
3793 }
3794 continue;
3795 }
3796
3797 /* Float operand 2 with L/R selection. */
3798 case 'B':
252b5132 3799 {
ecacdc7a 3800 if (!pa_parse_number (&s, 1))
0f4f8b56 3801 break;
ecacdc7a
AM		 3802 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3803 CHECK_FIELD (num, 31, 0, 0);
3804 opcode |= num << 16;
3805 opcode |= (pa_number & FP_REG_RSEL ? 1 << 12 : 0);
97e1581b 3806 continue;
252b5132 3807 }
252b5132 3808
97e1581b
JL		 3809 /* Float operand 3 for fmpyfadd, fmpynfadd. */
3810 case 'C':
3811 {
ecacdc7a 3812 if (!pa_parse_number (&s, 1))
0f4f8b56 3813 break;
ecacdc7a
AM		 3814 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3815 CHECK_FIELD (num, 31, 0, 0);
3816 opcode |= (num & 0x1c) << 11;
3817 opcode |= (num & 0x03) << 9;
3818 opcode |= (pa_number & FP_REG_RSEL ? 1 << 8 : 0);
97e1581b
JL		 3819 continue;
3820 }
b53fcc20 3821
97e1581b
JL		 3822 /* Float mult operand 1 for fmpyadd, fmpysub */
3823 case 'i':
3824 {
ecacdc7a 3825 if (!pa_parse_number (&s, 1))
0f4f8b56 3826 break;
ecacdc7a
AM		 3827 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3828 CHECK_FIELD (num, 31, 0, 0);
97e1581b
JL		 3829 if (the_insn.fpof1 == SGL)
3830 {
ecacdc7a 3831 if (num < 16)
97e1581b
JL		 3832 {
3833 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3834 break;
3835 }
ecacdc7a
AM		 3836 num &= 0xF;
3837 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
97e1581b 3838 }
ecacdc7a 3839 INSERT_FIELD_AND_CONTINUE (opcode, num, 21);
97e1581b
JL		 3840 }
3841
3842 /* Float mult operand 2 for fmpyadd, fmpysub */
3843 case 'j':
252b5132 3844 {
ecacdc7a 3845 if (!pa_parse_number (&s, 1))
0f4f8b56 3846 break;
ecacdc7a
AM		 3847 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3848 CHECK_FIELD (num, 31, 0, 0);
97e1581b 3849 if (the_insn.fpof1 == SGL)
252b5132 3850 {
ecacdc7a 3851 if (num < 16)
97e1581b 3852 {
ecacdc7a
AM		 3853 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3854 break;
97e1581b 3855 }
ecacdc7a
AM		 3856 num &= 0xF;
3857 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
252b5132 3858 }
ecacdc7a 3859 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
252b5132 3860 }
252b5132 3861
97e1581b
JL		 3862 /* Float mult target for fmpyadd, fmpysub */
3863 case 'k':
252b5132 3864 {
ecacdc7a 3865 if (!pa_parse_number (&s, 1))
0f4f8b56 3866 break;
ecacdc7a
AM		 3867 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3868 CHECK_FIELD (num, 31, 0, 0);
97e1581b 3869 if (the_insn.fpof1 == SGL)
252b5132 3870 {
ecacdc7a 3871 if (num < 16)
97e1581b 3872 {
ecacdc7a
AM		 3873 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3874 break;
97e1581b 3875 }
ecacdc7a
AM		 3876 num &= 0xF;
3877 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
252b5132 3878 }
ecacdc7a 3879 INSERT_FIELD_AND_CONTINUE (opcode, num, 0);
252b5132 3880 }
252b5132 3881
97e1581b
JL		 3882 /* Float add operand 1 for fmpyadd, fmpysub */
3883 case 'l':
252b5132 3884 {
ecacdc7a 3885 if (!pa_parse_number (&s, 1))
0f4f8b56 3886 break;
ecacdc7a
AM		 3887 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3888 CHECK_FIELD (num, 31, 0, 0);
97e1581b 3889 if (the_insn.fpof1 == SGL)
252b5132 3890 {
ecacdc7a 3891 if (num < 16)
97e1581b 3892 {
ecacdc7a
AM		 3893 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3894 break;
97e1581b 3895 }
ecacdc7a
AM		 3896 num &= 0xF;
3897 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
252b5132 3898 }
ecacdc7a 3899 INSERT_FIELD_AND_CONTINUE (opcode, num, 6);
252b5132 3900 }
252b5132 3901
97e1581b
JL		 3902 /* Float add target for fmpyadd, fmpysub */
3903 case 'm':
252b5132 3904 {
ecacdc7a 3905 if (!pa_parse_number (&s, 1))
0f4f8b56 3906 break;
ecacdc7a
AM		 3907 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3908 CHECK_FIELD (num, 31, 0, 0);
97e1581b 3909 if (the_insn.fpof1 == SGL)
252b5132 3910 {
ecacdc7a 3911 if (num < 16)
97e1581b 3912 {
ecacdc7a
AM		 3913 as_bad (_("Invalid register for single precision fmpyadd or fmpysub"));
3914 break;
97e1581b 3915 }
ecacdc7a
AM		 3916 num &= 0xF;
3917 num |= (pa_number & FP_REG_RSEL ? 1 << 4 : 0);
252b5132 3918 }
ecacdc7a 3919 INSERT_FIELD_AND_CONTINUE (opcode, num, 11);
252b5132 3920 }
252b5132 3921
71823da4 3922 /* Handle L/R register halves like 'x'. */
a02fab7e 3923 case 'E':
71823da4
JL		 3924 case 'e':
3925 {
ecacdc7a 3926 if (!pa_parse_number (&s, 1))
71823da4 3927 break;
ecacdc7a
AM		 3928 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
3929 CHECK_FIELD (num, 31, 0, 0);
3930 opcode |= num << 16;
3931 if (need_pa11_opcode ())
71823da4 3932 {
ecacdc7a 3933 opcode |= (pa_number & FP_REG_RSEL ? 1 << 1 : 0);
71823da4
JL		 3934 }
3935 continue;
d3426803 3936 }
a02fab7e
JL		 3937
3938 /* Float target register (PA 2.0 wide). */
3939 case 'x':
ecacdc7a 3940 if (!pa_parse_number (&s, 3))
a02fab7e 3941 break;
ecacdc7a 3942 num = (pa_number & ~FP_REG_RSEL) - FP_REG_BASE;
a02fab7e
JL		 3943 CHECK_FIELD (num, 31, 0, 0);
3944 INSERT_FIELD_AND_CONTINUE (opcode, num, 16);
3945
97e1581b
JL		 3946 default:
3947 abort ();
3948 }
3949 break;
3950
252b5132
RH		 3951 default:
3952 abort ();
3953 }
3954 break;
3955 }
3956
9f45e54b
DA		 3957 /* If this instruction is specific to a particular architecture,
3958 then set a new architecture. This automatic promotion crud is
3959 for compatibility with HP's old assemblers only. */
3960 if (match == TRUE
3961 && bfd_get_mach (stdoutput) < insn->arch)
3962 {
8126167b
DA		 3963 if (need_promotion)
3964 {
3965 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, insn->arch))
3966 as_warn (_("could not update architecture and machine"));
3967 }
3968 else
3969 {
3970 match = FALSE;
3971 if (!promoted_insn)
3972 promoted_insn = insn;
3973 }
9f45e54b
DA		 3974 }
3975
252b5132
RH		 3976 failed:
3977 /* Check if the args matched. */
b34976b6 3978 if (!match)
252b5132
RH		 3979 {
3980 if (&insn[1] - pa_opcodes < (int) NUMOPCODES
3981 && !strcmp (insn->name, insn[1].name))
3982 {
3983 ++insn;
3984 s = argstart;
3985 continue;
3986 }
3987 else
3988 {
8126167b
DA		 3989 if (promoted_insn)
3990 {
3991 insn = promoted_insn;
3992 need_promotion = TRUE;
3993 s = argstart;
3994 continue;
3995 }
252b5132
RH		 3996 as_bad (_("Invalid operands %s"), error_message);
3997 return;
3998 }
3999 }
4000 break;
4001 }
4002
4003 the_insn.opcode = opcode;
4004}
4005
4006/* Turn a string in input_line_pointer into a floating point constant of type
4007 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
4008 emitted is stored in *sizeP . An error message or NULL is returned. */
4009
4010#define MAX_LITTLENUMS 6
4011
4012char *
4013md_atof (type, litP, sizeP)
4014 char type;
4015 char *litP;
4016 int *sizeP;
4017{
4018 int prec;
4019 LITTLENUM_TYPE words[MAX_LITTLENUMS];
4020 LITTLENUM_TYPE *wordP;
4021 char *t;
4022
4023 switch (type)
4024 {
4025
4026 case 'f':
4027 case 'F':
4028 case 's':
4029 case 'S':
4030 prec = 2;
4031 break;
4032
4033 case 'd':
4034 case 'D':
4035 case 'r':
4036 case 'R':
4037 prec = 4;
4038 break;
4039
4040 case 'x':
4041 case 'X':
4042 prec = 6;
4043 break;
4044
4045 case 'p':
4046 case 'P':
4047 prec = 6;
4048 break;
4049
4050 default:
4051 *sizeP = 0;
4052 return _("Bad call to MD_ATOF()");
4053 }
4054 t = atof_ieee (input_line_pointer, type, words);
4055 if (t)
4056 input_line_pointer = t;
4057 *sizeP = prec * sizeof (LITTLENUM_TYPE);
4058 for (wordP = words; prec--;)
4059 {
4060 md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
4061 litP += sizeof (LITTLENUM_TYPE);
4062 }
4063 return NULL;
4064}
4065
4066/* Write out big-endian. */
4067
4068void
4069md_number_to_chars (buf, val, n)
4070 char *buf;
4071 valueT val;
4072 int n;
4073{
4074 number_to_chars_bigendian (buf, val, n);
4075}
4076
4077/* Translate internal representation of relocation info to BFD target
4078 format. */
4079
4080arelent **
4081tc_gen_reloc (section, fixp)
4082 asection *section;
4083 fixS *fixp;
4084{
4085 arelent *reloc;
4086 struct hppa_fix_struct *hppa_fixp;
252b5132
RH		 4087 static arelent *no_relocs = NULL;
4088 arelent **relocs;
ad1079af
AM		 4089 reloc_type **codes;
4090 reloc_type code;
252b5132
RH		 4091 int n_relocs;
4092 int i;
4093
4094 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
4095 if (fixp->fx_addsy == 0)
4096 return &no_relocs;
ad1079af 4097
252b5132
RH		 4098 assert (hppa_fixp != 0);
4099 assert (section != 0);
4100
4101 reloc = (arelent *) xmalloc (sizeof (arelent));
4102
a0f75b47
ILT		 4103 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4104 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
ad1079af 4105 codes = hppa_gen_reloc_type (stdoutput,
252b5132
RH		 4106 fixp->fx_r_type,
4107 hppa_fixp->fx_r_format,
4108 hppa_fixp->fx_r_field,
4109 fixp->fx_subsy != NULL,
a0f75b47 4110 symbol_get_bfdsym (fixp->fx_addsy));
252b5132
RH		 4111
4112 if (codes == NULL)
5506e1a5 4113 {
b091f402 4114 as_bad_where (fixp->fx_file, fixp->fx_line, _("Cannot handle fixup"));
5506e1a5
AM		 4115 abort ();
4116 }
252b5132
RH		 4117
4118 for (n_relocs = 0; codes[n_relocs]; n_relocs++)
4119 ;
4120
4121 relocs = (arelent **) xmalloc (sizeof (arelent *) * n_relocs + 1);
4122 reloc = (arelent *) xmalloc (sizeof (arelent) * n_relocs);
4123 for (i = 0; i < n_relocs; i++)
4124 relocs[i] = &reloc[i];
4125
4126 relocs[n_relocs] = NULL;
4127
4128#ifdef OBJ_ELF
4129 switch (fixp->fx_r_type)
4130 {
4131 default:
4132 assert (n_relocs == 1);
4133
4134 code = *codes[0];
4135
252b5132
RH		 4136 /* Now, do any processing that is dependent on the relocation type. */
4137 switch (code)
4138 {
4139 case R_PARISC_DLTREL21L:
4140 case R_PARISC_DLTREL14R:
4141 case R_PARISC_DLTREL14F:
4142 case R_PARISC_PLABEL32:
4143 case R_PARISC_PLABEL21L:
4144 case R_PARISC_PLABEL14R:
4145 /* For plabel relocations, the addend of the
4146 relocation should be either 0 (no static link) or 2
904a31bf
AM		 4147 (static link required). This adjustment is done in
4148 bfd/elf32-hppa.c:elf32_hppa_relocate_section.
252b5132
RH		 4149
4150 We also slam a zero addend into the DLT relative relocs;
4151 it doesn't make a lot of sense to use any addend since
4152 it gets you a different (eg unknown) DLT entry. */
4153 reloc->addend = 0;
4154 break;
4155
ad1079af 4156#ifdef ELF_ARG_RELOC
252b5132
RH		 4157 case R_PARISC_PCREL17R:
4158 case R_PARISC_PCREL17F:
4159 case R_PARISC_PCREL17C:
ad1079af
AM		 4160 case R_PARISC_DIR17R:
4161 case R_PARISC_DIR17F:
ad1079af
AM		 4162 case R_PARISC_PCREL21L:
4163 case R_PARISC_DIR21L:
904a31bf
AM		 4164 reloc->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc,
4165 fixp->fx_offset);
ad1079af
AM		 4166 break;
4167#endif
4168
64afeba3
AM		 4169 case R_PARISC_DIR32:
4170 /* Facilitate hand-crafted unwind info. */
4171 if (strcmp (section->name, UNWIND_SECTION_NAME) == 0)
4172 code = R_PARISC_SEGREL32;
4173 /* Fall thru */
4174
252b5132
RH		 4175 default:
4176 reloc->addend = fixp->fx_offset;
4177 break;
4178 }
64afeba3
AM		 4179
4180 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4181 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4182 reloc->howto = bfd_reloc_type_lookup (stdoutput,
4183 (bfd_reloc_code_real_type) code);
4184 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
4185
4186 assert (reloc->howto && (unsigned int) code == reloc->howto->type);
252b5132
RH		 4187 break;
4188 }
4189#else /* OBJ_SOM */
4190
4191 /* Walk over reach relocation returned by the BFD backend. */
4192 for (i = 0; i < n_relocs; i++)
4193 {
4194 code = *codes[i];
4195
398e8c25
ILT		 4196 relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4197 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
ad1079af
AM		 4198 relocs[i]->howto =
4199 bfd_reloc_type_lookup (stdoutput,
4200 (bfd_reloc_code_real_type) code);
252b5132
RH		 4201 relocs[i]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4202
4203 switch (code)
4204 {
4205 case R_COMP2:
4206 /* The only time we ever use a R_COMP2 fixup is for the difference
4207 of two symbols. With that in mind we fill in all four
4208 relocs now and break out of the loop. */
4209 assert (i == 1);
993142d5 4210 relocs[0]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
ad1079af
AM		 4211 relocs[0]->howto =
4212 bfd_reloc_type_lookup (stdoutput,
4213 (bfd_reloc_code_real_type) *codes[0]);
252b5132
RH		 4214 relocs[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4215 relocs[0]->addend = 0;
993142d5
ILT		 4216 relocs[1]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4217 *relocs[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
ad1079af
AM		 4218 relocs[1]->howto =
4219 bfd_reloc_type_lookup (stdoutput,
4220 (bfd_reloc_code_real_type) *codes[1]);
252b5132
RH		 4221 relocs[1]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4222 relocs[1]->addend = 0;
993142d5
ILT		 4223 relocs[2]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4224 *relocs[2]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
ad1079af
AM		 4225 relocs[2]->howto =
4226 bfd_reloc_type_lookup (stdoutput,
4227 (bfd_reloc_code_real_type) *codes[2]);
252b5132
RH		 4228 relocs[2]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4229 relocs[2]->addend = 0;
993142d5 4230 relocs[3]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
ad1079af
AM		 4231 relocs[3]->howto =
4232 bfd_reloc_type_lookup (stdoutput,
4233 (bfd_reloc_code_real_type) *codes[3]);
252b5132
RH		 4234 relocs[3]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4235 relocs[3]->addend = 0;
993142d5 4236 relocs[4]->sym_ptr_ptr = (asymbol **) &(bfd_abs_symbol);
ad1079af
AM		 4237 relocs[4]->howto =
4238 bfd_reloc_type_lookup (stdoutput,
4239 (bfd_reloc_code_real_type) *codes[4]);
252b5132
RH		 4240 relocs[4]->address = fixp->fx_frag->fr_address + fixp->fx_where;
4241 relocs[4]->addend = 0;
4242 goto done;
4243 case R_PCREL_CALL:
4244 case R_ABS_CALL:
4245 relocs[i]->addend = HPPA_R_ADDEND (hppa_fixp->fx_arg_reloc, 0);
4246 break;
4247
4248 case R_DLT_REL:
4249 case R_DATA_PLABEL:
4250 case R_CODE_PLABEL:
4251 /* For plabel relocations, the addend of the
4252 relocation should be either 0 (no static link) or 2
4253 (static link required).
4254
4255 FIXME: We always assume no static link!
4256
4257 We also slam a zero addend into the DLT relative relocs;
4258 it doesn't make a lot of sense to use any addend since
4259 it gets you a different (eg unknown) DLT entry. */
4260 relocs[i]->addend = 0;
4261 break;
4262
4263 case R_N_MODE:
4264 case R_S_MODE:
4265 case R_D_MODE:
4266 case R_R_MODE:
4267 case R_FSEL:
4268 case R_LSEL:
4269 case R_RSEL:
4270 case R_BEGIN_BRTAB:
4271 case R_END_BRTAB:
4272 case R_BEGIN_TRY:
4273 case R_N0SEL:
4274 case R_N1SEL:
4275 /* There is no symbol or addend associated with these fixups. */
cc8a6dd0
KH		 4276 relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4277 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
252b5132
RH		 4278 relocs[i]->addend = 0;
4279 break;
4280
4281 case R_END_TRY:
4282 case R_ENTRY:
4283 case R_EXIT:
4284 /* There is no symbol associated with these fixups. */
cc8a6dd0
KH		 4285 relocs[i]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4286 *relocs[i]->sym_ptr_ptr = symbol_get_bfdsym (dummy_symbol);
252b5132
RH		 4287 relocs[i]->addend = fixp->fx_offset;
4288 break;
4289
4290 default:
4291 relocs[i]->addend = fixp->fx_offset;
4292 }
4293 }
4294
4295 done:
4296#endif
4297
4298 return relocs;
4299}
4300
4301/* Process any machine dependent frag types. */
4302
4303void
4304md_convert_frag (abfd, sec, fragP)
3f9b03b5
AM		 4305 register bfd *abfd ATTRIBUTE_UNUSED;
4306 register asection *sec ATTRIBUTE_UNUSED;
252b5132
RH		 4307 register fragS *fragP;
4308{
4309 unsigned int address;
4310
4311 if (fragP->fr_type == rs_machine_dependent)
4312 {
4313 switch ((int) fragP->fr_subtype)
4314 {
4315 case 0:
4316 fragP->fr_type = rs_fill;
4317 know (fragP->fr_var == 1);
4318 know (fragP->fr_next);
4319 address = fragP->fr_address + fragP->fr_fix;
4320 if (address % fragP->fr_offset)
4321 {
4322 fragP->fr_offset =
4323 fragP->fr_next->fr_address
4324 - fragP->fr_address
4325 - fragP->fr_fix;
4326 }
4327 else
4328 fragP->fr_offset = 0;
4329 break;
4330 }
4331 }
4332}
4333
a28a3ccf 4334/* Round up a section size to the appropriate boundary. */
252b5132
RH		 4335
4336valueT
4337md_section_align (segment, size)
4338 asection *segment;
4339 valueT size;
4340{
4341 int align = bfd_get_section_alignment (stdoutput, segment);
4342 int align2 = (1 << align) - 1;
4343
4344 return (size + align2) & ~align2;
4345}
4346
4347/* Return the approximate size of a frag before relaxation has occurred. */
4348int
4349md_estimate_size_before_relax (fragP, segment)
4350 register fragS *fragP;
3f9b03b5 4351 asection *segment ATTRIBUTE_UNUSED;
252b5132
RH		 4352{
4353 int size;
4354
4355 size = 0;
4356
4357 while ((fragP->fr_fix + size) % fragP->fr_offset)
4358 size++;
4359
4360 return size;
4361}
4362\f
ad1079af 4363#ifdef OBJ_ELF
4c400d5e
AM		 4364# ifdef WARN_COMMENTS
4365const char *md_shortopts = "Vc";
4366# else
ad1079af 4367const char *md_shortopts = "V";
4c400d5e 4368# endif
ad1079af 4369#else
4c400d5e
AM		 4370# ifdef WARN_COMMENTS
4371const char *md_shortopts = "c";
4372# else
ad1079af 4373const char *md_shortopts = "";
4c400d5e 4374# endif
ad1079af
AM		 4375#endif
4376
252b5132 4377struct option md_longopts[] = {
4c400d5e
AM		 4378#ifdef WARN_COMMENTS
4379 {"warn-comment", no_argument, NULL, 'c'},
4380#endif
252b5132
RH		 4381 {NULL, no_argument, NULL, 0}
4382};
bc805888 4383size_t md_longopts_size = sizeof (md_longopts);
252b5132
RH		 4384
4385int
4386md_parse_option (c, arg)
3f9b03b5
AM		 4387 int c ATTRIBUTE_UNUSED;
4388 char *arg ATTRIBUTE_UNUSED;
252b5132 4389{
ad1079af
AM		 4390 switch (c)
4391 {
4392 default:
4393 return 0;
4394
4395#ifdef OBJ_ELF
4396 case 'V':
4397 print_version_id ();
4398 break;
4c400d5e
AM		 4399#endif
4400#ifdef WARN_COMMENTS
4401 case 'c':
4402 warn_comment = 1;
4403 break;
ad1079af
AM		 4404#endif
4405 }
4406
4407 return 1;
252b5132
RH		 4408}
4409
4410void
4411md_show_usage (stream)
3f9b03b5 4412 FILE *stream ATTRIBUTE_UNUSED;
252b5132 4413{
4c400d5e
AM		 4414#ifdef OBJ_ELF
4415 fprintf (stream, _("\
4416 -Q ignored\n"));
4417#endif
4418#ifdef WARN_COMMENTS
4419 fprintf (stream, _("\
4420 -c print a warning if a comment is found\n"));
4421#endif
252b5132
RH		 4422}
4423\f
4424/* We have no need to default values of symbols. */
4425
4426symbolS *
4427md_undefined_symbol (name)
3f9b03b5 4428 char *name ATTRIBUTE_UNUSED;
252b5132
RH		 4429{
4430 return 0;
4431}
4432
25a8b250 4433#if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
5506e1a5
AM		 4434#define nonzero_dibits(x) \
4435 ((x) | (((x) & 0x55555555) << 1) | (((x) & 0xAAAAAAAA) >> 1))
ad1079af 4436#define arg_reloc_stub_needed(CALLER, CALLEE) \
5506e1a5 4437 (((CALLER) ^ (CALLEE)) & nonzero_dibits (CALLER) & nonzero_dibits (CALLEE))
ad1079af
AM		 4438#else
4439#define arg_reloc_stub_needed(CALLER, CALLEE) 0
4440#endif
4441
252b5132
RH		 4442/* Apply a fixup to an instruction. */
4443
94f592af 4444void
55cf6793 4445md_apply_fix (fixP, valP, seg)
252b5132 4446 fixS *fixP;
e0ac8af0 4447 valueT *valP;
94f592af 4448 segT seg ATTRIBUTE_UNUSED;
252b5132 4449{
dc1fc56b 4450 unsigned char *buf;
252b5132 4451 struct hppa_fix_struct *hppa_fixP;
3f9b03b5 4452 offsetT new_val;
dc1fc56b 4453 int insn, val, fmt;
252b5132 4454
252b5132
RH		 4455 /* SOM uses R_HPPA_ENTRY and R_HPPA_EXIT relocations which can
4456 never be "applied" (they are just markers). Likewise for
4457 R_HPPA_BEGIN_BRTAB and R_HPPA_END_BRTAB. */
4458#ifdef OBJ_SOM
4459 if (fixP->fx_r_type == R_HPPA_ENTRY
4460 || fixP->fx_r_type == R_HPPA_EXIT
4461 || fixP->fx_r_type == R_HPPA_BEGIN_BRTAB
4462 || fixP->fx_r_type == R_HPPA_END_BRTAB
4463 || fixP->fx_r_type == R_HPPA_BEGIN_TRY)
94f592af 4464 return;
252b5132
RH		 4465
4466 /* Disgusting. We must set fx_offset ourselves -- R_HPPA_END_TRY
4467 fixups are considered not adjustable, which in turn causes
4468 adjust_reloc_syms to not set fx_offset. Ugh. */
4469 if (fixP->fx_r_type == R_HPPA_END_TRY)
4470 {
94f592af
NC		 4471 fixP->fx_offset = * valP;
4472 return;
252b5132
RH		 4473 }
4474#endif
904a31bf
AM		 4475#ifdef OBJ_ELF
4476 if (fixP->fx_r_type == (int) R_PARISC_GNU_VTENTRY
4477 || fixP->fx_r_type == (int) R_PARISC_GNU_VTINHERIT)
94f592af 4478 return;
904a31bf 4479#endif
252b5132 4480
502b19cb
JL		 4481 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
4482 fixP->fx_done = 1;
4483
252b5132
RH		 4484 /* There should have been an HPPA specific fixup associated
4485 with the GAS fixup. */
dc1fc56b
AM		 4486 hppa_fixP = (struct hppa_fix_struct *) fixP->tc_fix_data;
4487 if (hppa_fixP == NULL)
252b5132 4488 {
b091f402
AM		 4489 as_bad_where (fixP->fx_file, fixP->fx_line,
4490 _("no hppa_fixup entry for fixup type 0x%x"),
4491 fixP->fx_r_type);
94f592af 4492 return;
dc1fc56b 4493 }
252b5132 4494
40d74fb1 4495 buf = (unsigned char *) (fixP->fx_frag->fr_literal + fixP->fx_where);
dc1fc56b
AM		 4496 insn = bfd_get_32 (stdoutput, buf);
4497 fmt = bfd_hppa_insn2fmt (stdoutput, insn);
5506e1a5 4498
dc1fc56b
AM		 4499 /* If there is a symbol associated with this fixup, then it's something
4500 which will need a SOM relocation (except for some PC-relative relocs).
4501 In such cases we should treat the "val" or "addend" as zero since it
4502 will be added in as needed from fx_offset in tc_gen_reloc. */
4503 if ((fixP->fx_addsy != NULL
4504 || fixP->fx_r_type == (int) R_HPPA_NONE)
252b5132 4505#ifdef OBJ_SOM
dc1fc56b 4506 && fmt != 32
252b5132 4507#endif
dc1fc56b
AM		 4508 )
4509 new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
252b5132 4510#ifdef OBJ_SOM
dc1fc56b
AM		 4511 /* These field selectors imply that we do not want an addend. */
4512 else if (hppa_fixP->fx_r_field == e_psel
4513 || hppa_fixP->fx_r_field == e_rpsel
4514 || hppa_fixP->fx_r_field == e_lpsel
4515 || hppa_fixP->fx_r_field == e_tsel
4516 || hppa_fixP->fx_r_field == e_rtsel
4517 || hppa_fixP->fx_r_field == e_ltsel)
4518 new_val = ((fmt == 12 || fmt == 17 || fmt == 22) ? 8 : 0);
252b5132 4519#endif
dc1fc56b 4520 else
94f592af 4521 new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
dc1fc56b
AM		 4522
4523 /* Handle pc-relative exceptions from above. */
4524 if ((fmt == 12 || fmt == 17 || fmt == 22)
4525 && fixP->fx_addsy
4526 && fixP->fx_pcrel
4527 && !arg_reloc_stub_needed (symbol_arg_reloc_info (fixP->fx_addsy),
4528 hppa_fixP->fx_arg_reloc)
27df9f40 4529#ifdef OBJ_ELF
94f592af
NC		 4530 && (* valP - 8 + 8192 < 16384
4531 || (fmt == 17 && * valP - 8 + 262144 < 524288)
4532 || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
27df9f40
AM		 4533#endif
4534#ifdef OBJ_SOM
94f592af
NC		 4535 && (* valP - 8 + 262144 < 524288
4536 || (fmt == 22 && * valP - 8 + 8388608 < 16777216))
27df9f40 4537#endif
dc1fc56b
AM		 4538 && !S_IS_EXTERNAL (fixP->fx_addsy)
4539 && !S_IS_WEAK (fixP->fx_addsy)
4540 && S_GET_SEGMENT (fixP->fx_addsy) == hppa_fixP->segment
4541 && !(fixP->fx_subsy
4542 && S_GET_SEGMENT (fixP->fx_subsy) != hppa_fixP->segment))
4543 {
94f592af 4544 new_val = hppa_field_adjust (* valP, 0, hppa_fixP->fx_r_field);
dc1fc56b 4545 }
3f9b03b5 4546
dc1fc56b
AM		 4547 switch (fmt)
4548 {
4549 case 10:
b091f402
AM		 4550 CHECK_FIELD_WHERE (new_val, 8191, -8192,
4551 fixP->fx_file, fixP->fx_line);
dc1fc56b 4552 val = new_val;
a02fab7e 4553
dc1fc56b
AM		 4554 insn = (insn & ~ 0x3ff1) | (((val & 0x1ff8) << 1)
4555 | ((val & 0x2000) >> 13));
4556 break;
4557 case -11:
b091f402
AM		 4558 CHECK_FIELD_WHERE (new_val, 8191, -8192,
4559 fixP->fx_file, fixP->fx_line);
dc1fc56b 4560 val = new_val;
a02fab7e 4561
dc1fc56b
AM		 4562 insn = (insn & ~ 0x3ff9) | (((val & 0x1ffc) << 1)
4563 | ((val & 0x2000) >> 13));
4564 break;
4565 /* Handle all opcodes with the 'j' operand type. */
4566 case 14:
b091f402
AM		 4567 CHECK_FIELD_WHERE (new_val, 8191, -8192,
4568 fixP->fx_file, fixP->fx_line);
dc1fc56b 4569 val = new_val;
252b5132 4570
dc1fc56b
AM		 4571 insn = ((insn & ~ 0x3fff) | low_sign_unext (val, 14));
4572 break;
252b5132 4573
dc1fc56b
AM		 4574 /* Handle all opcodes with the 'k' operand type. */
4575 case 21:
b091f402
AM		 4576 CHECK_FIELD_WHERE (new_val, 1048575, -1048576,
4577 fixP->fx_file, fixP->fx_line);
dc1fc56b 4578 val = new_val;
3f9b03b5 4579
dc1fc56b
AM		 4580 insn = (insn & ~ 0x1fffff) | re_assemble_21 (val);
4581 break;
252b5132 4582
dc1fc56b
AM		 4583 /* Handle all the opcodes with the 'i' operand type. */
4584 case 11:
b091f402
AM		 4585 CHECK_FIELD_WHERE (new_val, 1023, -1024,
4586 fixP->fx_file, fixP->fx_line);
dc1fc56b 4587 val = new_val;
252b5132 4588
dc1fc56b
AM		 4589 insn = (insn & ~ 0x7ff) | low_sign_unext (val, 11);
4590 break;
252b5132 4591
dc1fc56b
AM		 4592 /* Handle all the opcodes with the 'w' operand type. */
4593 case 12:
b091f402
AM		 4594 CHECK_FIELD_WHERE (new_val - 8, 8191, -8192,
4595 fixP->fx_file, fixP->fx_line);
dc1fc56b 4596 val = new_val - 8;
252b5132 4597
dc1fc56b
AM		 4598 insn = (insn & ~ 0x1ffd) | re_assemble_12 (val >> 2);
4599 break;
252b5132 4600
dc1fc56b
AM		 4601 /* Handle some of the opcodes with the 'W' operand type. */
4602 case 17:
4603 {
94f592af 4604 offsetT distance = * valP;
252b5132 4605
dc1fc56b
AM		 4606 /* If this is an absolute branch (ie no link) with an out of
4607 range target, then we want to complain. */
4608 if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
4609 && (insn & 0xffe00000) == 0xe8000000)
b091f402
AM		 4610 CHECK_FIELD_WHERE (distance - 8, 262143, -262144,
4611 fixP->fx_file, fixP->fx_line);
3f9b03b5 4612
b091f402
AM		 4613 CHECK_FIELD_WHERE (new_val - 8, 262143, -262144,
4614 fixP->fx_file, fixP->fx_line);
dc1fc56b 4615 val = new_val - 8;
252b5132 4616
dc1fc56b
AM		 4617 insn = (insn & ~ 0x1f1ffd) | re_assemble_17 (val >> 2);
4618 break;
4619 }
77c02e18 4620
dc1fc56b
AM		 4621 case 22:
4622 {
94f592af 4623 offsetT distance = * valP;
77c02e18 4624
dc1fc56b
AM		 4625 /* If this is an absolute branch (ie no link) with an out of
4626 range target, then we want to complain. */
4627 if (fixP->fx_r_type == (int) R_HPPA_PCREL_CALL
4628 && (insn & 0xffe00000) == 0xe8000000)
b091f402
AM		 4629 CHECK_FIELD_WHERE (distance - 8, 8388607, -8388608,
4630 fixP->fx_file, fixP->fx_line);
3f9b03b5 4631
b091f402
AM		 4632 CHECK_FIELD_WHERE (new_val - 8, 8388607, -8388608,
4633 fixP->fx_file, fixP->fx_line);
dc1fc56b 4634 val = new_val - 8;
77c02e18 4635
dc1fc56b
AM		 4636 insn = (insn & ~ 0x3ff1ffd) | re_assemble_22 (val >> 2);
4637 break;
4638 }
ad1079af 4639
dc1fc56b
AM		 4640 case -10:
4641 val = new_val;
4642 insn = (insn & ~ 0xfff1) | re_assemble_16 (val & -8);
4643 break;
ad1079af 4644
dc1fc56b
AM		 4645 case -16:
4646 val = new_val;
4647 insn = (insn & ~ 0xfff9) | re_assemble_16 (val & -4);
4648 break;
ad1079af 4649
dc1fc56b
AM		 4650 case 16:
4651 val = new_val;
4652 insn = (insn & ~ 0xffff) | re_assemble_16 (val);
4653 break;
252b5132 4654
dc1fc56b
AM		 4655 case 32:
4656 insn = new_val;
4657 break;
252b5132 4658
dc1fc56b 4659 default:
b091f402
AM		 4660 as_bad_where (fixP->fx_file, fixP->fx_line,
4661 _("Unknown relocation encountered in md_apply_fix."));
94f592af 4662 return;
252b5132 4663 }
dc1fc56b
AM		 4664
4665 /* Insert the relocation. */
4666 bfd_put_32 (stdoutput, insn, buf);
252b5132
RH		 4667}
4668
4669/* Exactly what point is a PC-relative offset relative TO?
4670 On the PA, they're relative to the address of the offset. */
4671
4672long
4673md_pcrel_from (fixP)
4674 fixS *fixP;
4675{
4676 return fixP->fx_where + fixP->fx_frag->fr_address;
4677}
4678
4679/* Return nonzero if the input line pointer is at the end of
4680 a statement. */
4681
4682static int
4683is_end_of_statement ()
4684{
4685 return ((*input_line_pointer == '\n')
4686 || (*input_line_pointer == ';')
4687 || (*input_line_pointer == '!'));
4688}
4689
4690/* Read a number from S. The number might come in one of many forms,
4691 the most common will be a hex or decimal constant, but it could be
4692 a pre-defined register (Yuk!), or an absolute symbol.
4693
ecacdc7a
AM		 4694 Return 1 on success or 0 on failure. If STRICT, then a missing
4695 register prefix will cause a failure. The number itself is
4696 returned in `pa_number'.
252b5132 4697
ecacdc7a
AM		 4698 IS_FLOAT indicates that a PA-89 FP register number should be
4699 parsed; A `l' or `r' suffix is checked for if but 2 of IS_FLOAT is
4700 not set.
252b5132
RH		 4701
4702 pa_parse_number can not handle negative constants and will fail
4703 horribly if it is passed such a constant. */
4704
4705static int
ecacdc7a 4706pa_parse_number (s, is_float)
252b5132 4707 char **s;
ecacdc7a 4708 int is_float;
252b5132
RH		 4709{
4710 int num;
4711 char *name;
4712 char c;
4713 symbolS *sym;
4714 int status;
4715 char *p = *s;
b34976b6 4716 bfd_boolean have_prefix;
252b5132
RH		 4717
4718 /* Skip whitespace before the number. */
4719 while (*p == ' ' || *p == '\t')
4720 p = p + 1;
4721
ecacdc7a
AM		 4722 pa_number = -1;
4723 have_prefix = 0;
4724 num = 0;
3882b010 4725 if (!strict && ISDIGIT (*p))
252b5132
RH		 4726 {
4727 /* Looks like a number. */
252b5132
RH		 4728
4729 if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
4730 {
4731 /* The number is specified in hex. */
4732 p += 2;
3882b010 4733 while (ISDIGIT (*p) || ((*p >= 'a') && (*p <= 'f'))
252b5132
RH		 4734 || ((*p >= 'A') && (*p <= 'F')))
4735 {
3882b010 4736 if (ISDIGIT (*p))
252b5132
RH		 4737 num = num * 16 + *p - '0';
4738 else if (*p >= 'a' && *p <= 'f')
4739 num = num * 16 + *p - 'a' + 10;
4740 else
4741 num = num * 16 + *p - 'A' + 10;
4742 ++p;
4743 }
4744 }
4745 else
4746 {
4747 /* The number is specified in decimal. */
3882b010 4748 while (ISDIGIT (*p))
252b5132
RH		 4749 {
4750 num = num * 10 + *p - '0';
4751 ++p;
4752 }
4753 }
4754
ecacdc7a 4755 pa_number = num;
252b5132 4756
ecacdc7a
AM		 4757 /* Check for a `l' or `r' suffix. */
4758 if (is_float)
4759 {
4760 pa_number += FP_REG_BASE;
4761 if (! (is_float & 2))
252b5132 4762 {
ecacdc7a
AM		 4763 if (IS_R_SELECT (p))
4764 {
4765 pa_number += FP_REG_RSEL;
4766 ++p;
4767 }
4768 else if (IS_L_SELECT (p))
4769 {
4770 ++p;
4771 }
252b5132 4772 }
252b5132
RH		 4773 }
4774 }
4775 else if (*p == '%')
4776 {
4777 /* The number might be a predefined register. */
ecacdc7a 4778 have_prefix = 1;
252b5132
RH		 4779 name = p;
4780 p++;
4781 c = *p;
4782 /* Tege hack: Special case for general registers as the general
4783 code makes a binary search with case translation, and is VERY
a28a3ccf 4784 slow. */
252b5132
RH		 4785 if (c == 'r')
4786 {
4787 p++;
4788 if (*p == 'e' && *(p + 1) == 't'
4789 && (*(p + 2) == '0' || *(p + 2) == '1'))
4790 {
4791 p += 2;
4792 num = *p - '0' + 28;
4793 p++;
4794 }
4795 else if (*p == 'p')
4796 {
4797 num = 2;
4798 p++;
4799 }
3882b010 4800 else if (!ISDIGIT (*p))
252b5132
RH		 4801 {
4802 if (print_errors)
4803 as_bad (_("Undefined register: '%s'."), name);
4804 num = -1;
4805 }
4806 else
4807 {
4808 do
4809 num = num * 10 + *p++ - '0';
3882b010 4810 while (ISDIGIT (*p));
252b5132
RH		 4811 }
4812 }
4813 else
4814 {
4815 /* Do a normal register search. */
4816 while (is_part_of_name (c))
4817 {
4818 p = p + 1;
4819 c = *p;
4820 }
4821 *p = 0;
4822 status = reg_name_search (name);
4823 if (status >= 0)
4824 num = status;
4825 else
4826 {
4827 if (print_errors)
4828 as_bad (_("Undefined register: '%s'."), name);
4829 num = -1;
4830 }
4831 *p = c;
4832 }
4833
ecacdc7a 4834 pa_number = num;
252b5132
RH		 4835 }
4836 else
4837 {
4838 /* And finally, it could be a symbol in the absolute section which
ecacdc7a 4839 is effectively a constant, or a register alias symbol. */
252b5132
RH		 4840 name = p;
4841 c = *p;
4842 while (is_part_of_name (c))
4843 {
4844 p = p + 1;
4845 c = *p;
4846 }
4847 *p = 0;
4848 if ((sym = symbol_find (name)) != NULL)
4849 {
ecacdc7a
AM		 4850 if (S_GET_SEGMENT (sym) == reg_section)
4851 {
4852 num = S_GET_VALUE (sym);
4853 /* Well, we don't really have one, but we do have a
4854 register, so... */
b34976b6 4855 have_prefix = TRUE;
ecacdc7a
AM		 4856 }
4857 else if (S_GET_SEGMENT (sym) == &bfd_abs_section)
252b5132 4858 num = S_GET_VALUE (sym);
ecacdc7a 4859 else if (!strict)
252b5132
RH		 4860 {
4861 if (print_errors)
4862 as_bad (_("Non-absolute symbol: '%s'."), name);
4863 num = -1;
4864 }
4865 }
ecacdc7a 4866 else if (!strict)
252b5132
RH		 4867 {
4868 /* There is where we'd come for an undefined symbol
4869 or for an empty string. For an empty string we
4870 will return zero. That's a concession made for
0234cb7c 4871 compatibility with the braindamaged HP assemblers. */
252b5132
RH		 4872 if (*name == 0)
4873 num = 0;
4874 else
4875 {
4876 if (print_errors)
4877 as_bad (_("Undefined absolute constant: '%s'."), name);
4878 num = -1;
4879 }
4880 }
4881 *p = c;
4882
ecacdc7a 4883 pa_number = num;
252b5132
RH		 4884 }
4885
ecacdc7a
AM		 4886 if (!strict || have_prefix)
4887 {
4888 *s = p;
4889 return 1;
4890 }
4891 return 0;
252b5132
RH		 4892}
4893
bc805888 4894#define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
252b5132
RH		 4895
4896/* Given NAME, find the register number associated with that name, return
4897 the integer value associated with the given name or -1 on failure. */
4898
4899static int
4900reg_name_search (name)
4901 char *name;
4902{
4903 int middle, low, high;
4904 int cmp;
4905
4906 low = 0;
4907 high = REG_NAME_CNT - 1;
4908
4909 do
4910 {
4911 middle = (low + high) / 2;
4912 cmp = strcasecmp (name, pre_defined_registers[middle].name);
4913 if (cmp < 0)
4914 high = middle - 1;
4915 else if (cmp > 0)
4916 low = middle + 1;
4917 else
4918 return pre_defined_registers[middle].value;
4919 }
4920 while (low <= high);
4921
4922 return -1;
4923}
4924
252b5132
RH		 4925/* Return nonzero if the given INSN and L/R information will require
4926 a new PA-1.1 opcode. */
4927
4928static int
ecacdc7a 4929need_pa11_opcode ()
252b5132 4930{
ecacdc7a
AM		 4931 if ((pa_number & FP_REG_RSEL) != 0
4932 && !(the_insn.fpof1 == DBL && the_insn.fpof2 == DBL))
252b5132
RH		 4933 {
4934 /* If this instruction is specific to a particular architecture,
4935 then set a new architecture. */
4936 if (bfd_get_mach (stdoutput) < pa11)
4937 {
4938 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, pa11))
4939 as_warn (_("could not update architecture and machine"));
4940 }
4941 return TRUE;
4942 }
4943 else
4944 return FALSE;
4945}
4946
4947/* Parse a condition for a fcmp instruction. Return the numerical
4948 code associated with the condition. */
4949
4950static int
4951pa_parse_fp_cmp_cond (s)
4952 char **s;
4953{
4954 int cond, i;
4955
4956 cond = 0;
4957
4958 for (i = 0; i < 32; i++)
4959 {
4960 if (strncasecmp (*s, fp_cond_map[i].string,
4961 strlen (fp_cond_map[i].string)) == 0)
4962 {
4963 cond = fp_cond_map[i].cond;
4964 *s += strlen (fp_cond_map[i].string);
4965 /* If not a complete match, back up the input string and
4966 report an error. */
4967 if (**s != ' ' && **s != '\t')
4968 {
4969 *s -= strlen (fp_cond_map[i].string);
4970 break;
4971 }
4972 while (**s == ' ' || **s == '\t')
4973 *s = *s + 1;
4974 return cond;
4975 }
4976 }
4977
4978 as_bad (_("Invalid FP Compare Condition: %s"), *s);
4979
4980 /* Advance over the bogus completer. */
4981 while (**s != ',' && **s != ' ' && **s != '\t')
4982 *s += 1;
4983
4984 return 0;
4985}
4986
1cf6ae67
JL		 4987/* Parse a graphics test complete for ftest. */
4988
4989static int
4990pa_parse_ftest_gfx_completer (s)
4991 char **s;
4992{
4993 int value;
4994
4995 value = 0;
4996 if (strncasecmp (*s, "acc8", 4) == 0)
4997 {
4998 value = 5;
4999 *s += 4;
5000 }
5001 else if (strncasecmp (*s, "acc6", 4) == 0)
5002 {
5003 value = 9;
5004 *s += 4;
5005 }
5006 else if (strncasecmp (*s, "acc4", 4) == 0)
5007 {
5008 value = 13;
5009 *s += 4;
5010 }
5011 else if (strncasecmp (*s, "acc2", 4) == 0)
5012 {
5013 value = 17;
5014 *s += 4;
5015 }
5016 else if (strncasecmp (*s, "acc", 3) == 0)
5017 {
5018 value = 1;
5019 *s += 3;
5020 }
5021 else if (strncasecmp (*s, "rej8", 4) == 0)
5022 {
5023 value = 6;
5024 *s += 4;
5025 }
5026 else if (strncasecmp (*s, "rej", 3) == 0)
5027 {
5028 value = 2;
5029 *s += 3;
5030 }
5031 else
5032 {
5033 value = 0;
5034 as_bad (_("Invalid FTEST completer: %s"), *s);
5035 }
5036
5037 return value;
5038}
5039
5040/* Parse an FP operand format completer returning the completer
5041 type. */
5042
5043static fp_operand_format
5044pa_parse_fp_cnv_format (s)
5045 char **s;
5046{
5047 int format;
5048
5049 format = SGL;
5050 if (**s == ',')
5051 {
5052 *s += 1;
5053 if (strncasecmp (*s, "sgl", 3) == 0)
5054 {
5055 format = SGL;
5056 *s += 4;
5057 }
5058 else if (strncasecmp (*s, "dbl", 3) == 0)
5059 {
5060 format = DBL;
5061 *s += 4;
5062 }
5063 else if (strncasecmp (*s, "quad", 4) == 0)
5064 {
5065 format = QUAD;
5066 *s += 5;
5067 }
5068 else if (strncasecmp (*s, "w", 1) == 0)
5069 {
5070 format = W;
5071 *s += 2;
5072 }
5073 else if (strncasecmp (*s, "uw", 2) == 0)
5074 {
5075 format = UW;
5076 *s += 3;
5077 }
5078 else if (strncasecmp (*s, "dw", 2) == 0)
5079 {
5080 format = DW;
5081 *s += 3;
5082 }
5083 else if (strncasecmp (*s, "udw", 3) == 0)
5084 {
5085 format = UDW;
5086 *s += 4;
5087 }
5088 else if (strncasecmp (*s, "qw", 2) == 0)
5089 {
5090 format = QW;
5091 *s += 3;
5092 }
5093 else if (strncasecmp (*s, "uqw", 3) == 0)
5094 {
5095 format = UQW;
5096 *s += 4;
5097 }
5098 else
5099 {
5100 format = ILLEGAL_FMT;
5101 as_bad (_("Invalid FP Operand Format: %3s"), *s);
5102 }
5103 }
5104
5105 return format;
5106}
252b5132
RH		 5107
5108/* Parse an FP operand format completer returning the completer
5109 type. */
5110
5111static fp_operand_format
5112pa_parse_fp_format (s)
5113 char **s;
5114{
5115 int format;
5116
5117 format = SGL;
5118 if (**s == ',')
5119 {
5120 *s += 1;
5121 if (strncasecmp (*s, "sgl", 3) == 0)
5122 {
5123 format = SGL;
5124 *s += 4;
5125 }
5126 else if (strncasecmp (*s, "dbl", 3) == 0)
5127 {
5128 format = DBL;
5129 *s += 4;
5130 }
5131 else if (strncasecmp (*s, "quad", 4) == 0)
5132 {
5133 format = QUAD;
5134 *s += 5;
5135 }
5136 else
5137 {
5138 format = ILLEGAL_FMT;
5139 as_bad (_("Invalid FP Operand Format: %3s"), *s);
5140 }
5141 }
5142
5143 return format;
5144}
5145
5146/* Convert from a selector string into a selector type. */
5147
5148static int
5149pa_chk_field_selector (str)
5150 char **str;
5151{
5152 int middle, low, high;
5153 int cmp;
5154 char name[4];
5155
5156 /* Read past any whitespace. */
5157 /* FIXME: should we read past newlines and formfeeds??? */
5158 while (**str == ' ' || **str == '\t' || **str == '\n' || **str == '\f')
5159 *str = *str + 1;
5160
5161 if ((*str)[1] == '\'' || (*str)[1] == '%')
3882b010 5162 name[0] = TOLOWER ((*str)[0]),
252b5132
RH		 5163 name[1] = 0;
5164 else if ((*str)[2] == '\'' || (*str)[2] == '%')
3882b010
L		 5165 name[0] = TOLOWER ((*str)[0]),
5166 name[1] = TOLOWER ((*str)[1]),
252b5132 5167 name[2] = 0;
252b5132 5168 else if ((*str)[3] == '\'' || (*str)[3] == '%')
3882b010
L		 5169 name[0] = TOLOWER ((*str)[0]),
5170 name[1] = TOLOWER ((*str)[1]),
5171 name[2] = TOLOWER ((*str)[2]),
252b5132 5172 name[3] = 0;
252b5132
RH		 5173 else
5174 return e_fsel;
5175
5176 low = 0;
5177 high = sizeof (selector_table) / sizeof (struct selector_entry) - 1;
5178
5179 do
5180 {
5181 middle = (low + high) / 2;
5182 cmp = strcmp (name, selector_table[middle].prefix);
5183 if (cmp < 0)
5184 high = middle - 1;
5185 else if (cmp > 0)
5186 low = middle + 1;
5187 else
5188 {
5189 *str += strlen (name) + 1;
5190#ifndef OBJ_SOM
5191 if (selector_table[middle].field_selector == e_nsel)
5192 return e_fsel;
5193#endif
5194 return selector_table[middle].field_selector;
5195 }
5196 }
5197 while (low <= high);
5198
5199 return e_fsel;
5200}
5201
5202/* Mark (via expr_end) the end of an expression (I think). FIXME. */
5203
5204static int
5205get_expression (str)
5206 char *str;
5207{
5208 char *save_in;
5209 asection *seg;
5210
5211 save_in = input_line_pointer;
5212 input_line_pointer = str;
5213 seg = expression (&the_insn.exp);
5214 if (!(seg == absolute_section
5215 || seg == undefined_section
5216 || SEG_NORMAL (seg)))
5217 {
5218 as_warn (_("Bad segment in expression."));
5219 expr_end = input_line_pointer;
5220 input_line_pointer = save_in;
5221 return 1;
5222 }
5223 expr_end = input_line_pointer;
5224 input_line_pointer = save_in;
5225 return 0;
5226}
5227
a28a3ccf 5228/* Mark (via expr_end) the end of an absolute expression. FIXME. */
252b5132
RH		 5229static int
5230pa_get_absolute_expression (insn, strp)
5231 struct pa_it *insn;
5232 char **strp;
5233{
5234 char *save_in;
5235
5236 insn->field_selector = pa_chk_field_selector (strp);
5237 save_in = input_line_pointer;
5238 input_line_pointer = *strp;
5239 expression (&insn->exp);
5240 /* This is not perfect, but is a huge improvement over doing nothing.
5241
0234cb7c 5242 The PA assembly syntax is ambiguous in a variety of ways. Consider
252b5132 5243 this string "4 %r5" Is that the number 4 followed by the register
ecacdc7a 5244 r5, or is that 4 MOD r5?
252b5132 5245
0234cb7c 5246 If we get a modulo expression when looking for an absolute, we try
252b5132
RH		 5247 again cutting off the input string at the first whitespace character. */
5248 if (insn->exp.X_op == O_modulus)
5249 {
5250 char *s, c;
5251 int retval;
5252
5253 input_line_pointer = *strp;
5254 s = *strp;
5255 while (*s != ',' && *s != ' ' && *s != '\t')
cc8a6dd0 5256 s++;
252b5132
RH		 5257
5258 c = *s;
5259 *s = 0;
5260
5261 retval = pa_get_absolute_expression (insn, strp);
5262
5263 input_line_pointer = save_in;
5264 *s = c;
5265 return evaluate_absolute (insn);
5266 }
0f4f8b56
JL		 5267 /* When in strict mode we have a non-match, fix up the pointers
5268 and return to our caller. */
5269 if (insn->exp.X_op != O_constant && strict)
5270 {
5271 expr_end = input_line_pointer;
5272 input_line_pointer = save_in;
5273 return 0;
5274 }
252b5132
RH		 5275 if (insn->exp.X_op != O_constant)
5276 {
5277 as_bad (_("Bad segment (should be absolute)."));
5278 expr_end = input_line_pointer;
5279 input_line_pointer = save_in;
5280 return 0;
5281 }
5282 expr_end = input_line_pointer;
5283 input_line_pointer = save_in;
5284 return evaluate_absolute (insn);
5285}
5286
5287/* Evaluate an absolute expression EXP which may be modified by
5288 the selector FIELD_SELECTOR. Return the value of the expression. */
5289static int
5290evaluate_absolute (insn)
5291 struct pa_it *insn;
5292{
3f9b03b5 5293 offsetT value;
252b5132
RH		 5294 expressionS exp;
5295 int field_selector = insn->field_selector;
5296
5297 exp = insn->exp;
5298 value = exp.X_add_number;
5299
3f9b03b5 5300 return hppa_field_adjust (0, value, field_selector);
252b5132
RH		 5301}
5302
5303/* Given an argument location specification return the associated
5304 argument location number. */
5305
5306static unsigned int
5307pa_build_arg_reloc (type_name)
5308 char *type_name;
5309{
5310
5311 if (strncasecmp (type_name, "no", 2) == 0)
5312 return 0;
5313 if (strncasecmp (type_name, "gr", 2) == 0)
5314 return 1;
5315 else if (strncasecmp (type_name, "fr", 2) == 0)
5316 return 2;
5317 else if (strncasecmp (type_name, "fu", 2) == 0)
5318 return 3;
5319 else
5320 as_bad (_("Invalid argument location: %s\n"), type_name);
5321
5322 return 0;
5323}
5324
5325/* Encode and return an argument relocation specification for
5326 the given register in the location specified by arg_reloc. */
5327
5328static unsigned int
5329pa_align_arg_reloc (reg, arg_reloc)
5330 unsigned int reg;
5331 unsigned int arg_reloc;
5332{
5333 unsigned int new_reloc;
5334
5335 new_reloc = arg_reloc;
5336 switch (reg)
5337 {
5338 case 0:
5339 new_reloc <<= 8;
5340 break;
5341 case 1:
5342 new_reloc <<= 6;
5343 break;
5344 case 2:
5345 new_reloc <<= 4;
5346 break;
5347 case 3:
5348 new_reloc <<= 2;
5349 break;
5350 default:
5351 as_bad (_("Invalid argument description: %d"), reg);
5352 }
5353
5354 return new_reloc;
5355}
5356
5357/* Parse a PA nullification completer (,n). Return nonzero if the
5358 completer was found; return zero if no completer was found. */
5359
5360static int
5361pa_parse_nullif (s)
5362 char **s;
5363{
5364 int nullif;
5365
5366 nullif = 0;
5367 if (**s == ',')
5368 {
5369 *s = *s + 1;
5370 if (strncasecmp (*s, "n", 1) == 0)
5371 nullif = 1;
5372 else
5373 {
5374 as_bad (_("Invalid Nullification: (%c)"), **s);
5375 nullif = 0;
5376 }
5377 *s = *s + 1;
5378 }
5379
5380 return nullif;
5381}
5382
5383/* Parse a non-negated compare/subtract completer returning the
0234cb7c 5384 number (for encoding in instructions) of the given completer. */
252b5132
RH		 5385
5386static int
677537c1 5387pa_parse_nonneg_cmpsub_cmpltr (s)
252b5132 5388 char **s;
252b5132
RH		 5389{
5390 int cmpltr;
5391 char *name = *s + 1;
5392 char c;
5393 char *save_s = *s;
5394 int nullify = 0;
5395
5396 cmpltr = 0;
5397 if (**s == ',')
5398 {
5399 *s += 1;
5400 while (**s != ',' && **s != ' ' && **s != '\t')
5401 *s += 1;
5402 c = **s;
5403 **s = 0x00;
5404
252b5132
RH		 5405 if (strcmp (name, "=") == 0)
5406 {
5407 cmpltr = 1;
5408 }
5409 else if (strcmp (name, "<") == 0)
5410 {
5411 cmpltr = 2;
5412 }
5413 else if (strcmp (name, "<=") == 0)
5414 {
5415 cmpltr = 3;
5416 }
5417 else if (strcmp (name, "<<") == 0)
5418 {
5419 cmpltr = 4;
5420 }
5421 else if (strcmp (name, "<<=") == 0)
5422 {
5423 cmpltr = 5;
5424 }
5425 else if (strcasecmp (name, "sv") == 0)
5426 {
5427 cmpltr = 6;
5428 }
5429 else if (strcasecmp (name, "od") == 0)
5430 {
5431 cmpltr = 7;
5432 }
5433 /* If we have something like addb,n then there is no condition
5434 completer. */
677537c1 5435 else if (strcasecmp (name, "n") == 0)
252b5132
RH		 5436 {
5437 cmpltr = 0;
5438 nullify = 1;
5439 }
5440 else
5441 {
5442 cmpltr = -1;
5443 }
5444 **s = c;
5445 }
5446
5447 /* Reset pointers if this was really a ,n for a branch instruction. */
5448 if (nullify)
5449 *s = save_s;
5450
252b5132
RH		 5451 return cmpltr;
5452}
5453
5454/* Parse a negated compare/subtract completer returning the
0234cb7c 5455 number (for encoding in instructions) of the given completer. */
252b5132
RH		 5456
5457static int
677537c1 5458pa_parse_neg_cmpsub_cmpltr (s)
252b5132 5459 char **s;
252b5132
RH		 5460{
5461 int cmpltr;
5462 char *name = *s + 1;
5463 char c;
5464 char *save_s = *s;
5465 int nullify = 0;
5466
5467 cmpltr = 0;
5468 if (**s == ',')
5469 {
5470 *s += 1;
5471 while (**s != ',' && **s != ' ' && **s != '\t')
5472 *s += 1;
5473 c = **s;
5474 **s = 0x00;
5475
252b5132
RH		 5476 if (strcasecmp (name, "tr") == 0)
5477 {
5478 cmpltr = 0;
5479 }
5480 else if (strcmp (name, "<>") == 0)
5481 {
5482 cmpltr = 1;
5483 }
5484 else if (strcmp (name, ">=") == 0)
5485 {
5486 cmpltr = 2;
5487 }
5488 else if (strcmp (name, ">") == 0)
5489 {
5490 cmpltr = 3;
5491 }
5492 else if (strcmp (name, ">>=") == 0)
5493 {
5494 cmpltr = 4;
5495 }
5496 else if (strcmp (name, ">>") == 0)
5497 {
5498 cmpltr = 5;
5499 }
5500 else if (strcasecmp (name, "nsv") == 0)
5501 {
5502 cmpltr = 6;
5503 }
5504 else if (strcasecmp (name, "ev") == 0)
5505 {
5506 cmpltr = 7;
5507 }
5508 /* If we have something like addb,n then there is no condition
5509 completer. */
677537c1 5510 else if (strcasecmp (name, "n") == 0)
252b5132
RH		 5511 {
5512 cmpltr = 0;
5513 nullify = 1;
5514 }
5515 else
5516 {
5517 cmpltr = -1;
5518 }
5519 **s = c;
5520 }
5521
5522 /* Reset pointers if this was really a ,n for a branch instruction. */
5523 if (nullify)
5524 *s = save_s;
5525
252b5132
RH		 5526 return cmpltr;
5527}
5528
d53d2751 5529/* Parse a 64 bit compare and branch completer returning the number (for
0234cb7c 5530 encoding in instructions) of the given completer.
d53d2751
JL		 5531
5532 Nonnegated comparisons are returned as 0-7, negated comparisons are
5533 returned as 8-15. */
5534
5535static int
5536pa_parse_cmpb_64_cmpltr (s)
5537 char **s;
5538{
5539 int cmpltr;
5540 char *name = *s + 1;
5541 char c;
d53d2751
JL		 5542
5543 cmpltr = -1;
5544 if (**s == ',')
5545 {
5546 *s += 1;
5547 while (**s != ',' && **s != ' ' && **s != '\t')
5548 *s += 1;
5549 c = **s;
5550 **s = 0x00;
5551
5552 if (strcmp (name, "*") == 0)
5553 {
5554 cmpltr = 0;
5555 }
5556 else if (strcmp (name, "*=") == 0)
5557 {
5558 cmpltr = 1;
5559 }
5560 else if (strcmp (name, "*<") == 0)
5561 {
5562 cmpltr = 2;
5563 }
5564 else if (strcmp (name, "*<=") == 0)
5565 {
5566 cmpltr = 3;
5567 }
5568 else if (strcmp (name, "*<<") == 0)
5569 {
5570 cmpltr = 4;
5571 }
5572 else if (strcmp (name, "*<<=") == 0)
5573 {
5574 cmpltr = 5;
5575 }
5576 else if (strcasecmp (name, "*sv") == 0)
5577 {
5578 cmpltr = 6;
5579 }
5580 else if (strcasecmp (name, "*od") == 0)
5581 {
5582 cmpltr = 7;
5583 }
5584 else if (strcasecmp (name, "*tr") == 0)
5585 {
5586 cmpltr = 8;
5587 }
5588 else if (strcmp (name, "*<>") == 0)
5589 {
5590 cmpltr = 9;
5591 }
5592 else if (strcmp (name, "*>=") == 0)
5593 {
5594 cmpltr = 10;
5595 }
5596 else if (strcmp (name, "*>") == 0)
5597 {
5598 cmpltr = 11;
5599 }
5600 else if (strcmp (name, "*>>=") == 0)
5601 {
5602 cmpltr = 12;
5603 }
5604 else if (strcmp (name, "*>>") == 0)
5605 {
5606 cmpltr = 13;
5607 }
5608 else if (strcasecmp (name, "*nsv") == 0)
5609 {
5610 cmpltr = 14;
5611 }
5612 else if (strcasecmp (name, "*ev") == 0)
5613 {
5614 cmpltr = 15;
5615 }
5616 else
5617 {
5618 cmpltr = -1;
5619 }
5620 **s = c;
5621 }
5622
d53d2751
JL		 5623 return cmpltr;
5624}
5625
5626/* Parse a 64 bit compare immediate and branch completer returning the number
0234cb7c 5627 (for encoding in instructions) of the given completer. */
d53d2751
JL		 5628
5629static int
5630pa_parse_cmpib_64_cmpltr (s)
5631 char **s;
5632{
5633 int cmpltr;
5634 char *name = *s + 1;
5635 char c;
d53d2751
JL		 5636
5637 cmpltr = -1;
5638 if (**s == ',')
5639 {
5640 *s += 1;
5641 while (**s != ',' && **s != ' ' && **s != '\t')
5642 *s += 1;
5643 c = **s;
5644 **s = 0x00;
5645
5646 if (strcmp (name, "*<<") == 0)
5647 {
5648 cmpltr = 0;
5649 }
5650 else if (strcmp (name, "*=") == 0)
5651 {
5652 cmpltr = 1;
5653 }
5654 else if (strcmp (name, "*<") == 0)
5655 {
5656 cmpltr = 2;
5657 }
5658 else if (strcmp (name, "*<=") == 0)
5659 {
5660 cmpltr = 3;
5661 }
5662 else if (strcmp (name, "*>>=") == 0)
5663 {
5664 cmpltr = 4;
5665 }
5666 else if (strcmp (name, "*<>") == 0)
5667 {
5668 cmpltr = 5;
5669 }
5670 else if (strcasecmp (name, "*>=") == 0)
5671 {
5672 cmpltr = 6;
5673 }
5674 else if (strcasecmp (name, "*>") == 0)
5675 {
5676 cmpltr = 7;
5677 }
5678 else
5679 {
5680 cmpltr = -1;
5681 }
5682 **s = c;
5683 }
5684
d53d2751
JL		 5685 return cmpltr;
5686}
5687
252b5132 5688/* Parse a non-negated addition completer returning the number
0234cb7c 5689 (for encoding in instructions) of the given completer. */
252b5132
RH		 5690
5691static int
677537c1 5692pa_parse_nonneg_add_cmpltr (s)
252b5132 5693 char **s;
252b5132
RH		 5694{
5695 int cmpltr;
5696 char *name = *s + 1;
5697 char c;
5698 char *save_s = *s;
677537c1 5699 int nullify = 0;
252b5132
RH		 5700
5701 cmpltr = 0;
5702 if (**s == ',')
5703 {
5704 *s += 1;
5705 while (**s != ',' && **s != ' ' && **s != '\t')
5706 *s += 1;
5707 c = **s;
5708 **s = 0x00;
5709 if (strcmp (name, "=") == 0)
5710 {
5711 cmpltr = 1;
5712 }
5713 else if (strcmp (name, "<") == 0)
5714 {
5715 cmpltr = 2;
5716 }
5717 else if (strcmp (name, "<=") == 0)
5718 {
5719 cmpltr = 3;
5720 }
5721 else if (strcasecmp (name, "nuv") == 0)
5722 {
5723 cmpltr = 4;
5724 }
5725 else if (strcasecmp (name, "znv") == 0)
5726 {
5727 cmpltr = 5;
5728 }
5729 else if (strcasecmp (name, "sv") == 0)
5730 {
5731 cmpltr = 6;
5732 }
5733 else if (strcasecmp (name, "od") == 0)
5734 {
5735 cmpltr = 7;
5736 }
5737 /* If we have something like addb,n then there is no condition
5738 completer. */
677537c1 5739 else if (strcasecmp (name, "n") == 0)
252b5132
RH		 5740 {
5741 cmpltr = 0;
677537c1 5742 nullify = 1;
252b5132
RH		 5743 }
5744 else
5745 {
5746 cmpltr = -1;
5747 }
5748 **s = c;
5749 }
5750
5751 /* Reset pointers if this was really a ,n for a branch instruction. */
677537c1 5752 if (nullify)
252b5132
RH		 5753 *s = save_s;
5754
5755 return cmpltr;
5756}
5757
5758/* Parse a negated addition completer returning the number
0234cb7c 5759 (for encoding in instructions) of the given completer. */
252b5132
RH		 5760
5761static int
677537c1 5762pa_parse_neg_add_cmpltr (s)
252b5132 5763 char **s;
252b5132
RH		 5764{
5765 int cmpltr;
5766 char *name = *s + 1;
5767 char c;
5768 char *save_s = *s;
677537c1 5769 int nullify = 0;
252b5132
RH		 5770
5771 cmpltr = 0;
5772 if (**s == ',')
5773 {
5774 *s += 1;
5775 while (**s != ',' && **s != ' ' && **s != '\t')
5776 *s += 1;
5777 c = **s;
5778 **s = 0x00;
5779 if (strcasecmp (name, "tr") == 0)
5780 {
5781 cmpltr = 0;
5782 }
5783 else if (strcmp (name, "<>") == 0)
5784 {
5785 cmpltr = 1;
5786 }
5787 else if (strcmp (name, ">=") == 0)
5788 {
5789 cmpltr = 2;
5790 }
5791 else if (strcmp (name, ">") == 0)
5792 {
5793 cmpltr = 3;
5794 }
5795 else if (strcasecmp (name, "uv") == 0)
5796 {
5797 cmpltr = 4;
5798 }
5799 else if (strcasecmp (name, "vnz") == 0)
5800 {
5801 cmpltr = 5;
5802 }
5803 else if (strcasecmp (name, "nsv") == 0)
5804 {
5805 cmpltr = 6;
5806 }
5807 else if (strcasecmp (name, "ev") == 0)
5808 {
5809 cmpltr = 7;
5810 }
5811 /* If we have something like addb,n then there is no condition
5812 completer. */
677537c1 5813 else if (strcasecmp (name, "n") == 0)
252b5132
RH		 5814 {
5815 cmpltr = 0;
677537c1 5816 nullify = 1;
252b5132
RH		 5817 }
5818 else
5819 {
5820 cmpltr = -1;
5821 }
5822 **s = c;
5823 }
5824
5825 /* Reset pointers if this was really a ,n for a branch instruction. */
677537c1 5826 if (nullify)
252b5132
RH		 5827 *s = save_s;
5828
5829 return cmpltr;
5830}
5831
d53d2751 5832/* Parse a 64 bit wide mode add and branch completer returning the number (for
0234cb7c 5833 encoding in instructions) of the given completer. */
d53d2751
JL		 5834
5835static int
5836pa_parse_addb_64_cmpltr (s)
5837 char **s;
5838{
5839 int cmpltr;
5840 char *name = *s + 1;
5841 char c;
5842 char *save_s = *s;
5843 int nullify = 0;
5844
5845 cmpltr = 0;
5846 if (**s == ',')
5847 {
5848 *s += 1;
5849 while (**s != ',' && **s != ' ' && **s != '\t')
5850 *s += 1;
5851 c = **s;
5852 **s = 0x00;
5853 if (strcmp (name, "=") == 0)
5854 {
5855 cmpltr = 1;
5856 }
5857 else if (strcmp (name, "<") == 0)
5858 {
5859 cmpltr = 2;
5860 }
5861 else if (strcmp (name, "<=") == 0)
5862 {
5863 cmpltr = 3;
5864 }
5865 else if (strcasecmp (name, "nuv") == 0)
5866 {
5867 cmpltr = 4;
5868 }
5869 else if (strcasecmp (name, "*=") == 0)
5870 {
5871 cmpltr = 5;
5872 }
5873 else if (strcasecmp (name, "*<") == 0)
5874 {
5875 cmpltr = 6;
5876 }
5877 else if (strcasecmp (name, "*<=") == 0)
5878 {
5879 cmpltr = 7;
5880 }
5881 else if (strcmp (name, "tr") == 0)
5882 {
5883 cmpltr = 8;
5884 }
5885 else if (strcmp (name, "<>") == 0)
5886 {
5887 cmpltr = 9;
5888 }
5889 else if (strcmp (name, ">=") == 0)
5890 {
5891 cmpltr = 10;
5892 }
5893 else if (strcmp (name, ">") == 0)
5894 {
5895 cmpltr = 11;
5896 }
5897 else if (strcasecmp (name, "uv") == 0)
5898 {
5899 cmpltr = 12;
5900 }
5901 else if (strcasecmp (name, "*<>") == 0)
5902 {
5903 cmpltr = 13;
5904 }
5905 else if (strcasecmp (name, "*>=") == 0)
5906 {
5907 cmpltr = 14;
5908 }
5909 else if (strcasecmp (name, "*>") == 0)
5910 {
5911 cmpltr = 15;
5912 }
5913 /* If we have something like addb,n then there is no condition
5914 completer. */
5915 else if (strcasecmp (name, "n") == 0)
5916 {
5917 cmpltr = 0;
5918 nullify = 1;
5919 }
5920 else
5921 {
5922 cmpltr = -1;
5923 }
5924 **s = c;
5925 }
5926
5927 /* Reset pointers if this was really a ,n for a branch instruction. */
5928 if (nullify)
5929 *s = save_s;
5930
5931 return cmpltr;
5932}
5933
49863f82 5934#ifdef OBJ_SOM
252b5132
RH		 5935/* Handle an alignment directive. Special so that we can update the
5936 alignment of the subspace if necessary. */
5937static void
5938pa_align (bytes)
5506e1a5 5939 int bytes;
252b5132
RH		 5940{
5941 /* We must have a valid space and subspace. */
5942 pa_check_current_space_and_subspace ();
5943
5944 /* Let the generic gas code do most of the work. */
5945 s_align_bytes (bytes);
5946
5947 /* If bytes is a power of 2, then update the current subspace's
5948 alignment if necessary. */
b8fc22bc
DA		 5949 if (exact_log2 (bytes) != -1)
5950 record_alignment (current_subspace->ssd_seg, exact_log2 (bytes));
252b5132 5951}
49863f82 5952#endif
252b5132
RH		 5953
5954/* Handle a .BLOCK type pseudo-op. */
5955
5956static void
5957pa_block (z)
3f9b03b5 5958 int z ATTRIBUTE_UNUSED;
252b5132 5959{
252b5132 5960 unsigned int temp_size;
252b5132 5961
49863f82 5962#ifdef OBJ_SOM
252b5132
RH		 5963 /* We must have a valid space and subspace. */
5964 pa_check_current_space_and_subspace ();
49863f82 5965#endif
252b5132
RH		 5966
5967 temp_size = get_absolute_expression ();
5968
ee192366
MM		 5969 if (temp_size > 0x3FFFFFFF)
5970 {
5971 as_bad (_("Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff"));
5972 temp_size = 0;
5973 }
6bdb6dec 5974 else
252b5132 5975 {
6bdb6dec
AM		 5976 /* Always fill with zeros, that's what the HP assembler does. */
5977 char *p = frag_var (rs_fill, 1, 1, 0, NULL, temp_size, NULL);
5978 *p = 0;
252b5132
RH		 5979 }
5980
5981 pa_undefine_label ();
5982 demand_empty_rest_of_line ();
5983}
5984
5985/* Handle a .begin_brtab and .end_brtab pseudo-op. */
5986
5987static void
5988pa_brtab (begin)
3f9b03b5 5989 int begin ATTRIBUTE_UNUSED;
252b5132
RH		 5990{
5991
5992#ifdef OBJ_SOM
0234cb7c 5993 /* The BRTAB relocations are only available in SOM (to denote
252b5132
RH		 5994 the beginning and end of branch tables). */
5995 char *where = frag_more (0);
5996
5997 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5998 NULL, (offsetT) 0, NULL,
5999 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
da6c73e0 6000 e_fsel, 0, 0, 0);
252b5132
RH		 6001#endif
6002
6003 demand_empty_rest_of_line ();
6004}
6005
6006/* Handle a .begin_try and .end_try pseudo-op. */
6007
6008static void
6009pa_try (begin)
3f9b03b5 6010 int begin ATTRIBUTE_UNUSED;
252b5132
RH		 6011{
6012#ifdef OBJ_SOM
6013 expressionS exp;
6014 char *where = frag_more (0);
6015
6016 if (! begin)
6017 expression (&exp);
6018
0234cb7c 6019 /* The TRY relocations are only available in SOM (to denote
252b5132
RH		 6020 the beginning and end of exception handling regions). */
6021
6022 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6023 NULL, (offsetT) 0, begin ? NULL : &exp,
6024 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
da6c73e0 6025 e_fsel, 0, 0, 0);
252b5132
RH		 6026#endif
6027
6028 demand_empty_rest_of_line ();
6029}
6030
6031/* Handle a .CALL pseudo-op. This involves storing away information
6032 about where arguments are to be found so the linker can detect
6033 (and correct) argument location mismatches between caller and callee. */
6034
6035static void
6036pa_call (unused)
3f9b03b5 6037 int unused ATTRIBUTE_UNUSED;
252b5132 6038{
49863f82 6039#ifdef OBJ_SOM
252b5132
RH		 6040 /* We must have a valid space and subspace. */
6041 pa_check_current_space_and_subspace ();
49863f82 6042#endif
252b5132
RH		 6043
6044 pa_call_args (&last_call_desc);
6045 demand_empty_rest_of_line ();
6046}
6047
6048/* Do the dirty work of building a call descriptor which describes
6049 where the caller placed arguments to a function call. */
6050
6051static void
6052pa_call_args (call_desc)
6053 struct call_desc *call_desc;
6054{
6055 char *name, c, *p;
6056 unsigned int temp, arg_reloc;
6057
6058 while (!is_end_of_statement ())
6059 {
6060 name = input_line_pointer;
6061 c = get_symbol_end ();
6062 /* Process a source argument. */
6063 if ((strncasecmp (name, "argw", 4) == 0))
6064 {
6065 temp = atoi (name + 4);
6066 p = input_line_pointer;
6067 *p = c;
6068 input_line_pointer++;
6069 name = input_line_pointer;
6070 c = get_symbol_end ();
6071 arg_reloc = pa_build_arg_reloc (name);
6072 call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
6073 }
6074 /* Process a return value. */
6075 else if ((strncasecmp (name, "rtnval", 6) == 0))
6076 {
6077 p = input_line_pointer;
6078 *p = c;
6079 input_line_pointer++;
6080 name = input_line_pointer;
6081 c = get_symbol_end ();
6082 arg_reloc = pa_build_arg_reloc (name);
6083 call_desc->arg_reloc |= (arg_reloc & 0x3);
6084 }
6085 else
6086 {
6087 as_bad (_("Invalid .CALL argument: %s"), name);
6088 }
6089 p = input_line_pointer;
6090 *p = c;
6091 if (!is_end_of_statement ())
6092 input_line_pointer++;
6093 }
6094}
6095
6096/* Return TRUE if FRAG1 and FRAG2 are the same. */
6097
6098static int
6099is_same_frag (frag1, frag2)
6100 fragS *frag1;
6101 fragS *frag2;
6102{
6103
6104 if (frag1 == NULL)
6105 return (FALSE);
6106 else if (frag2 == NULL)
6107 return (FALSE);
6108 else if (frag1 == frag2)
6109 return (TRUE);
6110 else if (frag2->fr_type == rs_fill && frag2->fr_fix == 0)
6111 return (is_same_frag (frag1, frag2->fr_next));
6112 else
6113 return (FALSE);
6114}
6115
6116#ifdef OBJ_ELF
6117/* Build an entry in the UNWIND subspace from the given function
6118 attributes in CALL_INFO. This is not needed for SOM as using
6119 R_ENTRY and R_EXIT relocations allow the linker to handle building
6120 of the unwind spaces. */
6121
6122static void
6123pa_build_unwind_subspace (call_info)
6124 struct call_info *call_info;
6125{
252b5132 6126 asection *seg, *save_seg;
3f9b03b5 6127 subsegT save_subseg;
da6c73e0 6128 unsigned int unwind;
3f9b03b5 6129 int reloc;
da6c73e0 6130 char *p;
252b5132 6131
1d3d5051
AM		 6132 if ((bfd_get_section_flags (stdoutput, now_seg)
6133 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
6134 != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
7acbfc6b
JL		 6135 return;
6136
c46b7515 6137 reloc = R_PARISC_SEGREL32;
c97305a1
JL		 6138 save_seg = now_seg;
6139 save_subseg = now_subseg;
252b5132
RH		 6140 /* Get into the right seg/subseg. This may involve creating
6141 the seg the first time through. Make sure to have the
6142 old seg/subseg so that we can reset things when we are done. */
252b5132
RH		 6143 seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6144 if (seg == ASEC_NULL)
6145 {
c97305a1 6146 seg = subseg_new (UNWIND_SECTION_NAME, 0);
252b5132
RH		 6147 bfd_set_section_flags (stdoutput, seg,
6148 SEC_READONLY | SEC_HAS_CONTENTS
b100be66
JL		 6149 | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6150 bfd_set_section_alignment (stdoutput, seg, 2);
252b5132
RH		 6151 }
6152
46031ca9 6153 subseg_set (seg, 0);
252b5132 6154
252b5132
RH		 6155 /* Get some space to hold relocation information for the unwind
6156 descriptor. */
da6c73e0 6157 p = frag_more (16);
252b5132
RH		 6158
6159 /* Relocation info. for start offset of the function. */
8ea46bbd 6160 md_number_to_chars (p, 0, 4);
252b5132
RH		 6161 fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6162 call_info->start_symbol, (offsetT) 0,
46031ca9 6163 (expressionS *) NULL, 0, reloc,
da6c73e0 6164 e_fsel, 32, 0, 0);
252b5132
RH		 6165
6166 /* Relocation info. for end offset of the function.
6167
6168 Because we allow reductions of 32bit relocations for ELF, this will be
6169 reduced to section_sym + offset which avoids putting the temporary
6170 symbol into the symbol table. It (should) end up giving the same
6171 value as call_info->start_symbol + function size once the linker is
6172 finished with its work. */
8ea46bbd 6173 md_number_to_chars (p + 4, 0, 4);
da6c73e0 6174 fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
252b5132 6175 call_info->end_symbol, (offsetT) 0,
46031ca9 6176 (expressionS *) NULL, 0, reloc,
da6c73e0 6177 e_fsel, 32, 0, 0);
252b5132 6178
da6c73e0
AM		 6179 /* Dump the descriptor. */
6180 unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6181 md_number_to_chars (p + 8, unwind, 4);
6182
6183 unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6184 md_number_to_chars (p + 12, unwind, 4);
252b5132
RH		 6185
6186 /* Return back to the original segment/subsegment. */
6187 subseg_set (save_seg, save_subseg);
6188}
6189#endif
6190
6191/* Process a .CALLINFO pseudo-op. This information is used later
6192 to build unwind descriptors and maybe one day to support
6193 .ENTER and .LEAVE. */
6194
6195static void
6196pa_callinfo (unused)
3f9b03b5 6197 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6198{
6199 char *name, c, *p;
6200 int temp;
6201
49863f82 6202#ifdef OBJ_SOM
252b5132
RH		 6203 /* We must have a valid space and subspace. */
6204 pa_check_current_space_and_subspace ();
49863f82 6205#endif
252b5132
RH		 6206
6207 /* .CALLINFO must appear within a procedure definition. */
6208 if (!within_procedure)
6209 as_bad (_(".callinfo is not within a procedure definition"));
6210
6211 /* Mark the fact that we found the .CALLINFO for the
6212 current procedure. */
6213 callinfo_found = TRUE;
6214
6215 /* Iterate over the .CALLINFO arguments. */
6216 while (!is_end_of_statement ())
6217 {
6218 name = input_line_pointer;
6219 c = get_symbol_end ();
6220 /* Frame size specification. */
6221 if ((strncasecmp (name, "frame", 5) == 0))
6222 {
6223 p = input_line_pointer;
6224 *p = c;
6225 input_line_pointer++;
6226 temp = get_absolute_expression ();
6227 if ((temp & 0x3) != 0)
6228 {
6229 as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6230 temp = 0;
6231 }
6232
6233 /* callinfo is in bytes and unwind_desc is in 8 byte units. */
6234 last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6235
6236 }
6237 /* Entry register (GR, GR and SR) specifications. */
6238 else if ((strncasecmp (name, "entry_gr", 8) == 0))
6239 {
6240 p = input_line_pointer;
6241 *p = c;
6242 input_line_pointer++;
6243 temp = get_absolute_expression ();
6244 /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6245 even though %r19 is caller saved. I think this is a bug in
6246 the HP assembler, and we are not going to emulate it. */
6247 if (temp < 3 || temp > 18)
6248 as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6249 last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6250 }
6251 else if ((strncasecmp (name, "entry_fr", 8) == 0))
6252 {
6253 p = input_line_pointer;
6254 *p = c;
6255 input_line_pointer++;
6256 temp = get_absolute_expression ();
6257 /* Similarly the HP assembler takes 31 as the high bound even
6258 though %fr21 is the last callee saved floating point register. */
6259 if (temp < 12 || temp > 21)
6260 as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6261 last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6262 }
6263 else if ((strncasecmp (name, "entry_sr", 8) == 0))
6264 {
6265 p = input_line_pointer;
6266 *p = c;
6267 input_line_pointer++;
6268 temp = get_absolute_expression ();
6269 if (temp != 3)
6270 as_bad (_("Value for ENTRY_SR must be 3\n"));
6271 }
6272 /* Note whether or not this function performs any calls. */
6273 else if ((strncasecmp (name, "calls", 5) == 0) ||
6274 (strncasecmp (name, "caller", 6) == 0))
6275 {
6276 p = input_line_pointer;
6277 *p = c;
6278 }
6279 else if ((strncasecmp (name, "no_calls", 8) == 0))
6280 {
6281 p = input_line_pointer;
6282 *p = c;
6283 }
6284 /* Should RP be saved into the stack. */
6285 else if ((strncasecmp (name, "save_rp", 7) == 0))
6286 {
6287 p = input_line_pointer;
6288 *p = c;
6289 last_call_info->ci_unwind.descriptor.save_rp = 1;
6290 }
6291 /* Likewise for SP. */
6292 else if ((strncasecmp (name, "save_sp", 7) == 0))
6293 {
6294 p = input_line_pointer;
6295 *p = c;
6296 last_call_info->ci_unwind.descriptor.save_sp = 1;
6297 }
6298 /* Is this an unwindable procedure. If so mark it so
6299 in the unwind descriptor. */
6300 else if ((strncasecmp (name, "no_unwind", 9) == 0))
6301 {
6302 p = input_line_pointer;
6303 *p = c;
6304 last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6305 }
6306 /* Is this an interrupt routine. If so mark it in the
6307 unwind descriptor. */
6308 else if ((strncasecmp (name, "hpux_int", 7) == 0))
6309 {
6310 p = input_line_pointer;
6311 *p = c;
6312 last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6313 }
6314 /* Is this a millicode routine. "millicode" isn't in my
6315 assembler manual, but my copy is old. The HP assembler
6316 accepts it, and there's a place in the unwind descriptor
6317 to drop the information, so we'll accept it too. */
6318 else if ((strncasecmp (name, "millicode", 9) == 0))
6319 {
6320 p = input_line_pointer;
6321 *p = c;
6322 last_call_info->ci_unwind.descriptor.millicode = 1;
6323 }
6324 else
6325 {
6326 as_bad (_("Invalid .CALLINFO argument: %s"), name);
6327 *input_line_pointer = c;
6328 }
6329 if (!is_end_of_statement ())
6330 input_line_pointer++;
6331 }
6332
6333 demand_empty_rest_of_line ();
6334}
6335
85cf2a8a 6336#if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
ad1079af
AM		 6337/* Switch to the text space. Like s_text, but delete our
6338 label when finished. */
252b5132 6339static void
ad1079af 6340pa_text (unused)
3f9b03b5 6341 int unused ATTRIBUTE_UNUSED;
252b5132 6342{
49863f82 6343#ifdef OBJ_SOM
252b5132
RH		 6344 current_space = is_defined_space ("$TEXT$");
6345 current_subspace
6346 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
49863f82 6347#endif
ad1079af 6348
252b5132
RH		 6349 s_text (0);
6350 pa_undefine_label ();
6351}
6352
ad1079af
AM		 6353/* Switch to the data space. As usual delete our label. */
6354static void
6355pa_data (unused)
6356 int unused ATTRIBUTE_UNUSED;
6357{
6358#ifdef OBJ_SOM
6359 current_space = is_defined_space ("$PRIVATE$");
6360 current_subspace
6361 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6362#endif
6363 s_data (0);
6364 pa_undefine_label ();
6365}
6366
252b5132
RH		 6367/* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6368 the .comm pseudo-op has the following symtax:
6369
6370 <label> .comm <length>
6371
6372 where <label> is optional and is a symbol whose address will be the start of
6373 a block of memory <length> bytes long. <length> must be an absolute
6374 expression. <length> bytes will be allocated in the current space
6375 and subspace.
6376
6377 Also note the label may not even be on the same line as the .comm.
6378
6379 This difference in syntax means the colon function will be called
6380 on the symbol before we arrive in pa_comm. colon will set a number
6381 of attributes of the symbol that need to be fixed here. In particular
6382 the value, section pointer, fragment pointer, flags, etc. What
6383 a pain.
6384
6385 This also makes error detection all but impossible. */
6386
6387static void
6388pa_comm (unused)
3f9b03b5 6389 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6390{
6391 unsigned int size;
6392 symbolS *symbol;
6393 label_symbol_struct *label_symbol = pa_get_label ();
6394
6395 if (label_symbol)
6396 symbol = label_symbol->lss_label;
6397 else
6398 symbol = NULL;
6399
6400 SKIP_WHITESPACE ();
6401 size = get_absolute_expression ();
6402
6403 if (symbol)
6404 {
9992270f 6405 symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
252b5132
RH		 6406 S_SET_VALUE (symbol, size);
6407 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6408 S_SET_EXTERNAL (symbol);
6409
6410 /* colon() has already set the frag to the current location in the
6411 current subspace; we need to reset the fragment to the zero address
6412 fragment. We also need to reset the segment pointer. */
a0f75b47 6413 symbol_set_frag (symbol, &zero_address_frag);
252b5132
RH		 6414 }
6415 demand_empty_rest_of_line ();
6416}
85cf2a8a 6417#endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
252b5132
RH		 6418
6419/* Process a .END pseudo-op. */
6420
6421static void
6422pa_end (unused)
3f9b03b5 6423 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6424{
6425 demand_empty_rest_of_line ();
6426}
6427
6428/* Process a .ENTER pseudo-op. This is not supported. */
6429static void
6430pa_enter (unused)
3f9b03b5 6431 int unused ATTRIBUTE_UNUSED;
252b5132 6432{
49863f82 6433#ifdef OBJ_SOM
252b5132
RH		 6434 /* We must have a valid space and subspace. */
6435 pa_check_current_space_and_subspace ();
49863f82 6436#endif
252b5132
RH		 6437
6438 as_bad (_("The .ENTER pseudo-op is not supported"));
6439 demand_empty_rest_of_line ();
6440}
6441
6442/* Process a .ENTRY pseudo-op. .ENTRY marks the beginning of the
0234cb7c 6443 procedure. */
252b5132
RH		 6444static void
6445pa_entry (unused)
3f9b03b5 6446 int unused ATTRIBUTE_UNUSED;
252b5132 6447{
49863f82 6448#ifdef OBJ_SOM
252b5132
RH		 6449 /* We must have a valid space and subspace. */
6450 pa_check_current_space_and_subspace ();
49863f82 6451#endif
252b5132
RH		 6452
6453 if (!within_procedure)
6454 as_bad (_("Misplaced .entry. Ignored."));
6455 else
6456 {
6457 if (!callinfo_found)
6458 as_bad (_("Missing .callinfo."));
6459 }
6460 demand_empty_rest_of_line ();
6461 within_entry_exit = TRUE;
6462
6463#ifdef OBJ_SOM
6464 /* SOM defers building of unwind descriptors until the link phase.
6465 The assembler is responsible for creating an R_ENTRY relocation
6466 to mark the beginning of a region and hold the unwind bits, and
6467 for creating an R_EXIT relocation to mark the end of the region.
6468
6469 FIXME. ELF should be using the same conventions! The problem
6470 is an unwind requires too much relocation space. Hmmm. Maybe
6471 if we split the unwind bits up between the relocations which
6472 denote the entry and exit points. */
6473 if (last_call_info->start_symbol != NULL)
6474 {
da6c73e0
AM		 6475 char *where;
6476 unsigned int u;
252b5132 6477
da6c73e0
AM		 6478 where = frag_more (0);
6479 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
252b5132
RH		 6480 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6481 NULL, (offsetT) 0, NULL,
da6c73e0 6482 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
252b5132
RH		 6483 }
6484#endif
6485}
6486
ecacdc7a
AM		 6487/* Silly nonsense for pa_equ. The only half-sensible use for this is
6488 being able to subtract two register symbols that specify a range of
6489 registers, to get the size of the range. */
6490static int fudge_reg_expressions;
6491
6492int
6493hppa_force_reg_syms_absolute (resultP, op, rightP)
6494 expressionS *resultP;
6495 operatorT op ATTRIBUTE_UNUSED;
6496 expressionS *rightP;
6497{
6498 if (fudge_reg_expressions
6499 && rightP->X_op == O_register
6500 && resultP->X_op == O_register)
6501 {
6502 rightP->X_op = O_constant;
6503 resultP->X_op = O_constant;
6504 }
6505 return 0; /* Continue normal expr handling. */
6506}
6507
252b5132
RH		 6508/* Handle a .EQU pseudo-op. */
6509
6510static void
6511pa_equ (reg)
6512 int reg;
6513{
6514 label_symbol_struct *label_symbol = pa_get_label ();
6515 symbolS *symbol;
6516
6517 if (label_symbol)
6518 {
6519 symbol = label_symbol->lss_label;
6520 if (reg)
ecacdc7a
AM		 6521 {
6522 strict = 1;
6523 if (!pa_parse_number (&input_line_pointer, 0))
6524 as_bad (_(".REG expression must be a register"));
6525 S_SET_VALUE (symbol, pa_number);
6526 S_SET_SEGMENT (symbol, reg_section);
6527 }
252b5132 6528 else
ecacdc7a
AM		 6529 {
6530 expressionS exp;
6531 segT seg;
6532
6533 fudge_reg_expressions = 1;
6534 seg = expression (&exp);
6535 fudge_reg_expressions = 0;
6536 if (exp.X_op != O_constant
6537 && exp.X_op != O_register)
6538 {
6539 if (exp.X_op != O_absent)
6540 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6541 exp.X_add_number = 0;
6542 seg = absolute_section;
6543 }
6544 S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6545 S_SET_SEGMENT (symbol, seg);
6546 }
252b5132
RH		 6547 }
6548 else
6549 {
6550 if (reg)
6551 as_bad (_(".REG must use a label"));
6552 else
6553 as_bad (_(".EQU must use a label"));
6554 }
6555
6556 pa_undefine_label ();
6557 demand_empty_rest_of_line ();
6558}
6559
6560/* Helper function. Does processing for the end of a function. This
6561 usually involves creating some relocations or building special
6562 symbols to mark the end of the function. */
6563
6564static void
6565process_exit ()
6566{
6567 char *where;
6568
6569 where = frag_more (0);
6570
6571#ifdef OBJ_ELF
6572 /* Mark the end of the function, stuff away the location of the frag
6573 for the end of the function, and finally call pa_build_unwind_subspace
6574 to add an entry in the unwind table. */
6575 hppa_elf_mark_end_of_function ();
6576 pa_build_unwind_subspace (last_call_info);
6577#else
6578 /* SOM defers building of unwind descriptors until the link phase.
6579 The assembler is responsible for creating an R_ENTRY relocation
6580 to mark the beginning of a region and hold the unwind bits, and
6581 for creating an R_EXIT relocation to mark the end of the region.
6582
6583 FIXME. ELF should be using the same conventions! The problem
6584 is an unwind requires too much relocation space. Hmmm. Maybe
6585 if we split the unwind bits up between the relocations which
6586 denote the entry and exit points. */
6587 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6588 NULL, (offsetT) 0,
6589 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
da6c73e0 6590 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
252b5132
RH		 6591#endif
6592}
6593
6594/* Process a .EXIT pseudo-op. */
6595
6596static void
6597pa_exit (unused)
3f9b03b5 6598 int unused ATTRIBUTE_UNUSED;
252b5132 6599{
49863f82 6600#ifdef OBJ_SOM
252b5132
RH		 6601 /* We must have a valid space and subspace. */
6602 pa_check_current_space_and_subspace ();
49863f82 6603#endif
252b5132
RH		 6604
6605 if (!within_procedure)
6606 as_bad (_(".EXIT must appear within a procedure"));
6607 else
6608 {
6609 if (!callinfo_found)
6610 as_bad (_("Missing .callinfo"));
6611 else
6612 {
6613 if (!within_entry_exit)
6614 as_bad (_("No .ENTRY for this .EXIT"));
6615 else
6616 {
6617 within_entry_exit = FALSE;
6618 process_exit ();
6619 }
6620 }
6621 }
6622 demand_empty_rest_of_line ();
6623}
6624
6625/* Process a .EXPORT directive. This makes functions external
6626 and provides information such as argument relocation entries
6627 to callers. */
6628
6629static void
6630pa_export (unused)
3f9b03b5 6631 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6632{
6633 char *name, c, *p;
6634 symbolS *symbol;
6635
6636 name = input_line_pointer;
6637 c = get_symbol_end ();
6638 /* Make sure the given symbol exists. */
6639 if ((symbol = symbol_find_or_make (name)) == NULL)
6640 {
6641 as_bad (_("Cannot define export symbol: %s\n"), name);
6642 p = input_line_pointer;
6643 *p = c;
6644 input_line_pointer++;
6645 }
6646 else
6647 {
20348649 6648 /* OK. Set the external bits and process argument relocations.
a28a3ccf 6649 For the HP, weak and global are not mutually exclusive.
20348649
JL		 6650 S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6651 Call S_SET_EXTERNAL to get the other processing. Manually
6652 set BSF_GLOBAL when we get back. */
252b5132 6653 S_SET_EXTERNAL (symbol);
20348649 6654 symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
252b5132
RH		 6655 p = input_line_pointer;
6656 *p = c;
6657 if (!is_end_of_statement ())
6658 {
6659 input_line_pointer++;
6660 pa_type_args (symbol, 1);
6661 }
6662 }
6663
6664 demand_empty_rest_of_line ();
6665}
6666
6667/* Helper function to process arguments to a .EXPORT pseudo-op. */
6668
6669static void
6670pa_type_args (symbolP, is_export)
6671 symbolS *symbolP;
6672 int is_export;
6673{
6674 char *name, c, *p;
6675 unsigned int temp, arg_reloc;
6676 pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
904a31bf 6677 asymbol *bfdsym = symbol_get_bfdsym (symbolP);
252b5132
RH		 6678
6679 if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6680
6681 {
6682 input_line_pointer += 8;
904a31bf 6683 bfdsym->flags &= ~BSF_FUNCTION;
252b5132
RH		 6684 S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6685 type = SYMBOL_TYPE_ABSOLUTE;
6686 }
6687 else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6688 {
6689 input_line_pointer += 4;
6690 /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6691 instead one should be IMPORTing/EXPORTing ENTRY types.
6692
6693 Complain if one tries to EXPORT a CODE type since that's never
6694 done. Both GCC and HP C still try to IMPORT CODE types, so
6695 silently fix them to be ENTRY types. */
a0f75b47 6696 if (S_IS_FUNCTION (symbolP))
252b5132
RH		 6697 {
6698 if (is_export)
a0f75b47
ILT		 6699 as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6700 S_GET_NAME (symbolP));
252b5132 6701
904a31bf 6702 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6703 type = SYMBOL_TYPE_ENTRY;
6704 }
6705 else
6706 {
904a31bf 6707 bfdsym->flags &= ~BSF_FUNCTION;
252b5132
RH		 6708 type = SYMBOL_TYPE_CODE;
6709 }
6710 }
6711 else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6712 {
6713 input_line_pointer += 4;
904a31bf
AM		 6714 bfdsym->flags &= ~BSF_FUNCTION;
6715 bfdsym->flags |= BSF_OBJECT;
252b5132
RH		 6716 type = SYMBOL_TYPE_DATA;
6717 }
6718 else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6719 {
6720 input_line_pointer += 5;
904a31bf 6721 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6722 type = SYMBOL_TYPE_ENTRY;
6723 }
6724 else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6725 {
6726 input_line_pointer += 9;
904a31bf
AM		 6727 bfdsym->flags |= BSF_FUNCTION;
6728#ifdef OBJ_ELF
6729 {
6730 elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6731 elfsym->internal_elf_sym.st_info =
6732 ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6733 STT_PARISC_MILLI);
6734 }
6735#endif
252b5132
RH		 6736 type = SYMBOL_TYPE_MILLICODE;
6737 }
6738 else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6739 {
6740 input_line_pointer += 6;
904a31bf 6741 bfdsym->flags &= ~BSF_FUNCTION;
252b5132
RH		 6742 type = SYMBOL_TYPE_PLABEL;
6743 }
6744 else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6745 {
6746 input_line_pointer += 8;
904a31bf 6747 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6748 type = SYMBOL_TYPE_PRI_PROG;
6749 }
6750 else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6751 {
6752 input_line_pointer += 8;
904a31bf 6753 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6754 type = SYMBOL_TYPE_SEC_PROG;
6755 }
6756
6757 /* SOM requires much more information about symbol types
6758 than BFD understands. This is how we get this information
6759 to the SOM BFD backend. */
6760#ifdef obj_set_symbol_type
904a31bf 6761 obj_set_symbol_type (bfdsym, (int) type);
252b5132
RH		 6762#endif
6763
6764 /* Now that the type of the exported symbol has been handled,
6765 handle any argument relocation information. */
6766 while (!is_end_of_statement ())
6767 {
6768 if (*input_line_pointer == ',')
6769 input_line_pointer++;
6770 name = input_line_pointer;
6771 c = get_symbol_end ();
6772 /* Argument sources. */
6773 if ((strncasecmp (name, "argw", 4) == 0))
6774 {
6775 p = input_line_pointer;
6776 *p = c;
6777 input_line_pointer++;
6778 temp = atoi (name + 4);
6779 name = input_line_pointer;
6780 c = get_symbol_end ();
6781 arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
25a8b250 6782#if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
ad1079af 6783 symbol_arg_reloc_info (symbolP) |= arg_reloc;
49863f82 6784#endif
252b5132
RH		 6785 *input_line_pointer = c;
6786 }
6787 /* The return value. */
6788 else if ((strncasecmp (name, "rtnval", 6)) == 0)
6789 {
6790 p = input_line_pointer;
6791 *p = c;
6792 input_line_pointer++;
6793 name = input_line_pointer;
6794 c = get_symbol_end ();
6795 arg_reloc = pa_build_arg_reloc (name);
25a8b250 6796#if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
ad1079af 6797 symbol_arg_reloc_info (symbolP) |= arg_reloc;
49863f82 6798#endif
252b5132
RH		 6799 *input_line_pointer = c;
6800 }
0234cb7c 6801 /* Privilege level. */
252b5132
RH		 6802 else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6803 {
6804 p = input_line_pointer;
6805 *p = c;
6806 input_line_pointer++;
6807 temp = atoi (input_line_pointer);
49863f82 6808#ifdef OBJ_SOM
904a31bf 6809 ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
49863f82 6810#endif
252b5132
RH		 6811 c = get_symbol_end ();
6812 *input_line_pointer = c;
6813 }
6814 else
6815 {
6816 as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6817 p = input_line_pointer;
6818 *p = c;
6819 }
6820 if (!is_end_of_statement ())
6821 input_line_pointer++;
6822 }
6823}
6824
6825/* Handle an .IMPORT pseudo-op. Any symbol referenced in a given
6826 assembly file must either be defined in the assembly file, or
6827 explicitly IMPORTED from another. */
6828
6829static void
6830pa_import (unused)
3f9b03b5 6831 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6832{
6833 char *name, c, *p;
6834 symbolS *symbol;
6835
6836 name = input_line_pointer;
6837 c = get_symbol_end ();
6838
6839 symbol = symbol_find (name);
6840 /* Ugh. We might be importing a symbol defined earlier in the file,
6841 in which case all the code below will really screw things up
6842 (set the wrong segment, symbol flags & type, etc). */
6843 if (symbol == NULL || !S_IS_DEFINED (symbol))
6844 {
6845 symbol = symbol_find_or_make (name);
6846 p = input_line_pointer;
6847 *p = c;
6848
6849 if (!is_end_of_statement ())
6850 {
6851 input_line_pointer++;
6852 pa_type_args (symbol, 0);
6853 }
6854 else
6855 {
0234cb7c 6856 /* Sigh. To be compatible with the HP assembler and to help
252b5132 6857 poorly written assembly code, we assign a type based on
b6ff326e 6858 the current segment. Note only BSF_FUNCTION really
252b5132
RH		 6859 matters, we do not need to set the full SYMBOL_TYPE_* info. */
6860 if (now_seg == text_section)
a0f75b47 6861 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
252b5132
RH		 6862
6863 /* If the section is undefined, then the symbol is undefined
6864 Since this is an import, leave the section undefined. */
6865 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6866 }
6867 }
6868 else
6869 {
6870 /* The symbol was already defined. Just eat everything up to
6871 the end of the current statement. */
6872 while (!is_end_of_statement ())
6873 input_line_pointer++;
6874 }
6875
6876 demand_empty_rest_of_line ();
6877}
6878
6879/* Handle a .LABEL pseudo-op. */
6880
6881static void
6882pa_label (unused)
3f9b03b5 6883 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6884{
6885 char *name, c, *p;
6886
6887 name = input_line_pointer;
6888 c = get_symbol_end ();
6889
6890 if (strlen (name) > 0)
6891 {
6892 colon (name);
6893 p = input_line_pointer;
6894 *p = c;
6895 }
6896 else
6897 {
6898 as_warn (_("Missing label name on .LABEL"));
6899 }
6900
6901 if (!is_end_of_statement ())
6902 {
6903 as_warn (_("extra .LABEL arguments ignored."));
6904 ignore_rest_of_line ();
6905 }
6906 demand_empty_rest_of_line ();
6907}
6908
6909/* Handle a .LEAVE pseudo-op. This is not supported yet. */
6910
6911static void
6912pa_leave (unused)
3f9b03b5 6913 int unused ATTRIBUTE_UNUSED;
252b5132 6914{
49863f82 6915#ifdef OBJ_SOM
252b5132
RH		 6916 /* We must have a valid space and subspace. */
6917 pa_check_current_space_and_subspace ();
49863f82 6918#endif
252b5132
RH		 6919
6920 as_bad (_("The .LEAVE pseudo-op is not supported"));
6921 demand_empty_rest_of_line ();
6922}
6923
6924/* Handle a .LEVEL pseudo-op. */
6925
6926static void
6927pa_level (unused)
3f9b03b5 6928 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6929{
6930 char *level;
6931
6932 level = input_line_pointer;
6933 if (strncmp (level, "1.0", 3) == 0)
6934 {
6935 input_line_pointer += 3;
6936 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6937 as_warn (_("could not set architecture and machine"));
6938 }
6939 else if (strncmp (level, "1.1", 3) == 0)
6940 {
6941 input_line_pointer += 3;
6942 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6943 as_warn (_("could not set architecture and machine"));
6944 }
46031ca9
JL		 6945 else if (strncmp (level, "2.0w", 4) == 0)
6946 {
6947 input_line_pointer += 4;
6948 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6949 as_warn (_("could not set architecture and machine"));
6950 }
252b5132
RH		 6951 else if (strncmp (level, "2.0", 3) == 0)
6952 {
6953 input_line_pointer += 3;
6954 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6955 as_warn (_("could not set architecture and machine"));
6956 }
6957 else
6958 {
6959 as_bad (_("Unrecognized .LEVEL argument\n"));
6960 ignore_rest_of_line ();
6961 }
6962 demand_empty_rest_of_line ();
6963}
6964
6965/* Handle a .ORIGIN pseudo-op. */
6966
6967static void
6968pa_origin (unused)
3f9b03b5 6969 int unused ATTRIBUTE_UNUSED;
252b5132 6970{
49863f82 6971#ifdef OBJ_SOM
252b5132
RH		 6972 /* We must have a valid space and subspace. */
6973 pa_check_current_space_and_subspace ();
49863f82 6974#endif
252b5132
RH		 6975
6976 s_org (0);
6977 pa_undefine_label ();
6978}
6979
6980/* Handle a .PARAM pseudo-op. This is much like a .EXPORT, except it
6981 is for static functions. FIXME. Should share more code with .EXPORT. */
6982
6983static void
6984pa_param (unused)
3f9b03b5 6985 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6986{
6987 char *name, c, *p;
6988 symbolS *symbol;
6989
6990 name = input_line_pointer;
6991 c = get_symbol_end ();
6992
6993 if ((symbol = symbol_find_or_make (name)) == NULL)
6994 {
6995 as_bad (_("Cannot define static symbol: %s\n"), name);
6996 p = input_line_pointer;
6997 *p = c;
6998 input_line_pointer++;
6999 }
7000 else
7001 {
7002 S_CLEAR_EXTERNAL (symbol);
7003 p = input_line_pointer;
7004 *p = c;
7005 if (!is_end_of_statement ())
7006 {
7007 input_line_pointer++;
7008 pa_type_args (symbol, 0);
7009 }
7010 }
7011
7012 demand_empty_rest_of_line ();
7013}
7014
7015/* Handle a .PROC pseudo-op. It is used to mark the beginning
ad1079af 7016 of a procedure from a syntactical point of view. */
252b5132
RH		 7017
7018static void
7019pa_proc (unused)
3f9b03b5 7020 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7021{
7022 struct call_info *call_info;
7023
49863f82 7024#ifdef OBJ_SOM
252b5132
RH		 7025 /* We must have a valid space and subspace. */
7026 pa_check_current_space_and_subspace ();
49863f82 7027#endif
252b5132
RH		 7028
7029 if (within_procedure)
7030 as_fatal (_("Nested procedures"));
7031
7032 /* Reset global variables for new procedure. */
7033 callinfo_found = FALSE;
7034 within_procedure = TRUE;
7035
7036 /* Create another call_info structure. */
7037 call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
7038
7039 if (!call_info)
7040 as_fatal (_("Cannot allocate unwind descriptor\n"));
7041
7042 memset (call_info, 0, sizeof (struct call_info));
7043
7044 call_info->ci_next = NULL;
7045
7046 if (call_info_root == NULL)
7047 {
7048 call_info_root = call_info;
7049 last_call_info = call_info;
7050 }
7051 else
7052 {
7053 last_call_info->ci_next = call_info;
7054 last_call_info = call_info;
7055 }
7056
7057 /* set up defaults on call_info structure */
7058
7059 call_info->ci_unwind.descriptor.cannot_unwind = 0;
7060 call_info->ci_unwind.descriptor.region_desc = 1;
7061 call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
7062
7063 /* If we got a .PROC pseudo-op, we know that the function is defined
7064 locally. Make sure it gets into the symbol table. */
7065 {
7066 label_symbol_struct *label_symbol = pa_get_label ();
7067
7068 if (label_symbol)
7069 {
7070 if (label_symbol->lss_label)
7071 {
7072 last_call_info->start_symbol = label_symbol->lss_label;
a0f75b47 7073 symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
252b5132
RH		 7074 }
7075 else
7076 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7077 }
7078 else
7079 last_call_info->start_symbol = NULL;
7080 }
7081
7082 demand_empty_rest_of_line ();
7083}
7084
0234cb7c 7085/* Process the syntactical end of a procedure. Make sure all the
252b5132
RH		 7086 appropriate pseudo-ops were found within the procedure. */
7087
7088static void
7089pa_procend (unused)
3f9b03b5 7090 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7091{
7092
49863f82 7093#ifdef OBJ_SOM
252b5132
RH		 7094 /* We must have a valid space and subspace. */
7095 pa_check_current_space_and_subspace ();
49863f82 7096#endif
252b5132
RH		 7097
7098 /* If we are within a procedure definition, make sure we've
7099 defined a label for the procedure; handle case where the
7100 label was defined after the .PROC directive.
7101
7102 Note there's not need to diddle with the segment or fragment
7103 for the label symbol in this case. We have already switched
7104 into the new $CODE$ subspace at this point. */
7105 if (within_procedure && last_call_info->start_symbol == NULL)
7106 {
7107 label_symbol_struct *label_symbol = pa_get_label ();
7108
7109 if (label_symbol)
7110 {
7111 if (label_symbol->lss_label)
7112 {
7113 last_call_info->start_symbol = label_symbol->lss_label;
a0f75b47
ILT		 7114 symbol_get_bfdsym (label_symbol->lss_label)->flags
7115 |= BSF_FUNCTION;
252b5132
RH		 7116#ifdef OBJ_SOM
7117 /* Also handle allocation of a fixup to hold the unwind
7118 information when the label appears after the proc/procend. */
7119 if (within_entry_exit)
7120 {
da6c73e0
AM		 7121 char *where;
7122 unsigned int u;
252b5132 7123
da6c73e0
AM		 7124 where = frag_more (0);
7125 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
252b5132
RH		 7126 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7127 NULL, (offsetT) 0, NULL,
da6c73e0 7128 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
252b5132
RH		 7129 }
7130#endif
7131 }
7132 else
7133 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7134 }
7135 else
7136 as_bad (_("Missing function name for .PROC"));
7137 }
7138
7139 if (!within_procedure)
7140 as_bad (_("misplaced .procend"));
7141
7142 if (!callinfo_found)
7143 as_bad (_("Missing .callinfo for this procedure"));
7144
7145 if (within_entry_exit)
7146 as_bad (_("Missing .EXIT for a .ENTRY"));
7147
7148#ifdef OBJ_ELF
7149 /* ELF needs to mark the end of each function so that it can compute
7150 the size of the function (apparently its needed in the symbol table). */
7151 hppa_elf_mark_end_of_function ();
7152#endif
7153
7154 within_procedure = FALSE;
7155 demand_empty_rest_of_line ();
7156 pa_undefine_label ();
7157}
7158
3f9b03b5 7159#ifdef OBJ_SOM
49863f82
JL		 7160/* If VALUE is an exact power of two between zero and 2^31, then
7161 return log2 (VALUE). Else return -1. */
7162
7163static int
b8fc22bc 7164exact_log2 (value)
49863f82
JL		 7165 int value;
7166{
7167 int shift = 0;
7168
7169 while ((1 << shift) != value && shift < 32)
7170 shift++;
7171
7172 if (shift >= 32)
7173 return -1;
7174 else
7175 return shift;
7176}
7177
49863f82
JL		 7178/* Check to make sure we have a valid space and subspace. */
7179
7180static void
7181pa_check_current_space_and_subspace ()
7182{
7183 if (current_space == NULL)
7184 as_fatal (_("Not in a space.\n"));
7185
7186 if (current_subspace == NULL)
7187 as_fatal (_("Not in a subspace.\n"));
7188}
7189
252b5132
RH		 7190/* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7191 then create a new space entry to hold the information specified
7192 by the parameters to the .SPACE directive. */
7193
7194static sd_chain_struct *
7195pa_parse_space_stmt (space_name, create_flag)
7196 char *space_name;
7197 int create_flag;
7198{
7199 char *name, *ptemp, c;
7200 char loadable, defined, private, sort;
ecacdc7a 7201 int spnum;
252b5132
RH		 7202 asection *seg = NULL;
7203 sd_chain_struct *space;
7204
7205 /* load default values */
7206 spnum = 0;
7207 sort = 0;
7208 loadable = TRUE;
7209 defined = TRUE;
7210 private = FALSE;
7211 if (strcmp (space_name, "$TEXT$") == 0)
7212 {
7213 seg = pa_def_spaces[0].segment;
7214 defined = pa_def_spaces[0].defined;
7215 private = pa_def_spaces[0].private;
7216 sort = pa_def_spaces[0].sort;
7217 spnum = pa_def_spaces[0].spnum;
7218 }
7219 else if (strcmp (space_name, "$PRIVATE$") == 0)
7220 {
7221 seg = pa_def_spaces[1].segment;
7222 defined = pa_def_spaces[1].defined;
7223 private = pa_def_spaces[1].private;
7224 sort = pa_def_spaces[1].sort;
7225 spnum = pa_def_spaces[1].spnum;
7226 }
7227
7228 if (!is_end_of_statement ())
7229 {
7230 print_errors = FALSE;
7231 ptemp = input_line_pointer + 1;
7232 /* First see if the space was specified as a number rather than
7233 as a name. According to the PA assembly manual the rest of
7234 the line should be ignored. */
ecacdc7a
AM		 7235 strict = 0;
7236 pa_parse_number (&ptemp, 0);
7237 if (pa_number >= 0)
252b5132 7238 {
ecacdc7a 7239 spnum = pa_number;
252b5132
RH		 7240 input_line_pointer = ptemp;
7241 }
7242 else
7243 {
7244 while (!is_end_of_statement ())
7245 {
7246 input_line_pointer++;
7247 name = input_line_pointer;
7248 c = get_symbol_end ();
7249 if ((strncasecmp (name, "spnum", 5) == 0))
7250 {
7251 *input_line_pointer = c;
7252 input_line_pointer++;
7253 spnum = get_absolute_expression ();
7254 }
7255 else if ((strncasecmp (name, "sort", 4) == 0))
7256 {
7257 *input_line_pointer = c;
7258 input_line_pointer++;
7259 sort = get_absolute_expression ();
7260 }
7261 else if ((strncasecmp (name, "unloadable", 10) == 0))
7262 {
7263 *input_line_pointer = c;
7264 loadable = FALSE;
7265 }
7266 else if ((strncasecmp (name, "notdefined", 10) == 0))
7267 {
7268 *input_line_pointer = c;
7269 defined = FALSE;
7270 }
7271 else if ((strncasecmp (name, "private", 7) == 0))
7272 {
7273 *input_line_pointer = c;
7274 private = TRUE;
7275 }
7276 else
7277 {
7278 as_bad (_("Invalid .SPACE argument"));
7279 *input_line_pointer = c;
7280 if (!is_end_of_statement ())
7281 input_line_pointer++;
7282 }
7283 }
7284 }
7285 print_errors = TRUE;
7286 }
7287
7288 if (create_flag && seg == NULL)
7289 seg = subseg_new (space_name, 0);
7290
7291 /* If create_flag is nonzero, then create the new space with
7292 the attributes computed above. Else set the values in
7293 an already existing space -- this can only happen for
0234cb7c 7294 the first occurrence of a built-in space. */
252b5132
RH		 7295 if (create_flag)
7296 space = create_new_space (space_name, spnum, loadable, defined,
7297 private, sort, seg, 1);
7298 else
7299 {
7300 space = is_defined_space (space_name);
7301 SPACE_SPNUM (space) = spnum;
7302 SPACE_DEFINED (space) = defined & 1;
7303 SPACE_USER_DEFINED (space) = 1;
7304 }
7305
7306#ifdef obj_set_section_attributes
7307 obj_set_section_attributes (seg, defined, private, sort, spnum);
7308#endif
7309
7310 return space;
7311}
7312
7313/* Handle a .SPACE pseudo-op; this switches the current space to the
7314 given space, creating the new space if necessary. */
7315
7316static void
7317pa_space (unused)
3f9b03b5 7318 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7319{
7320 char *name, c, *space_name, *save_s;
252b5132
RH		 7321 sd_chain_struct *sd_chain;
7322
7323 if (within_procedure)
7324 {
7325 as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7326 ignore_rest_of_line ();
7327 }
7328 else
7329 {
7330 /* Check for some of the predefined spaces. FIXME: most of the code
7331 below is repeated several times, can we extract the common parts
7332 and place them into a subroutine or something similar? */
7333 /* FIXME Is this (and the next IF stmt) really right?
7334 What if INPUT_LINE_POINTER points to "$TEXT$FOO"? */
7335 if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7336 {
7337 input_line_pointer += 6;
7338 sd_chain = is_defined_space ("$TEXT$");
7339 if (sd_chain == NULL)
7340 sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7341 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7342 sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7343
7344 current_space = sd_chain;
7345 subseg_set (text_section, sd_chain->sd_last_subseg);
7346 current_subspace
7347 = pa_subsegment_to_subspace (text_section,
7348 sd_chain->sd_last_subseg);
7349 demand_empty_rest_of_line ();
7350 return;
7351 }
7352 if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7353 {
7354 input_line_pointer += 9;
7355 sd_chain = is_defined_space ("$PRIVATE$");
7356 if (sd_chain == NULL)
7357 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7358 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7359 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7360
7361 current_space = sd_chain;
7362 subseg_set (data_section, sd_chain->sd_last_subseg);
7363 current_subspace
7364 = pa_subsegment_to_subspace (data_section,
7365 sd_chain->sd_last_subseg);
7366 demand_empty_rest_of_line ();
7367 return;
7368 }
7369 if (!strncasecmp (input_line_pointer,
7370 GDB_DEBUG_SPACE_NAME,
7371 strlen (GDB_DEBUG_SPACE_NAME)))
7372 {
7373 input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7374 sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7375 if (sd_chain == NULL)
7376 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7377 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7378 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7379
7380 current_space = sd_chain;
7381
7382 {
7383 asection *gdb_section
7384 = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7385
7386 subseg_set (gdb_section, sd_chain->sd_last_subseg);
7387 current_subspace
7388 = pa_subsegment_to_subspace (gdb_section,
7389 sd_chain->sd_last_subseg);
7390 }
7391 demand_empty_rest_of_line ();
7392 return;
7393 }
7394
7395 /* It could be a space specified by number. */
7396 print_errors = 0;
7397 save_s = input_line_pointer;
ecacdc7a
AM		 7398 strict = 0;
7399 pa_parse_number (&input_line_pointer, 0);
7400 if (pa_number >= 0)
252b5132 7401 {
ecacdc7a 7402 if ((sd_chain = pa_find_space_by_number (pa_number)))
252b5132
RH		 7403 {
7404 current_space = sd_chain;
7405
7406 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7407 current_subspace
7408 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7409 sd_chain->sd_last_subseg);
7410 demand_empty_rest_of_line ();
7411 return;
7412 }
7413 }
7414
7415 /* Not a number, attempt to create a new space. */
7416 print_errors = 1;
7417 input_line_pointer = save_s;
7418 name = input_line_pointer;
7419 c = get_symbol_end ();
7420 space_name = xmalloc (strlen (name) + 1);
7421 strcpy (space_name, name);
7422 *input_line_pointer = c;
7423
7424 sd_chain = pa_parse_space_stmt (space_name, 1);
7425 current_space = sd_chain;
7426
7427 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7428 current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7429 sd_chain->sd_last_subseg);
7430 demand_empty_rest_of_line ();
7431 }
7432}
7433
7434/* Switch to a new space. (I think). FIXME. */
7435
7436static void
7437pa_spnum (unused)
3f9b03b5 7438 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7439{
7440 char *name;
7441 char c;
7442 char *p;
7443 sd_chain_struct *space;
7444
7445 name = input_line_pointer;
7446 c = get_symbol_end ();
7447 space = is_defined_space (name);
7448 if (space)
7449 {
7450 p = frag_more (4);
7451 md_number_to_chars (p, SPACE_SPNUM (space), 4);
7452 }
7453 else
7454 as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7455
7456 *input_line_pointer = c;
7457 demand_empty_rest_of_line ();
7458}
7459
252b5132
RH		 7460/* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7461 given subspace, creating the new subspace if necessary.
7462
7463 FIXME. Should mirror pa_space more closely, in particular how
7464 they're broken up into subroutines. */
7465
7466static void
7467pa_subspace (create_new)
7468 int create_new;
7469{
49863f82 7470 char *name, *ss_name, c;
351e2b5a 7471 char loadable, code_only, comdat, common, dup_common, zero, sort;
252b5132
RH		 7472 int i, access, space_index, alignment, quadrant, applicable, flags;
7473 sd_chain_struct *space;
7474 ssd_chain_struct *ssd;
7475 asection *section;
7476
7477 if (current_space == NULL)
7478 as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7479
7480 if (within_procedure)
7481 {
7482 as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7483 ignore_rest_of_line ();
7484 }
7485 else
7486 {
7487 name = input_line_pointer;
7488 c = get_symbol_end ();
7489 ss_name = xmalloc (strlen (name) + 1);
7490 strcpy (ss_name, name);
7491 *input_line_pointer = c;
7492
7493 /* Load default values. */
7494 sort = 0;
7495 access = 0x7f;
7496 loadable = 1;
351e2b5a 7497 comdat = 0;
252b5132
RH		 7498 common = 0;
7499 dup_common = 0;
7500 code_only = 0;
7501 zero = 0;
7502 space_index = ~0;
7503 alignment = 1;
7504 quadrant = 0;
252b5132
RH		 7505
7506 space = current_space;
7507 if (create_new)
7508 ssd = NULL;
7509 else
7510 ssd = is_defined_subspace (ss_name);
7511 /* Allow user to override the builtin attributes of subspaces. But
7512 only allow the attributes to be changed once! */
7513 if (ssd && SUBSPACE_DEFINED (ssd))
7514 {
7515 subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7516 current_subspace = ssd;
7517 if (!is_end_of_statement ())
7518 as_warn (_("Parameters of an existing subspace can\'t be modified"));
7519 demand_empty_rest_of_line ();
7520 return;
7521 }
7522 else
7523 {
7524 /* A new subspace. Load default values if it matches one of
7525 the builtin subspaces. */
7526 i = 0;
7527 while (pa_def_subspaces[i].name)
7528 {
7529 if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7530 {
7531 loadable = pa_def_subspaces[i].loadable;
351e2b5a 7532 comdat = pa_def_subspaces[i].comdat;
252b5132
RH		 7533 common = pa_def_subspaces[i].common;
7534 dup_common = pa_def_subspaces[i].dup_common;
7535 code_only = pa_def_subspaces[i].code_only;
7536 zero = pa_def_subspaces[i].zero;
7537 space_index = pa_def_subspaces[i].space_index;
7538 alignment = pa_def_subspaces[i].alignment;
7539 quadrant = pa_def_subspaces[i].quadrant;
7540 access = pa_def_subspaces[i].access;
7541 sort = pa_def_subspaces[i].sort;
252b5132
RH		 7542 break;
7543 }
7544 i++;
7545 }
7546 }
7547
7548 /* We should be working with a new subspace now. Fill in
7549 any information as specified by the user. */
7550 if (!is_end_of_statement ())
7551 {
7552 input_line_pointer++;
7553 while (!is_end_of_statement ())
7554 {
7555 name = input_line_pointer;
7556 c = get_symbol_end ();
7557 if ((strncasecmp (name, "quad", 4) == 0))
7558 {
7559 *input_line_pointer = c;
7560 input_line_pointer++;
7561 quadrant = get_absolute_expression ();
7562 }
7563 else if ((strncasecmp (name, "align", 5) == 0))
7564 {
7565 *input_line_pointer = c;
7566 input_line_pointer++;
7567 alignment = get_absolute_expression ();
b8fc22bc 7568 if (exact_log2 (alignment) == -1)
252b5132
RH		 7569 {
7570 as_bad (_("Alignment must be a power of 2"));
7571 alignment = 1;
7572 }
7573 }
7574 else if ((strncasecmp (name, "access", 6) == 0))
7575 {
7576 *input_line_pointer = c;
7577 input_line_pointer++;
7578 access = get_absolute_expression ();
7579 }
7580 else if ((strncasecmp (name, "sort", 4) == 0))
7581 {
7582 *input_line_pointer = c;
7583 input_line_pointer++;
7584 sort = get_absolute_expression ();
7585 }
7586 else if ((strncasecmp (name, "code_only", 9) == 0))
7587 {
7588 *input_line_pointer = c;
7589 code_only = 1;
7590 }
7591 else if ((strncasecmp (name, "unloadable", 10) == 0))
7592 {
7593 *input_line_pointer = c;
7594 loadable = 0;
7595 }
351e2b5a
DA		 7596 else if ((strncasecmp (name, "comdat", 6) == 0))
7597 {
7598 *input_line_pointer = c;
7599 comdat = 1;
7600 }
252b5132
RH		 7601 else if ((strncasecmp (name, "common", 6) == 0))
7602 {
7603 *input_line_pointer = c;
7604 common = 1;
7605 }
7606 else if ((strncasecmp (name, "dup_comm", 8) == 0))
7607 {
7608 *input_line_pointer = c;
7609 dup_common = 1;
7610 }
7611 else if ((strncasecmp (name, "zero", 4) == 0))
7612 {
7613 *input_line_pointer = c;
7614 zero = 1;
7615 }
7616 else if ((strncasecmp (name, "first", 5) == 0))
7617 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7618 else
7619 as_bad (_("Invalid .SUBSPACE argument"));
7620 if (!is_end_of_statement ())
7621 input_line_pointer++;
7622 }
7623 }
7624
7625 /* Compute a reasonable set of BFD flags based on the information
7626 in the .subspace directive. */
7627 applicable = bfd_applicable_section_flags (stdoutput);
7628 flags = 0;
7629 if (loadable)
7630 flags |= (SEC_ALLOC | SEC_LOAD);
7631 if (code_only)
7632 flags |= SEC_CODE;
351e2b5a
DA		 7633
7634 /* These flags are used to implement various flavors of initialized
7635 common. The SOM linker discards duplicate subspaces when they
7636 have the same "key" symbol name. This support is more like
7637 GNU linkonce than BFD common. Further, pc-relative relocations
7638 are converted to section relative relocations in BFD common
7639 sections. This complicates the handling of relocations in
7640 common sections containing text and isn't currently supported
7641 correctly in the SOM BFD backend. */
7642 if (comdat || common || dup_common)
7643 flags |= SEC_LINK_ONCE;
252b5132
RH		 7644
7645 flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7646
7647 /* This is a zero-filled subspace (eg BSS). */
7648 if (zero)
7649 flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7650
7651 applicable &= flags;
7652
7653 /* If this is an existing subspace, then we want to use the
7654 segment already associated with the subspace.
7655
7656 FIXME NOW! ELF BFD doesn't appear to be ready to deal with
7657 lots of sections. It might be a problem in the PA ELF
7658 code, I do not know yet. For now avoid creating anything
7659 but the "standard" sections for ELF. */
7660 if (create_new)
7661 section = subseg_force_new (ss_name, 0);
7662 else if (ssd)
7663 section = ssd->ssd_seg;
252b5132
RH		 7664 else
7665 section = subseg_new (ss_name, 0);
7666
7667 if (zero)
7668 seg_info (section)->bss = 1;
7669
7670 /* Now set the flags. */
7671 bfd_set_section_flags (stdoutput, section, applicable);
7672
7673 /* Record any alignment request for this section. */
b8fc22bc 7674 record_alignment (section, exact_log2 (alignment));
252b5132
RH		 7675
7676 /* Set the starting offset for this section. */
7677 bfd_set_section_vma (stdoutput, section,
7678 pa_subspace_start (space, quadrant));
7679
7680 /* Now that all the flags are set, update an existing subspace,
7681 or create a new one. */
7682 if (ssd)
7683
7684 current_subspace = update_subspace (space, ss_name, loadable,
351e2b5a
DA		 7685 code_only, comdat, common,
7686 dup_common, sort, zero, access,
7687 space_index, alignment, quadrant,
252b5132
RH		 7688 section);
7689 else
7690 current_subspace = create_new_subspace (space, ss_name, loadable,
351e2b5a 7691 code_only, comdat, common,
252b5132
RH		 7692 dup_common, zero, sort,
7693 access, space_index,
351e2b5a 7694 alignment, quadrant, section);
252b5132
RH		 7695
7696 demand_empty_rest_of_line ();
7697 current_subspace->ssd_seg = section;
7698 subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7699 }
7700 SUBSPACE_DEFINED (current_subspace) = 1;
7701}
7702
252b5132
RH		 7703/* Create default space and subspace dictionaries. */
7704
7705static void
7706pa_spaces_begin ()
7707{
7708 int i;
7709
7710 space_dict_root = NULL;
7711 space_dict_last = NULL;
7712
7713 i = 0;
7714 while (pa_def_spaces[i].name)
7715 {
7716 char *name;
7717
7718 /* Pick the right name to use for the new section. */
49863f82 7719 name = pa_def_spaces[i].name;
252b5132
RH		 7720
7721 pa_def_spaces[i].segment = subseg_new (name, 0);
7722 create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7723 pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7724 pa_def_spaces[i].private, pa_def_spaces[i].sort,
7725 pa_def_spaces[i].segment, 0);
7726 i++;
7727 }
7728
7729 i = 0;
7730 while (pa_def_subspaces[i].name)
7731 {
7732 char *name;
7733 int applicable, subsegment;
7734 asection *segment = NULL;
7735 sd_chain_struct *space;
7736
7737 /* Pick the right name for the new section and pick the right
7738 subsegment number. */
49863f82
JL		 7739 name = pa_def_subspaces[i].name;
7740 subsegment = 0;
252b5132
RH		 7741
7742 /* Create the new section. */
7743 segment = subseg_new (name, subsegment);
7744
252b5132
RH		 7745 /* For SOM we want to replace the standard .text, .data, and .bss
7746 sections with our own. We also want to set BFD flags for
7747 all the built-in subspaces. */
49863f82 7748 if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
252b5132
RH		 7749 {
7750 text_section = segment;
7751 applicable = bfd_applicable_section_flags (stdoutput);
7752 bfd_set_section_flags (stdoutput, segment,
7753 applicable & (SEC_ALLOC | SEC_LOAD
7754 | SEC_RELOC | SEC_CODE
7755 | SEC_READONLY
7756 | SEC_HAS_CONTENTS));
7757 }
49863f82 7758 else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
252b5132
RH		 7759 {
7760 data_section = segment;
7761 applicable = bfd_applicable_section_flags (stdoutput);
7762 bfd_set_section_flags (stdoutput, segment,
7763 applicable & (SEC_ALLOC | SEC_LOAD
7764 | SEC_RELOC
7765 | SEC_HAS_CONTENTS));
7766
252b5132 7767 }
49863f82 7768 else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
252b5132
RH		 7769 {
7770 bss_section = segment;
7771 applicable = bfd_applicable_section_flags (stdoutput);
7772 bfd_set_section_flags (stdoutput, segment,
7773 applicable & SEC_ALLOC);
7774 }
49863f82 7775 else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
252b5132
RH		 7776 {
7777 applicable = bfd_applicable_section_flags (stdoutput);
7778 bfd_set_section_flags (stdoutput, segment,
7779 applicable & (SEC_ALLOC | SEC_LOAD
7780 | SEC_RELOC
7781 | SEC_READONLY
7782 | SEC_HAS_CONTENTS));
7783 }
49863f82 7784 else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
252b5132
RH		 7785 {
7786 applicable = bfd_applicable_section_flags (stdoutput);
7787 bfd_set_section_flags (stdoutput, segment,
7788 applicable & (SEC_ALLOC | SEC_LOAD
7789 | SEC_RELOC
7790 | SEC_READONLY
7791 | SEC_HAS_CONTENTS));
7792 }
49863f82 7793 else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
252b5132
RH		 7794 {
7795 applicable = bfd_applicable_section_flags (stdoutput);
7796 bfd_set_section_flags (stdoutput, segment,
7797 applicable & (SEC_ALLOC | SEC_LOAD
7798 | SEC_RELOC
7799 | SEC_READONLY
7800 | SEC_HAS_CONTENTS));
7801 }
7802
7803 /* Find the space associated with this subspace. */
7804 space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7805 def_space_index].segment);
7806 if (space == NULL)
7807 {
7808 as_fatal (_("Internal error: Unable to find containing space for %s."),
7809 pa_def_subspaces[i].name);
7810 }
7811
7812 create_new_subspace (space, name,
7813 pa_def_subspaces[i].loadable,
7814 pa_def_subspaces[i].code_only,
351e2b5a 7815 pa_def_subspaces[i].comdat,
252b5132
RH		 7816 pa_def_subspaces[i].common,
7817 pa_def_subspaces[i].dup_common,
7818 pa_def_subspaces[i].zero,
7819 pa_def_subspaces[i].sort,
7820 pa_def_subspaces[i].access,
7821 pa_def_subspaces[i].space_index,
7822 pa_def_subspaces[i].alignment,
7823 pa_def_subspaces[i].quadrant,
7824 segment);
7825 i++;
7826 }
7827}
7828
252b5132
RH		 7829/* Create a new space NAME, with the appropriate flags as defined
7830 by the given parameters. */
7831
7832static sd_chain_struct *
7833create_new_space (name, spnum, loadable, defined, private,
7834 sort, seg, user_defined)
7835 char *name;
7836 int spnum;
b8fc22bc 7837 int loadable ATTRIBUTE_UNUSED;
252b5132
RH		 7838 int defined;
7839 int private;
7840 int sort;
7841 asection *seg;
7842 int user_defined;
7843{
7844 sd_chain_struct *chain_entry;
7845
7846 chain_entry = (sd_chain_struct *) xmalloc (sizeof (sd_chain_struct));
7847 if (!chain_entry)
7848 as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7849 name);
7850
7851 SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7852 strcpy (SPACE_NAME (chain_entry), name);
7853 SPACE_DEFINED (chain_entry) = defined;
7854 SPACE_USER_DEFINED (chain_entry) = user_defined;
7855 SPACE_SPNUM (chain_entry) = spnum;
7856
7857 chain_entry->sd_seg = seg;
7858 chain_entry->sd_last_subseg = -1;
7859 chain_entry->sd_subspaces = NULL;
7860 chain_entry->sd_next = NULL;
7861
7862 /* Find spot for the new space based on its sort key. */
7863 if (!space_dict_last)
7864 space_dict_last = chain_entry;
7865
7866 if (space_dict_root == NULL)
7867 space_dict_root = chain_entry;
7868 else
7869 {
7870 sd_chain_struct *chain_pointer;
7871 sd_chain_struct *prev_chain_pointer;
7872
7873 chain_pointer = space_dict_root;
7874 prev_chain_pointer = NULL;
7875
7876 while (chain_pointer)
7877 {
7878 prev_chain_pointer = chain_pointer;
7879 chain_pointer = chain_pointer->sd_next;
7880 }
7881
7882 /* At this point we've found the correct place to add the new
7883 entry. So add it and update the linked lists as appropriate. */
7884 if (prev_chain_pointer)
7885 {
7886 chain_entry->sd_next = chain_pointer;
7887 prev_chain_pointer->sd_next = chain_entry;
7888 }
7889 else
7890 {
7891 space_dict_root = chain_entry;
7892 chain_entry->sd_next = chain_pointer;
7893 }
7894
7895 if (chain_entry->sd_next == NULL)
7896 space_dict_last = chain_entry;
7897 }
7898
7899 /* This is here to catch predefined spaces which do not get
7900 modified by the user's input. Another call is found at
7901 the bottom of pa_parse_space_stmt to handle cases where
7902 the user modifies a predefined space. */
7903#ifdef obj_set_section_attributes
7904 obj_set_section_attributes (seg, defined, private, sort, spnum);
7905#endif
7906
7907 return chain_entry;
7908}
7909
7910/* Create a new subspace NAME, with the appropriate flags as defined
7911 by the given parameters.
7912
7913 Add the new subspace to the subspace dictionary chain in numerical
7914 order as defined by the SORT entries. */
7915
7916static ssd_chain_struct *
351e2b5a 7917create_new_subspace (space, name, loadable, code_only, comdat, common,
252b5132
RH		 7918 dup_common, is_zero, sort, access, space_index,
7919 alignment, quadrant, seg)
7920 sd_chain_struct *space;
7921 char *name;
b8fc22bc
DA		 7922 int loadable ATTRIBUTE_UNUSED;
7923 int code_only ATTRIBUTE_UNUSED;
7924 int comdat, common, dup_common;
7925 int is_zero ATTRIBUTE_UNUSED;
252b5132
RH		 7926 int sort;
7927 int access;
b8fc22bc
DA		 7928 int space_index ATTRIBUTE_UNUSED;
7929 int alignment ATTRIBUTE_UNUSED;
252b5132
RH		 7930 int quadrant;
7931 asection *seg;
7932{
7933 ssd_chain_struct *chain_entry;
7934
7935 chain_entry = (ssd_chain_struct *) xmalloc (sizeof (ssd_chain_struct));
7936 if (!chain_entry)
7937 as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
7938
7939 SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7940 strcpy (SUBSPACE_NAME (chain_entry), name);
7941
7942 /* Initialize subspace_defined. When we hit a .subspace directive
7943 we'll set it to 1 which "locks-in" the subspace attributes. */
7944 SUBSPACE_DEFINED (chain_entry) = 0;
7945
49863f82 7946 chain_entry->ssd_subseg = 0;
252b5132
RH		 7947 chain_entry->ssd_seg = seg;
7948 chain_entry->ssd_next = NULL;
7949
7950 /* Find spot for the new subspace based on its sort key. */
7951 if (space->sd_subspaces == NULL)
7952 space->sd_subspaces = chain_entry;
7953 else
7954 {
7955 ssd_chain_struct *chain_pointer;
7956 ssd_chain_struct *prev_chain_pointer;
7957
7958 chain_pointer = space->sd_subspaces;
7959 prev_chain_pointer = NULL;
7960
7961 while (chain_pointer)
7962 {
7963 prev_chain_pointer = chain_pointer;
7964 chain_pointer = chain_pointer->ssd_next;
7965 }
7966
7967 /* Now we have somewhere to put the new entry. Insert it and update
7968 the links. */
7969 if (prev_chain_pointer)
7970 {
7971 chain_entry->ssd_next = chain_pointer;
7972 prev_chain_pointer->ssd_next = chain_entry;
7973 }
7974 else
7975 {
7976 space->sd_subspaces = chain_entry;
7977 chain_entry->ssd_next = chain_pointer;
7978 }
7979 }
7980
7981#ifdef obj_set_subsection_attributes
351e2b5a
DA		 7982 obj_set_subsection_attributes (seg, space->sd_seg, access, sort,
7983 quadrant, comdat, common, dup_common);
252b5132
RH		 7984#endif
7985
7986 return chain_entry;
7987}
7988
7989/* Update the information for the given subspace based upon the
7990 various arguments. Return the modified subspace chain entry. */
7991
7992static ssd_chain_struct *
351e2b5a
DA		 7993update_subspace (space, name, loadable, code_only, comdat, common, dup_common,
7994 sort, zero, access, space_index, alignment, quadrant, section)
252b5132
RH		 7995 sd_chain_struct *space;
7996 char *name;
e12904d2
DA		 7997 int loadable ATTRIBUTE_UNUSED;
7998 int code_only ATTRIBUTE_UNUSED;
351e2b5a 7999 int comdat;
252b5132
RH		 8000 int common;
8001 int dup_common;
e12904d2 8002 int zero ATTRIBUTE_UNUSED;
252b5132
RH		 8003 int sort;
8004 int access;
e12904d2
DA		 8005 int space_index ATTRIBUTE_UNUSED;
8006 int alignment ATTRIBUTE_UNUSED;
252b5132
RH		 8007 int quadrant;
8008 asection *section;
8009{
8010 ssd_chain_struct *chain_entry;
8011
8012 chain_entry = is_defined_subspace (name);
8013
8014#ifdef obj_set_subsection_attributes
351e2b5a
DA		 8015 obj_set_subsection_attributes (section, space->sd_seg, access, sort,
8016 quadrant, comdat, common, dup_common);
252b5132
RH		 8017#endif
8018
8019 return chain_entry;
8020}
8021
8022/* Return the space chain entry for the space with the name NAME or
8023 NULL if no such space exists. */
8024
8025static sd_chain_struct *
8026is_defined_space (name)
8027 char *name;
8028{
8029 sd_chain_struct *chain_pointer;
8030
8031 for (chain_pointer = space_dict_root;
8032 chain_pointer;
8033 chain_pointer = chain_pointer->sd_next)
8034 {
8035 if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
8036 return chain_pointer;
8037 }
8038
8039 /* No mapping from segment to space was found. Return NULL. */
8040 return NULL;
8041}
8042
8043/* Find and return the space associated with the given seg. If no mapping
8044 from the given seg to a space is found, then return NULL.
8045
8046 Unlike subspaces, the number of spaces is not expected to grow much,
8047 so a linear exhaustive search is OK here. */
8048
8049static sd_chain_struct *
8050pa_segment_to_space (seg)
8051 asection *seg;
8052{
8053 sd_chain_struct *space_chain;
8054
8055 /* Walk through each space looking for the correct mapping. */
8056 for (space_chain = space_dict_root;
8057 space_chain;
8058 space_chain = space_chain->sd_next)
8059 {
8060 if (space_chain->sd_seg == seg)
8061 return space_chain;
8062 }
8063
8064 /* Mapping was not found. Return NULL. */
8065 return NULL;
8066}
8067
e12904d2
DA		 8068/* Return the first space chain entry for the subspace with the name
8069 NAME or NULL if no such subspace exists.
252b5132 8070
e12904d2
DA		 8071 When there are multiple subspaces with the same name, switching to
8072 the first (i.e., default) subspace is preferable in most situations.
8073 For example, it wouldn't be desirable to merge COMDAT data with non
8074 COMDAT data.
8075
252b5132
RH		 8076 Uses a linear search through all the spaces and subspaces, this may
8077 not be appropriate if we ever being placing each function in its
8078 own subspace. */
8079
8080static ssd_chain_struct *
8081is_defined_subspace (name)
8082 char *name;
8083{
8084 sd_chain_struct *space_chain;
8085 ssd_chain_struct *subspace_chain;
8086
8087 /* Walk through each space. */
8088 for (space_chain = space_dict_root;
8089 space_chain;
8090 space_chain = space_chain->sd_next)
8091 {
8092 /* Walk through each subspace looking for a name which matches. */
8093 for (subspace_chain = space_chain->sd_subspaces;
8094 subspace_chain;
8095 subspace_chain = subspace_chain->ssd_next)
8096 if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
8097 return subspace_chain;
8098 }
8099
8100 /* Subspace wasn't found. Return NULL. */
8101 return NULL;
8102}
8103
8104/* Find and return the subspace associated with the given seg. If no
8105 mapping from the given seg to a subspace is found, then return NULL.
8106
8107 If we ever put each procedure/function within its own subspace
8108 (to make life easier on the compiler and linker), then this will have
8109 to become more efficient. */
8110
8111static ssd_chain_struct *
8112pa_subsegment_to_subspace (seg, subseg)
8113 asection *seg;
8114 subsegT subseg;
8115{
8116 sd_chain_struct *space_chain;
8117 ssd_chain_struct *subspace_chain;
8118
8119 /* Walk through each space. */
8120 for (space_chain = space_dict_root;
8121 space_chain;
8122 space_chain = space_chain->sd_next)
8123 {
8124 if (space_chain->sd_seg == seg)
8125 {
8126 /* Walk through each subspace within each space looking for
8127 the correct mapping. */
8128 for (subspace_chain = space_chain->sd_subspaces;
8129 subspace_chain;
8130 subspace_chain = subspace_chain->ssd_next)
8131 if (subspace_chain->ssd_subseg == (int) subseg)
8132 return subspace_chain;
8133 }
8134 }
8135
8136 /* No mapping from subsegment to subspace found. Return NULL. */
8137 return NULL;
8138}
8139
8140/* Given a number, try and find a space with the name number.
8141
8142 Return a pointer to a space dictionary chain entry for the space
8143 that was found or NULL on failure. */
8144
8145static sd_chain_struct *
8146pa_find_space_by_number (number)
8147 int number;
8148{
8149 sd_chain_struct *space_chain;
8150
8151 for (space_chain = space_dict_root;
8152 space_chain;
8153 space_chain = space_chain->sd_next)
8154 {
8155 if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8156 return space_chain;
8157 }
8158
8159 /* No appropriate space found. Return NULL. */
8160 return NULL;
8161}
8162
8163/* Return the starting address for the given subspace. If the starting
8164 address is unknown then return zero. */
8165
8166static unsigned int
8167pa_subspace_start (space, quadrant)
8168 sd_chain_struct *space;
8169 int quadrant;
8170{
252b5132
RH		 8171 /* FIXME. Assumes everyone puts read/write data at 0x4000000, this
8172 is not correct for the PA OSF1 port. */
8173 if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8174 return 0x40000000;
8175 else if (space->sd_seg == data_section && quadrant == 1)
8176 return 0x40000000;
8177 else
8178 return 0;
252b5132
RH		 8179 return 0;
8180}
49863f82 8181#endif
252b5132
RH		 8182
8183/* Helper function for pa_stringer. Used to find the end of
8184 a string. */
8185
8186static unsigned int
8187pa_stringer_aux (s)
8188 char *s;
8189{
8190 unsigned int c = *s & CHAR_MASK;
8191
252b5132
RH		 8192 switch (c)
8193 {
8194 case '\"':
8195 c = NOT_A_CHAR;
8196 break;
8197 default:
8198 break;
8199 }
8200 return c;
8201}
8202
8203/* Handle a .STRING type pseudo-op. */
8204
8205static void
8206pa_stringer (append_zero)
8207 int append_zero;
8208{
8209 char *s, num_buf[4];
8210 unsigned int c;
8211 int i;
8212
8213 /* Preprocess the string to handle PA-specific escape sequences.
ad1079af 8214 For example, \xDD where DD is a hexadecimal number should be
252b5132
RH		 8215 changed to \OOO where OOO is an octal number. */
8216
ad1079af
AM		 8217#ifdef OBJ_SOM
8218 /* We must have a valid space and subspace. */
8219 pa_check_current_space_and_subspace ();
8220#endif
8221
252b5132
RH		 8222 /* Skip the opening quote. */
8223 s = input_line_pointer + 1;
8224
8225 while (is_a_char (c = pa_stringer_aux (s++)))
8226 {
8227 if (c == '\\')
8228 {
8229 c = *s;
8230 switch (c)
8231 {
8232 /* Handle \x<num>. */
8233 case 'x':
8234 {
8235 unsigned int number;
8236 int num_digit;
8237 char dg;
8238 char *s_start = s;
8239
ad1079af 8240 /* Get past the 'x'. */
252b5132
RH		 8241 s++;
8242 for (num_digit = 0, number = 0, dg = *s;
8243 num_digit < 2
3882b010 8244 && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
252b5132
RH		 8245 || (dg >= 'A' && dg <= 'F'));
8246 num_digit++)
8247 {
3882b010 8248 if (ISDIGIT (dg))
252b5132
RH		 8249 number = number * 16 + dg - '0';
8250 else if (dg >= 'a' && dg <= 'f')
8251 number = number * 16 + dg - 'a' + 10;
8252 else
8253 number = number * 16 + dg - 'A' + 10;
8254
8255 s++;
8256 dg = *s;
8257 }
8258 if (num_digit > 0)
8259 {
8260 switch (num_digit)
8261 {
8262 case 1:
8263 sprintf (num_buf, "%02o", number);
8264 break;
8265 case 2:
8266 sprintf (num_buf, "%03o", number);
8267 break;
8268 }
8269 for (i = 0; i <= num_digit; i++)
8270 s_start[i] = num_buf[i];
8271 }
8272 break;
8273 }
8274 /* This might be a "\"", skip over the escaped char. */
8275 default:
8276 s++;
8277 break;
8278 }
8279 }
8280 }
8281 stringer (append_zero);
8282 pa_undefine_label ();
8283}
8284
8285/* Handle a .VERSION pseudo-op. */
8286
8287static void
8288pa_version (unused)
3f9b03b5 8289 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 8290{
8291 obj_version (0);
8292 pa_undefine_label ();
8293}
8294
8295#ifdef OBJ_SOM
8296
8297/* Handle a .COMPILER pseudo-op. */
8298
8299static void
8300pa_compiler (unused)
3f9b03b5 8301 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 8302{
8303 obj_som_compiler (0);
8304 pa_undefine_label ();
8305}
8306
8307#endif
8308
8309/* Handle a .COPYRIGHT pseudo-op. */
8310
8311static void
8312pa_copyright (unused)
3f9b03b5 8313 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 8314{
8315 obj_copyright (0);
8316 pa_undefine_label ();
8317}
8318
8319/* Just like a normal cons, but when finished we have to undefine
8320 the latest space label. */
8321
8322static void
8323pa_cons (nbytes)
8324 int nbytes;
8325{
8326 cons (nbytes);
8327 pa_undefine_label ();
8328}
8329
252b5132
RH		 8330/* Like float_cons, but we need to undefine our label. */
8331
8332static void
8333pa_float_cons (float_type)
8334 int float_type;
8335{
8336 float_cons (float_type);
8337 pa_undefine_label ();
8338}
8339
8340/* Like s_fill, but delete our label when finished. */
8341
8342static void
8343pa_fill (unused)
3f9b03b5 8344 int unused ATTRIBUTE_UNUSED;
252b5132 8345{
49863f82 8346#ifdef OBJ_SOM
252b5132
RH		 8347 /* We must have a valid space and subspace. */
8348 pa_check_current_space_and_subspace ();
49863f82 8349#endif
252b5132
RH		 8350
8351 s_fill (0);
8352 pa_undefine_label ();
8353}
8354
8355/* Like lcomm, but delete our label when finished. */
8356
8357static void
8358pa_lcomm (needs_align)
8359 int needs_align;
8360{
49863f82 8361#ifdef OBJ_SOM
252b5132
RH		 8362 /* We must have a valid space and subspace. */
8363 pa_check_current_space_and_subspace ();
49863f82 8364#endif
252b5132
RH		 8365
8366 s_lcomm (needs_align);
8367 pa_undefine_label ();
8368}
8369
8370/* Like lsym, but delete our label when finished. */
8371
8372static void
8373pa_lsym (unused)
3f9b03b5 8374 int unused ATTRIBUTE_UNUSED;
252b5132 8375{
49863f82 8376#ifdef OBJ_SOM
252b5132
RH		 8377 /* We must have a valid space and subspace. */
8378 pa_check_current_space_and_subspace ();
49863f82 8379#endif
252b5132
RH		 8380
8381 s_lsym (0);
8382 pa_undefine_label ();
8383}
8384
252b5132
RH		 8385/* On the PA relocations which involve function symbols must not be
8386 adjusted. This so that the linker can know when/how to create argument
8387 relocation stubs for indirect calls and calls to static functions.
8388
8389 "T" field selectors create DLT relative fixups for accessing
8390 globals and statics in PIC code; each DLT relative fixup creates
8391 an entry in the DLT table. The entries contain the address of
8392 the final target (eg accessing "foo" would create a DLT entry
8393 with the address of "foo").
8394
8395 Unfortunately, the HP linker doesn't take into account any addend
8396 when generating the DLT; so accessing $LIT$+8 puts the address of
8397 $LIT$ into the DLT rather than the address of $LIT$+8.
8398
8399 The end result is we can't perform relocation symbol reductions for
8400 any fixup which creates entries in the DLT (eg they use "T" field
8401 selectors).
8402
8403 Reject reductions involving symbols with external scope; such
d53d2751 8404 reductions make life a living hell for object file editors.
252b5132
RH		 8405
8406 FIXME. Also reject R_HPPA relocations which are 32bits wide in
8407 the code space. The SOM BFD backend doesn't know how to pull the
8408 right bits out of an instruction. */
8409
8410int
8411hppa_fix_adjustable (fixp)
8412 fixS *fixp;
8413{
2337eb33 8414#ifdef OBJ_ELF
3dcfe21d 8415 reloc_type code;
2337eb33 8416#endif
252b5132
RH		 8417 struct hppa_fix_struct *hppa_fix;
8418
8419 hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8420
8421#ifdef OBJ_SOM
2337eb33
DA		 8422 /* Reject reductions of symbols in 32bit relocs unless they
8423 are fake labels. */
8424 if (fixp->fx_r_type == R_HPPA
8425 && hppa_fix->fx_r_format == 32
8426 && strncmp (S_GET_NAME (fixp->fx_addsy),
8427 FAKE_LABEL_NAME,
8428 strlen (FAKE_LABEL_NAME)))
252b5132 8429 return 0;
1cd1c99b 8430#endif
252b5132 8431
904a31bf 8432#ifdef OBJ_ELF
3dcfe21d
AM		 8433 /* LR/RR selectors are implicitly used for a number of different relocation
8434 types. We must ensure that none of these types are adjusted (see below)
8435 even if they occur with a different selector. */
8436 code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8437 hppa_fix->fx_r_format,
8438 hppa_fix->fx_r_field);
8439
8440 switch (code)
8441 {
8442 /* Relocation types which use e_lrsel. */
8443 case R_PARISC_DIR21L:
3dcfe21d
AM		 8444 case R_PARISC_DLTREL21L:
8445 case R_PARISC_DPREL21L:
3dcfe21d
AM		 8446 case R_PARISC_PLTOFF21L:
8447
8448 /* Relocation types which use e_rrsel. */
8449 case R_PARISC_DIR14R:
8450 case R_PARISC_DIR14DR:
8451 case R_PARISC_DIR14WR:
8452 case R_PARISC_DIR17R:
3dcfe21d
AM		 8453 case R_PARISC_DLTREL14R:
8454 case R_PARISC_DLTREL14DR:
8455 case R_PARISC_DLTREL14WR:
8456 case R_PARISC_DPREL14R:
8457 case R_PARISC_DPREL14DR:
8458 case R_PARISC_DPREL14WR:
40d74fb1
JL		 8459 case R_PARISC_PLTOFF14R:
8460 case R_PARISC_PLTOFF14DR:
8461 case R_PARISC_PLTOFF14WR:
3dcfe21d
AM		 8462
8463 /* Other types that we reject for reduction. */
8464 case R_PARISC_GNU_VTENTRY:
8465 case R_PARISC_GNU_VTINHERIT:
8466 return 0;
8467 default:
8468 break;
8469 }
5506e1a5 8470#endif
959ee541 8471
252b5132 8472 /* Reject reductions of symbols in sym1-sym2 expressions when
d53d2751 8473 the fixup will occur in a CODE subspace.
252b5132
RH		 8474
8475 XXX FIXME: Long term we probably want to reject all of these;
8476 for example reducing in the debug section would lose if we ever
8477 supported using the optimizing hp linker. */
8478 if (fixp->fx_addsy
8479 && fixp->fx_subsy
8480 && (hppa_fix->segment->flags & SEC_CODE))
a161fe53 8481 return 0;
252b5132
RH		 8482
8483 /* We can't adjust any relocs that use LR% and RR% field selectors.
1cd1c99b
AM		 8484
8485 If a symbol is reduced to a section symbol, the assembler will
8486 adjust the addend unless the symbol happens to reside right at
8487 the start of the section. Additionally, the linker has no choice
8488 but to manipulate the addends when coalescing input sections for
8489 "ld -r". Since an LR% field selector is defined to round the
8490 addend, we can't change the addend without risking that a LR% and
8491 it's corresponding (possible multiple) RR% field will no longer
8492 sum to the right value.
8493
8494 eg. Suppose we have
8495 . ldil LR%foo+0,%r21
8496 . ldw RR%foo+0(%r21),%r26
25a8b250
AM		 8497 . ldw RR%foo+4(%r21),%r25
8498
8499 If foo is at address 4092 (decimal) in section `sect', then after
8500 reducing to the section symbol we get
8501 . LR%sect+4092 == (L%sect)+0
8502 . RR%sect+4092 == (R%sect)+4092
8503 . RR%sect+4096 == (R%sect)-4096
8504 and the last address loses because rounding the addend to 8k
0234cb7c 8505 multiples takes us up to 8192 with an offset of -4096.
25a8b250
AM		 8506
8507 In cases where the LR% expression is identical to the RR% one we
8508 will never have a problem, but is so happens that gcc rounds
8509 addends involved in LR% field selectors to work around a HP
8510 linker bug. ie. We often have addresses like the last case
1cd1c99b
AM		 8511 above where the LR% expression is offset from the RR% one. */
8512
252b5132
RH		 8513 if (hppa_fix->fx_r_field == e_lrsel
8514 || hppa_fix->fx_r_field == e_rrsel
8515 || hppa_fix->fx_r_field == e_nlrsel)
8516 return 0;
252b5132
RH		 8517
8518 /* Reject reductions of symbols in DLT relative relocs,
8519 relocations with plabels. */
8520 if (hppa_fix->fx_r_field == e_tsel
8521 || hppa_fix->fx_r_field == e_ltsel
8522 || hppa_fix->fx_r_field == e_rtsel
8523 || hppa_fix->fx_r_field == e_psel
8524 || hppa_fix->fx_r_field == e_rpsel
8525 || hppa_fix->fx_r_field == e_lpsel)
8526 return 0;
8527
252b5132
RH		 8528 /* Reject absolute calls (jumps). */
8529 if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8530 return 0;
8531
8532 /* Reject reductions of function symbols. */
5506e1a5
AM		 8533 if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8534 return 0;
252b5132 8535
5506e1a5 8536 return 1;
252b5132
RH		 8537}
8538
8539/* Return nonzero if the fixup in FIXP will require a relocation,
8540 even it if appears that the fixup could be completely handled
8541 within GAS. */
8542
8543int
8544hppa_force_relocation (fixp)
ad1079af 8545 struct fix *fixp;
252b5132
RH		 8546{
8547 struct hppa_fix_struct *hppa_fixp;
252b5132
RH		 8548
8549 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8550#ifdef OBJ_SOM
ad1079af
AM		 8551 if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8552 || fixp->fx_r_type == (int) R_HPPA_EXIT
8553 || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8554 || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8555 || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8556 || fixp->fx_r_type == (int) R_HPPA_END_TRY
252b5132
RH		 8557 || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8558 && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8559 return 1;
8560#endif
904a31bf
AM		 8561#ifdef OBJ_ELF
8562 if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8563 || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8564 return 1;
5506e1a5
AM		 8565#endif
8566
8567 assert (fixp->fx_addsy != NULL);
252b5132 8568
9e754211
AM		 8569 /* Ensure we emit a relocation for global symbols so that dynamic
8570 linking works. */
ae6063d4 8571 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
9e754211
AM		 8572 return 1;
8573
252b5132 8574 /* It is necessary to force PC-relative calls/jumps to have a relocation
b6ff326e 8575 entry if they're going to need either an argument relocation or long
9e754211 8576 call stub. */
5506e1a5
AM		 8577 if (fixp->fx_pcrel
8578 && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8579 hppa_fixp->fx_arg_reloc))
252b5132 8580 return 1;
ad1079af 8581
5506e1a5
AM		 8582 /* Now check to see if we're going to need a long-branch stub. */
8583 if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8584 {
ec8b3afd
JL		 8585 long pc = md_pcrel_from (fixp);
8586 valueT distance, min_stub_distance;
5506e1a5 8587
ec8b3afd
JL		 8588 distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8589
8590 /* Distance to the closest possible stub. This will detect most
8591 but not all circumstances where a stub will not work. */
8592 min_stub_distance = pc + 16;
8593#ifdef OBJ_SOM
8594 if (last_call_info != NULL)
8595 min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
27df9f40 8596#endif
ec8b3afd
JL		 8597
8598 if ((distance + 8388608 >= 16777216
8599 && min_stub_distance <= 8388608)
8600 || (hppa_fixp->fx_r_format == 17
8601 && distance + 262144 >= 524288
8602 && min_stub_distance <= 262144)
8603 || (hppa_fixp->fx_r_format == 12
8604 && distance + 8192 >= 16384
8605 && min_stub_distance <= 8192)
27df9f40 8606 )
5506e1a5
AM		 8607 return 1;
8608 }
252b5132 8609
ad1079af 8610 if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
252b5132 8611 return 1;
252b5132
RH		 8612
8613 /* No need (yet) to force another relocations to be emitted. */
8614 return 0;
8615}
8616
8617/* Now for some ELF specific code. FIXME. */
8618#ifdef OBJ_ELF
8619/* Mark the end of a function so that it's possible to compute
ec8b3afd 8620 the size of the function in elf_hppa_final_processing. */
252b5132
RH		 8621
8622static void
8623hppa_elf_mark_end_of_function ()
8624{
8625 /* ELF does not have EXIT relocations. All we do is create a
8626 temporary symbol marking the end of the function. */
ad1079af
AM		 8627 char *name;
8628
8629 if (last_call_info == NULL || last_call_info->start_symbol == NULL)
8630 {
8631 /* We have already warned about a missing label,
8632 or other problems. */
8633 return;
8634 }
252b5132 8635
ad1079af
AM		 8636 name = (char *) xmalloc (strlen ("L$\001end_")
8637 + strlen (S_GET_NAME (last_call_info->start_symbol))
8638 + 1);
252b5132
RH		 8639 if (name)
8640 {
8641 symbolS *symbolP;
8642
8643 strcpy (name, "L$\001end_");
8644 strcat (name, S_GET_NAME (last_call_info->start_symbol));
8645
8646 /* If we have a .exit followed by a .procend, then the
8647 symbol will have already been defined. */
8648 symbolP = symbol_find (name);
8649 if (symbolP)
8650 {
8651 /* The symbol has already been defined! This can
8652 happen if we have a .exit followed by a .procend.
8653
8654 This is *not* an error. All we want to do is free
8655 the memory we just allocated for the name and continue. */
8656 xfree (name);
8657 }
8658 else
8659 {
8660 /* symbol value should be the offset of the
8661 last instruction of the function */
8662 symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
8663 frag_now);
8664
8665 assert (symbolP);
a0f75b47 8666 S_CLEAR_EXTERNAL (symbolP);
252b5132
RH		 8667 symbol_table_insert (symbolP);
8668 }
8669
8670 if (symbolP)
8671 last_call_info->end_symbol = symbolP;
8672 else
8673 as_bad (_("Symbol '%s' could not be created."), name);
8674
8675 }
8676 else
8677 as_bad (_("No memory for symbol name."));
8678
8679}
8680
8681/* For ELF, this function serves one purpose: to setup the st_size
8682 field of STT_FUNC symbols. To do this, we need to scan the
8683 call_info structure list, determining st_size in by taking the
8684 difference in the address of the beginning/end marker symbols. */
8685
8686void
8687elf_hppa_final_processing ()
8688{
8689 struct call_info *call_info_pointer;
8690
8691 for (call_info_pointer = call_info_root;
8692 call_info_pointer;
8693 call_info_pointer = call_info_pointer->ci_next)
8694 {
8695 elf_symbol_type *esym
a0f75b47
ILT		 8696 = ((elf_symbol_type *)
8697 symbol_get_bfdsym (call_info_pointer->start_symbol));
252b5132
RH		 8698 esym->internal_elf_sym.st_size =
8699 S_GET_VALUE (call_info_pointer->end_symbol)
8700 - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8701 }
8702}
2d93dcc4 8703
904a31bf
AM		 8704static void
8705pa_vtable_entry (ignore)
8706 int ignore ATTRIBUTE_UNUSED;
8707{
8708 struct fix *new_fix;
8709
8710 new_fix = obj_elf_vtable_entry (0);
8711
8712 if (new_fix)
8713 {
8714 struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8715 obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8716 hppa_fix->fx_r_type = R_HPPA;
8717 hppa_fix->fx_r_field = e_fsel;
8718 hppa_fix->fx_r_format = 32;
8719 hppa_fix->fx_arg_reloc = 0;
8720 hppa_fix->segment = now_seg;
8721 new_fix->tc_fix_data = (void *) hppa_fix;
8722 new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8723 }
8724}
8725
8726static void
8727pa_vtable_inherit (ignore)
8728 int ignore ATTRIBUTE_UNUSED;
8729{
8730 struct fix *new_fix;
8731
8732 new_fix = obj_elf_vtable_inherit (0);
8733
8734 if (new_fix)
8735 {
8736 struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8737 obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8738 hppa_fix->fx_r_type = R_HPPA;
8739 hppa_fix->fx_r_field = e_fsel;
8740 hppa_fix->fx_r_format = 32;
8741 hppa_fix->fx_arg_reloc = 0;
8742 hppa_fix->segment = now_seg;
8743 new_fix->tc_fix_data = (void *) hppa_fix;
8744 new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8745 }
8746}
2d93dcc4 8747#endif
GDB Binutils - Deliverables
This page took 0.764273 seconds and 4 git commands to generate.