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