projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gas/
[deliverable/binutils-gdb.git] / gas / config / tc-hppa.c
CommitLineData
252b5132 1/* tc-hppa.c -- Assemble for the PA
c7d004c5 2 Copyright 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
aef6203b 3 2002, 2003, 2004 Free Software Foundation, Inc.
252b5132
RH		 4
5 This file is part of GAS, the GNU Assembler.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
4b4da160
NC		 19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
252b5132 21
252b5132
RH		 22/* HP PA-RISC support was contributed by the Center for Software Science
23 at the University of Utah. */
24
25#include <stdio.h>
252b5132
RH		 26
27#include "as.h"
3882b010 28#include "safe-ctype.h"
252b5132
RH		 29#include "subsegs.h"
30
31#include "bfd/libhppa.h"
252b5132
RH		 32
33/* Be careful, this file includes data *declarations*. */
34#include "opcode/hppa.h"
35
49863f82
JL		 36#if defined (OBJ_ELF) && defined (OBJ_SOM)
37error only one of OBJ_ELF and OBJ_SOM can be defined
38#endif
39
2d93dcc4
JL		 40/* If we are using ELF, then we probably can support dwarf2 debug
41 records. Furthermore, if we are supporting dwarf2 debug records,
42 then we want to use the assembler support for compact line numbers. */
43#ifdef OBJ_ELF
44#include "dwarf2dbg.h"
2d93dcc4 45
0234cb7c 46/* A "convenient" place to put object file dependencies which do
252b5132 47 not need to be seen outside of tc-hppa.c. */
ad1079af 48
252b5132 49/* Object file formats specify relocation types. */
ad1079af 50typedef enum elf_hppa_reloc_type reloc_type;
252b5132
RH		 51
52/* Object file formats specify BFD symbol types. */
53typedef elf_symbol_type obj_symbol_type;
ad1079af
AM		 54#define symbol_arg_reloc_info(sym)\
55 (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.hppa_arg_reloc)
252b5132 56
ad1079af 57#if TARGET_ARCH_SIZE == 64
252b5132 58/* How to generate a relocation. */
b388df87 59#define hppa_gen_reloc_type _bfd_elf64_hppa_gen_reloc_type
3dcfe21d 60#define elf_hppa_reloc_final_type elf64_hppa_reloc_final_type
b388df87
JL		 61#else
62#define hppa_gen_reloc_type _bfd_elf32_hppa_gen_reloc_type
3dcfe21d 63#define elf_hppa_reloc_final_type elf32_hppa_reloc_final_type
b388df87 64#endif
252b5132
RH		 65
66/* ELF objects can have versions, but apparently do not have anywhere
67 to store a copyright string. */
68#define obj_version obj_elf_version
69#define obj_copyright obj_elf_version
46031ca9
JL		 70
71#define UNWIND_SECTION_NAME ".PARISC.unwind"
ad1079af 72#endif /* OBJ_ELF */
252b5132
RH		 73
74#ifdef OBJ_SOM
75/* Names of various debugging spaces/subspaces. */
76#define GDB_DEBUG_SPACE_NAME "$GDB_DEBUG$"
77#define GDB_STRINGS_SUBSPACE_NAME "$GDB_STRINGS$"
78#define GDB_SYMBOLS_SUBSPACE_NAME "$GDB_SYMBOLS$"
79#define UNWIND_SECTION_NAME "$UNWIND$"
80
81/* Object file formats specify relocation types. */
82typedef int reloc_type;
83
84/* SOM objects can have both a version string and a copyright string. */
85#define obj_version obj_som_version
86#define obj_copyright obj_som_copyright
87
252b5132
RH		 88/* How to generate a relocation. */
89#define hppa_gen_reloc_type hppa_som_gen_reloc_type
90
91/* Object file formats specify BFD symbol types. */
92typedef som_symbol_type obj_symbol_type;
ad1079af
AM		 93#define symbol_arg_reloc_info(sym)\
94 (((obj_symbol_type *) symbol_get_bfdsym (sym))->tc_data.ap.hppa_arg_reloc)
252b5132
RH		 95
96/* This apparently isn't in older versions of hpux reloc.h. */
97#ifndef R_DLT_REL
98#define R_DLT_REL 0x78
99#endif
252b5132
RH		 100
101#ifndef R_N0SEL
102#define R_N0SEL 0xd8
103#endif
104
105#ifndef R_N1SEL
106#define R_N1SEL 0xd9
107#endif
ad1079af 108#endif /* OBJ_SOM */
252b5132 109
8a238888
AM		 110#if TARGET_ARCH_SIZE == 64
111#define DEFAULT_LEVEL 25
112#else
113#define DEFAULT_LEVEL 10
114#endif
115
252b5132
RH		 116/* Various structures and types used internally in tc-hppa.c. */
117
118/* Unwind table and descriptor. FIXME: Sync this with GDB version. */
119
120struct unwind_desc
121 {
122 unsigned int cannot_unwind:1;
123 unsigned int millicode:1;
124 unsigned int millicode_save_rest:1;
125 unsigned int region_desc:2;
126 unsigned int save_sr:2;
127 unsigned int entry_fr:4;
128 unsigned int entry_gr:5;
129 unsigned int args_stored:1;
130 unsigned int call_fr:5;
131 unsigned int call_gr:5;
132 unsigned int save_sp:1;
133 unsigned int save_rp:1;
134 unsigned int save_rp_in_frame:1;
135 unsigned int extn_ptr_defined:1;
136 unsigned int cleanup_defined:1;
137
138 unsigned int hpe_interrupt_marker:1;
139 unsigned int hpux_interrupt_marker:1;
140 unsigned int reserved:3;
141 unsigned int frame_size:27;
142 };
143
da6c73e0
AM		 144/* We can't rely on compilers placing bitfields in any particular
145 place, so use these macros when dumping unwind descriptors to
146 object files. */
147#define UNWIND_LOW32(U) \
148 (((U)->cannot_unwind << 31) \
149 | ((U)->millicode << 30) \
150 | ((U)->millicode_save_rest << 29) \
151 | ((U)->region_desc << 27) \
152 | ((U)->save_sr << 25) \
153 | ((U)->entry_fr << 21) \
154 | ((U)->entry_gr << 16) \
155 | ((U)->args_stored << 15) \
156 | ((U)->call_fr << 10) \
157 | ((U)->call_gr << 5) \
158 | ((U)->save_sp << 4) \
159 | ((U)->save_rp << 3) \
160 | ((U)->save_rp_in_frame << 2) \
161 | ((U)->extn_ptr_defined << 1) \
162 | ((U)->cleanup_defined << 0))
163
164#define UNWIND_HIGH32(U) \
165 (((U)->hpe_interrupt_marker << 31) \
166 | ((U)->hpux_interrupt_marker << 30) \
167 | ((U)->frame_size << 0))
168
252b5132
RH		 169struct unwind_table
170 {
171 /* Starting and ending offsets of the region described by
172 descriptor. */
173 unsigned int start_offset;
174 unsigned int end_offset;
175 struct unwind_desc descriptor;
176 };
177
178/* This structure is used by the .callinfo, .enter, .leave pseudo-ops to
179 control the entry and exit code they generate. It is also used in
180 creation of the correct stack unwind descriptors.
181
182 NOTE: GAS does not support .enter and .leave for the generation of
183 prologues and epilogues. FIXME.
184
185 The fields in structure roughly correspond to the arguments available on the
186 .callinfo pseudo-op. */
187
188struct call_info
189 {
190 /* The unwind descriptor being built. */
191 struct unwind_table ci_unwind;
192
193 /* Name of this function. */
194 symbolS *start_symbol;
195
196 /* (temporary) symbol used to mark the end of this function. */
197 symbolS *end_symbol;
198
199 /* Next entry in the chain. */
200 struct call_info *ci_next;
201 };
202
203/* Operand formats for FP instructions. Note not all FP instructions
204 allow all four formats to be used (for example fmpysub only allows
205 SGL and DBL). */
206typedef enum
207 {
208 SGL, DBL, ILLEGAL_FMT, QUAD, W, UW, DW, UDW, QW, UQW
209 }
210fp_operand_format;
211
212/* This fully describes the symbol types which may be attached to
213 an EXPORT or IMPORT directive. Only SOM uses this formation
214 (ELF has no need for it). */
215typedef enum
216 {
217 SYMBOL_TYPE_UNKNOWN,
218 SYMBOL_TYPE_ABSOLUTE,
219 SYMBOL_TYPE_CODE,
220 SYMBOL_TYPE_DATA,
221 SYMBOL_TYPE_ENTRY,
222 SYMBOL_TYPE_MILLICODE,
223 SYMBOL_TYPE_PLABEL,
224 SYMBOL_TYPE_PRI_PROG,
225 SYMBOL_TYPE_SEC_PROG,
226 }
227pa_symbol_type;
228
229/* This structure contains information needed to assemble
230 individual instructions. */
231struct pa_it
232 {
233 /* Holds the opcode after parsing by pa_ip. */
234 unsigned long opcode;
235
236 /* Holds an expression associated with the current instruction. */
237 expressionS exp;
238
239 /* Does this instruction use PC-relative addressing. */
240 int pcrel;
241
242 /* Floating point formats for operand1 and operand2. */
243 fp_operand_format fpof1;
244 fp_operand_format fpof2;
245
1cf6ae67
JL		 246 /* Whether or not we saw a truncation request on an fcnv insn. */
247 int trunc;
252b5132
RH		 248
249 /* Holds the field selector for this instruction
250 (for example L%, LR%, etc). */
251 long field_selector;
252
253 /* Holds any argument relocation bits associated with this
254 instruction. (instruction should be some sort of call). */
ad1079af 255 unsigned int arg_reloc;
252b5132
RH		 256
257 /* The format specification for this instruction. */
258 int format;
259
260 /* The relocation (if any) associated with this instruction. */
261 reloc_type reloc;
262 };
263
264/* PA-89 floating point registers are arranged like this:
265
252b5132
RH		 266 +--------------+--------------+
267 | 0 or 16L | 16 or 16R |
268 +--------------+--------------+
269 | 1 or 17L | 17 or 17R |
270 +--------------+--------------+
271 | | |
272
273 . . .
274 . . .
275 . . .
276
277 | | |
278 +--------------+--------------+
279 | 14 or 30L | 30 or 30R |
280 +--------------+--------------+
281 | 15 or 31L | 31 or 31R |
ecacdc7a 282 +--------------+--------------+ */
252b5132
RH		 283
284/* Additional information needed to build argument relocation stubs. */
285struct call_desc
286 {
287 /* The argument relocation specification. */
288 unsigned int arg_reloc;
289
290 /* Number of arguments. */
291 unsigned int arg_count;
292 };
293
49863f82 294#ifdef OBJ_SOM
252b5132
RH		 295/* This structure defines an entry in the subspace dictionary
296 chain. */
297
298struct subspace_dictionary_chain
299 {
300 /* Nonzero if this space has been defined by the user code. */
301 unsigned int ssd_defined;
302
303 /* Name of this subspace. */
304 char *ssd_name;
305
306 /* GAS segment and subsegment associated with this subspace. */
307 asection *ssd_seg;
308 int ssd_subseg;
309
310 /* Next space in the subspace dictionary chain. */
311 struct subspace_dictionary_chain *ssd_next;
312 };
313
314typedef struct subspace_dictionary_chain ssd_chain_struct;
315
316/* This structure defines an entry in the subspace dictionary
317 chain. */
318
319struct space_dictionary_chain
320 {
321 /* Nonzero if this space has been defined by the user code or
322 as a default space. */
323 unsigned int sd_defined;
324
325 /* Nonzero if this spaces has been defined by the user code. */
326 unsigned int sd_user_defined;
327
328 /* The space number (or index). */
329 unsigned int sd_spnum;
330
331 /* The name of this subspace. */
332 char *sd_name;
333
334 /* GAS segment to which this subspace corresponds. */
335 asection *sd_seg;
336
337 /* Current subsegment number being used. */
338 int sd_last_subseg;
339
340 /* The chain of subspaces contained within this space. */
341 ssd_chain_struct *sd_subspaces;
342
343 /* The next entry in the space dictionary chain. */
344 struct space_dictionary_chain *sd_next;
345 };
346
347typedef struct space_dictionary_chain sd_chain_struct;
348
252b5132
RH		 349/* This structure defines attributes of the default subspace
350 dictionary entries. */
351
352struct default_subspace_dict
353 {
354 /* Name of the subspace. */
355 char *name;
356
357 /* FIXME. Is this still needed? */
358 char defined;
359
360 /* Nonzero if this subspace is loadable. */
361 char loadable;
362
363 /* Nonzero if this subspace contains only code. */
364 char code_only;
365
351e2b5a
DA		 366 /* Nonzero if this is a comdat subspace. */
367 char comdat;
368
252b5132
RH		 369 /* Nonzero if this is a common subspace. */
370 char common;
371
372 /* Nonzero if this is a common subspace which allows symbols
373 to be multiply defined. */
374 char dup_common;
375
376 /* Nonzero if this subspace should be zero filled. */
377 char zero;
378
379 /* Sort key for this subspace. */
380 unsigned char sort;
381
382 /* Access control bits for this subspace. Can represent RWX access
383 as well as privilege level changes for gateways. */
384 int access;
385
386 /* Index of containing space. */
387 int space_index;
388
389 /* Alignment (in bytes) of this subspace. */
390 int alignment;
391
392 /* Quadrant within space where this subspace should be loaded. */
393 int quadrant;
394
395 /* An index into the default spaces array. */
396 int def_space_index;
397
252b5132
RH		 398 /* Subsegment associated with this subspace. */
399 subsegT subsegment;
400 };
401
402/* This structure defines attributes of the default space
403 dictionary entries. */
404
405struct default_space_dict
406 {
407 /* Name of the space. */
408 char *name;
409
410 /* Space number. It is possible to identify spaces within
411 assembly code numerically! */
412 int spnum;
413
414 /* Nonzero if this space is loadable. */
415 char loadable;
416
417 /* Nonzero if this space is "defined". FIXME is still needed */
418 char defined;
419
420 /* Nonzero if this space can not be shared. */
421 char private;
422
423 /* Sort key for this space. */
424 unsigned char sort;
425
426 /* Segment associated with this space. */
427 asection *segment;
252b5132 428 };
49863f82
JL		 429#endif
430
431/* Structure for previous label tracking. Needed so that alignments,
432 callinfo declarations, etc can be easily attached to a particular
433 label. */
434typedef struct label_symbol_struct
435 {
436 struct symbol *lss_label;
437#ifdef OBJ_SOM
438 sd_chain_struct *lss_space;
439#endif
440#ifdef OBJ_ELF
441 segT lss_segment;
442#endif
443 struct label_symbol_struct *lss_next;
444 }
445label_symbol_struct;
252b5132
RH		 446
447/* Extra information needed to perform fixups (relocations) on the PA. */
448struct hppa_fix_struct
449 {
450 /* The field selector. */
451 enum hppa_reloc_field_selector_type_alt fx_r_field;
452
453 /* Type of fixup. */
454 int fx_r_type;
455
456 /* Format of fixup. */
457 int fx_r_format;
458
459 /* Argument relocation bits. */
ad1079af 460 unsigned int fx_arg_reloc;
252b5132
RH		 461
462 /* The segment this fixup appears in. */
463 segT segment;
464 };
465
466/* Structure to hold information about predefined registers. */
467
468struct pd_reg
469 {
470 char *name;
471 int value;
472 };
473
474/* This structure defines the mapping from a FP condition string
475 to a condition number which can be recorded in an instruction. */
476struct fp_cond_map
477 {
478 char *string;
479 int cond;
480 };
481
482/* This structure defines a mapping from a field selector
483 string to a field selector type. */
484struct selector_entry
485 {
486 char *prefix;
487 int field_selector;
488 };
489
490/* Prototypes for functions local to tc-hppa.c. */
491
49863f82 492#ifdef OBJ_SOM
252b5132 493static void pa_check_current_space_and_subspace PARAMS ((void));
49863f82
JL		 494#endif
495
85cf2a8a 496#if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
ad1079af
AM		 497static void pa_text PARAMS ((int));
498static void pa_data PARAMS ((int));
499static void pa_comm PARAMS ((int));
500#endif
252b5132
RH		 501static fp_operand_format pa_parse_fp_format PARAMS ((char **s));
502static void pa_cons PARAMS ((int));
252b5132
RH		 503static void pa_float_cons PARAMS ((int));
504static void pa_fill PARAMS ((int));
505static void pa_lcomm PARAMS ((int));
506static void pa_lsym PARAMS ((int));
507static void pa_stringer PARAMS ((int));
252b5132
RH		 508static void pa_version PARAMS ((int));
509static int pa_parse_fp_cmp_cond PARAMS ((char **));
510static int get_expression PARAMS ((char *));
511static int pa_get_absolute_expression PARAMS ((struct pa_it *, char **));
512static int evaluate_absolute PARAMS ((struct pa_it *));
513static unsigned int pa_build_arg_reloc PARAMS ((char *));
514static unsigned int pa_align_arg_reloc PARAMS ((unsigned int, unsigned int));
515static int pa_parse_nullif PARAMS ((char **));
677537c1
AM		 516static int pa_parse_nonneg_cmpsub_cmpltr PARAMS ((char **));
517static int pa_parse_neg_cmpsub_cmpltr PARAMS ((char **));
518static int pa_parse_neg_add_cmpltr PARAMS ((char **));
519static int pa_parse_nonneg_add_cmpltr PARAMS ((char **));
d53d2751
JL		 520static int pa_parse_cmpb_64_cmpltr PARAMS ((char **));
521static int pa_parse_cmpib_64_cmpltr PARAMS ((char **));
522static int pa_parse_addb_64_cmpltr PARAMS ((char **));
252b5132
RH		 523static void pa_block PARAMS ((int));
524static void pa_brtab PARAMS ((int));
525static void pa_try PARAMS ((int));
526static void pa_call PARAMS ((int));
527static void pa_call_args PARAMS ((struct call_desc *));
528static void pa_callinfo PARAMS ((int));
252b5132
RH		 529static void pa_copyright PARAMS ((int));
530static void pa_end PARAMS ((int));
531static void pa_enter PARAMS ((int));
532static void pa_entry PARAMS ((int));
533static void pa_equ PARAMS ((int));
534static void pa_exit PARAMS ((int));
535static void pa_export PARAMS ((int));
536static void pa_type_args PARAMS ((symbolS *, int));
537static void pa_import PARAMS ((int));
538static void pa_label PARAMS ((int));
539static void pa_leave PARAMS ((int));
540static void pa_level PARAMS ((int));
541static void pa_origin PARAMS ((int));
542static void pa_proc PARAMS ((int));
543static void pa_procend PARAMS ((int));
252b5132
RH		 544static void pa_param PARAMS ((int));
545static void pa_undefine_label PARAMS ((void));
ecacdc7a
AM		 546static int need_pa11_opcode PARAMS ((void));
547static int pa_parse_number PARAMS ((char **, int));
252b5132 548static label_symbol_struct *pa_get_label PARAMS ((void));
49863f82 549#ifdef OBJ_SOM
b8fc22bc 550static int exact_log2 PARAMS ((int));
49863f82
JL		 551static void pa_compiler PARAMS ((int));
552static void pa_align PARAMS ((int));
553static void pa_space PARAMS ((int));
554static void pa_spnum PARAMS ((int));
555static void pa_subspace PARAMS ((int));
252b5132
RH		 556static sd_chain_struct *create_new_space PARAMS ((char *, int, int,
557 int, int, int,
558 asection *, int));
559static ssd_chain_struct *create_new_subspace PARAMS ((sd_chain_struct *,
560 char *, int, int,
351e2b5a 561 int, int, int, int,
252b5132
RH		 562 int, int, int, int,
563 int, asection *));
564static ssd_chain_struct *update_subspace PARAMS ((sd_chain_struct *,
565 char *, int, int, int,
566 int, int, int, int,
351e2b5a 567 int, int, int, int,
252b5132
RH		 568 asection *));
569static sd_chain_struct *is_defined_space PARAMS ((char *));
570static ssd_chain_struct *is_defined_subspace PARAMS ((char *));
571static sd_chain_struct *pa_segment_to_space PARAMS ((asection *));
572static ssd_chain_struct *pa_subsegment_to_subspace PARAMS ((asection *,
573 subsegT));
574static sd_chain_struct *pa_find_space_by_number PARAMS ((int));
575static unsigned int pa_subspace_start PARAMS ((sd_chain_struct *, int));
49863f82 576static sd_chain_struct *pa_parse_space_stmt PARAMS ((char *, int));
49863f82
JL		 577static void pa_spaces_begin PARAMS ((void));
578#endif
252b5132
RH		 579static void pa_ip PARAMS ((char *));
580static void fix_new_hppa PARAMS ((fragS *, int, int, symbolS *,
ad1079af 581 offsetT, expressionS *, int,
252b5132
RH		 582 bfd_reloc_code_real_type,
583 enum hppa_reloc_field_selector_type_alt,
da6c73e0 584 int, unsigned int, int));
252b5132
RH		 585static int is_end_of_statement PARAMS ((void));
586static int reg_name_search PARAMS ((char *));
587static int pa_chk_field_selector PARAMS ((char **));
588static int is_same_frag PARAMS ((fragS *, fragS *));
589static void process_exit PARAMS ((void));
252b5132 590static unsigned int pa_stringer_aux PARAMS ((char *));
1cf6ae67
JL		 591static fp_operand_format pa_parse_fp_cnv_format PARAMS ((char **s));
592static int pa_parse_ftest_gfx_completer PARAMS ((char **));
252b5132
RH		 593
594#ifdef OBJ_ELF
595static void hppa_elf_mark_end_of_function PARAMS ((void));
596static void pa_build_unwind_subspace PARAMS ((struct call_info *));
904a31bf
AM		 597static void pa_vtable_entry PARAMS ((int));
598static void pa_vtable_inherit PARAMS ((int));
252b5132
RH		 599#endif
600
67c1ffbe 601/* File and globally scoped variable declarations. */
252b5132 602
49863f82 603#ifdef OBJ_SOM
252b5132
RH		 604/* Root and final entry in the space chain. */
605static sd_chain_struct *space_dict_root;
606static sd_chain_struct *space_dict_last;
607
608/* The current space and subspace. */
609static sd_chain_struct *current_space;
610static ssd_chain_struct *current_subspace;
49863f82 611#endif
252b5132
RH		 612
613/* Root of the call_info chain. */
614static struct call_info *call_info_root;
615
616/* The last call_info (for functions) structure
617 seen so it can be associated with fixups and
618 function labels. */
619static struct call_info *last_call_info;
620
621/* The last call description (for actual calls). */
622static struct call_desc last_call_desc;
623
624/* handle of the OPCODE hash table */
625static struct hash_control *op_hash = NULL;
626
85c77c38
DA		 627/* These characters can be suffixes of opcode names and they may be
628 followed by meaningful whitespace. We don't include `,' and `!'
629 as they never appear followed by meaningful whitespace. */
630const char hppa_symbol_chars[] = "*?=<>";
f0d7d5f9 631
252b5132
RH		 632/* Table of pseudo ops for the PA. FIXME -- how many of these
633 are now redundant with the overall GAS and the object file
634 dependent tables? */
635const pseudo_typeS md_pseudo_table[] =
636{
637 /* align pseudo-ops on the PA specify the actual alignment requested,
638 not the log2 of the requested alignment. */
49863f82 639#ifdef OBJ_SOM
252b5132 640 {"align", pa_align, 8},
49863f82
JL		 641#endif
642#ifdef OBJ_ELF
643 {"align", s_align_bytes, 8},
644#endif
252b5132
RH		 645 {"begin_brtab", pa_brtab, 1},
646 {"begin_try", pa_try, 1},
647 {"block", pa_block, 1},
648 {"blockz", pa_block, 0},
649 {"byte", pa_cons, 1},
650 {"call", pa_call, 0},
651 {"callinfo", pa_callinfo, 0},
85cf2a8a 652#if defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))
ad1079af
AM		 653 {"code", obj_elf_text, 0},
654#else
655 {"code", pa_text, 0},
252b5132 656 {"comm", pa_comm, 0},
ad1079af 657#endif
252b5132
RH		 658#ifdef OBJ_SOM
659 {"compiler", pa_compiler, 0},
660#endif
661 {"copyright", pa_copyright, 0},
85cf2a8a 662#if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
252b5132 663 {"data", pa_data, 0},
ad1079af 664#endif
252b5132 665 {"double", pa_float_cons, 'd'},
077db52a 666 {"dword", pa_cons, 8},
252b5132
RH		 667 {"end", pa_end, 0},
668 {"end_brtab", pa_brtab, 0},
85cf2a8a 669#if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
252b5132 670 {"end_try", pa_try, 0},
ad1079af 671#endif
252b5132
RH		 672 {"enter", pa_enter, 0},
673 {"entry", pa_entry, 0},
674 {"equ", pa_equ, 0},
675 {"exit", pa_exit, 0},
676 {"export", pa_export, 0},
677 {"fill", pa_fill, 0},
678 {"float", pa_float_cons, 'f'},
679 {"half", pa_cons, 2},
680 {"import", pa_import, 0},
681 {"int", pa_cons, 4},
682 {"label", pa_label, 0},
683 {"lcomm", pa_lcomm, 0},
684 {"leave", pa_leave, 0},
685 {"level", pa_level, 0},
686 {"long", pa_cons, 4},
687 {"lsym", pa_lsym, 0},
49863f82 688#ifdef OBJ_SOM
252b5132 689 {"nsubspa", pa_subspace, 1},
49863f82 690#endif
252b5132
RH		 691 {"octa", pa_cons, 16},
692 {"org", pa_origin, 0},
693 {"origin", pa_origin, 0},
694 {"param", pa_param, 0},
695 {"proc", pa_proc, 0},
696 {"procend", pa_procend, 0},
697 {"quad", pa_cons, 8},
698 {"reg", pa_equ, 1},
699 {"short", pa_cons, 2},
700 {"single", pa_float_cons, 'f'},
49863f82 701#ifdef OBJ_SOM
252b5132
RH		 702 {"space", pa_space, 0},
703 {"spnum", pa_spnum, 0},
49863f82 704#endif
252b5132
RH		 705 {"string", pa_stringer, 0},
706 {"stringz", pa_stringer, 1},
49863f82 707#ifdef OBJ_SOM
252b5132 708 {"subspa", pa_subspace, 0},
49863f82 709#endif
85cf2a8a 710#if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
252b5132 711 {"text", pa_text, 0},
ad1079af 712#endif
252b5132 713 {"version", pa_version, 0},
904a31bf
AM		 714#ifdef OBJ_ELF
715 {"vtable_entry", pa_vtable_entry, 0},
716 {"vtable_inherit", pa_vtable_inherit, 0},
717#endif
252b5132
RH		 718 {"word", pa_cons, 4},
719 {NULL, 0, 0}
720};
721
722/* This array holds the chars that only start a comment at the beginning of
723 a line. If the line seems to have the form '# 123 filename'
724 .line and .file directives will appear in the pre-processed output.
725
726 Note that input_file.c hand checks for '#' at the beginning of the
727 first line of the input file. This is because the compiler outputs
728 #NO_APP at the beginning of its output.
729
a28a3ccf 730 Also note that C style comments will always work. */
252b5132
RH		 731const char line_comment_chars[] = "#";
732
ad1079af
AM		 733/* This array holds the chars that always start a comment. If the
734 pre-processor is disabled, these aren't very useful. */
735const char comment_chars[] = ";";
736
252b5132
RH		 737/* This array holds the characters which act as line separators. */
738const char line_separator_chars[] = "!";
739
740/* Chars that can be used to separate mant from exp in floating point nums. */
741const char EXP_CHARS[] = "eE";
742
743/* Chars that mean this number is a floating point constant.
744 As in 0f12.456 or 0d1.2345e12.
745
746 Be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
747 changed in read.c. Ideally it shouldn't hae to know abou it at
748 all, but nothing is ideal around here. */
749const char FLT_CHARS[] = "rRsSfFdDxXpP";
750
751static struct pa_it the_insn;
752
0234cb7c 753/* Points to the end of an expression just parsed by get_expression
252b5132
RH		 754 and friends. FIXME. This shouldn't be handled with a file-global
755 variable. */
756static char *expr_end;
757
758/* Nonzero if a .callinfo appeared within the current procedure. */
759static int callinfo_found;
760
761/* Nonzero if the assembler is currently within a .entry/.exit pair. */
762static int within_entry_exit;
763
764/* Nonzero if the assembler is currently within a procedure definition. */
765static int within_procedure;
766
ad1079af 767/* Handle on structure which keep track of the last symbol
252b5132
RH		 768 seen in each subspace. */
769static label_symbol_struct *label_symbols_rootp = NULL;
770
771/* Holds the last field selector. */
772static int hppa_field_selector;
773
0f4f8b56
JL		 774/* Nonzero when strict syntax checking is enabled. Zero otherwise.
775
776 Each opcode in the table has a flag which indicates whether or not
777 strict syntax checking should be enabled for that instruction. */
778static int strict = 0;
779
ecacdc7a
AM		 780/* pa_parse_number returns values in `pa_number'. Mostly
781 pa_parse_number is used to return a register number, with floating
782 point registers being numbered from FP_REG_BASE upwards.
783 The bit specified with FP_REG_RSEL is set if the floating point
784 register has a `r' suffix. */
785#define FP_REG_BASE 64
786#define FP_REG_RSEL 128
787static int pa_number;
788
993142d5 789#ifdef OBJ_SOM
252b5132
RH		 790/* A dummy bfd symbol so that all relocations have symbols of some kind. */
791static symbolS *dummy_symbol;
993142d5 792#endif
252b5132
RH		 793
794/* Nonzero if errors are to be printed. */
795static int print_errors = 1;
796
797/* List of registers that are pre-defined:
798
799 Each general register has one predefined name of the form
800 %r<REGNUM> which has the value <REGNUM>.
801
802 Space and control registers are handled in a similar manner,
803 but use %sr<REGNUM> and %cr<REGNUM> as their predefined names.
804
805 Likewise for the floating point registers, but of the form
806 %fr<REGNUM>. Floating point registers have additional predefined
807 names with 'L' and 'R' suffixes (e.g. %fr19L, %fr19R) which
808 again have the value <REGNUM>.
809
810 Many registers also have synonyms:
811
812 %r26 - %r23 have %arg0 - %arg3 as synonyms
813 %r28 - %r29 have %ret0 - %ret1 as synonyms
f394e3dd 814 %fr4 - %fr7 have %farg0 - %farg3 as synonyms
252b5132
RH		 815 %r30 has %sp as a synonym
816 %r27 has %dp as a synonym
817 %r2 has %rp as a synonym
818
819 Almost every control register has a synonym; they are not listed
820 here for brevity.
821
a28a3ccf 822 The table is sorted. Suitable for searching by a binary search. */
252b5132
RH		 823
824static const struct pd_reg pre_defined_registers[] =
825{
ecacdc7a
AM		 826 {"%arg0", 26},
827 {"%arg1", 25},
828 {"%arg2", 24},
829 {"%arg3", 23},
830 {"%cr0", 0},
831 {"%cr10", 10},
832 {"%cr11", 11},
833 {"%cr12", 12},
834 {"%cr13", 13},
835 {"%cr14", 14},
836 {"%cr15", 15},
837 {"%cr16", 16},
838 {"%cr17", 17},
839 {"%cr18", 18},
840 {"%cr19", 19},
841 {"%cr20", 20},
842 {"%cr21", 21},
843 {"%cr22", 22},
844 {"%cr23", 23},
845 {"%cr24", 24},
846 {"%cr25", 25},
847 {"%cr26", 26},
848 {"%cr27", 27},
849 {"%cr28", 28},
850 {"%cr29", 29},
851 {"%cr30", 30},
852 {"%cr31", 31},
853 {"%cr8", 8},
854 {"%cr9", 9},
855 {"%dp", 27},
856 {"%eiem", 15},
857 {"%eirr", 23},
f394e3dd
NC		 858 {"%farg0", 4 + FP_REG_BASE},
859 {"%farg1", 5 + FP_REG_BASE},
860 {"%farg2", 6 + FP_REG_BASE},
861 {"%farg3", 7 + FP_REG_BASE},
ecacdc7a
AM		 862 {"%fr0", 0 + FP_REG_BASE},
863 {"%fr0l", 0 + FP_REG_BASE},
864 {"%fr0r", 0 + FP_REG_BASE + FP_REG_RSEL},
865 {"%fr1", 1 + FP_REG_BASE},
866 {"%fr10", 10 + FP_REG_BASE},
867 {"%fr10l", 10 + FP_REG_BASE},
868 {"%fr10r", 10 + FP_REG_BASE + FP_REG_RSEL},
869 {"%fr11", 11 + FP_REG_BASE},
870 {"%fr11l", 11 + FP_REG_BASE},
871 {"%fr11r", 11 + FP_REG_BASE + FP_REG_RSEL},
872 {"%fr12", 12 + FP_REG_BASE},
873 {"%fr12l", 12 + FP_REG_BASE},
874 {"%fr12r", 12 + FP_REG_BASE + FP_REG_RSEL},
875 {"%fr13", 13 + FP_REG_BASE},
876 {"%fr13l", 13 + FP_REG_BASE},
877 {"%fr13r", 13 + FP_REG_BASE + FP_REG_RSEL},
878 {"%fr14", 14 + FP_REG_BASE},
879 {"%fr14l", 14 + FP_REG_BASE},
880 {"%fr14r", 14 + FP_REG_BASE + FP_REG_RSEL},
881 {"%fr15", 15 + FP_REG_BASE},
882 {"%fr15l", 15 + FP_REG_BASE},
883 {"%fr15r", 15 + FP_REG_BASE + FP_REG_RSEL},
884 {"%fr16", 16 + FP_REG_BASE},
885 {"%fr16l", 16 + FP_REG_BASE},
886 {"%fr16r", 16 + FP_REG_BASE + FP_REG_RSEL},
887 {"%fr17", 17 + FP_REG_BASE},
888 {"%fr17l", 17 + FP_REG_BASE},
889 {"%fr17r", 17 + FP_REG_BASE + FP_REG_RSEL},
890 {"%fr18", 18 + FP_REG_BASE},
891 {"%fr18l", 18 + FP_REG_BASE},
892 {"%fr18r", 18 + FP_REG_BASE + FP_REG_RSEL},
893 {"%fr19", 19 + FP_REG_BASE},
894 {"%fr19l", 19 + FP_REG_BASE},
895 {"%fr19r", 19 + FP_REG_BASE + FP_REG_RSEL},
896 {"%fr1l", 1 + FP_REG_BASE},
897 {"%fr1r", 1 + FP_REG_BASE + FP_REG_RSEL},
898 {"%fr2", 2 + FP_REG_BASE},
899 {"%fr20", 20 + FP_REG_BASE},
900 {"%fr20l", 20 + FP_REG_BASE},
901 {"%fr20r", 20 + FP_REG_BASE + FP_REG_RSEL},
902 {"%fr21", 21 + FP_REG_BASE},
903 {"%fr21l", 21 + FP_REG_BASE},
904 {"%fr21r", 21 + FP_REG_BASE + FP_REG_RSEL},
905 {"%fr22", 22 + FP_REG_BASE},
906 {"%fr22l", 22 + FP_REG_BASE},
907 {"%fr22r", 22 + FP_REG_BASE + FP_REG_RSEL},
908 {"%fr23", 23 + FP_REG_BASE},
909 {"%fr23l", 23 + FP_REG_BASE},
910 {"%fr23r", 23 + FP_REG_BASE + FP_REG_RSEL},
911 {"%fr24", 24 + FP_REG_BASE},
912 {"%fr24l", 24 + FP_REG_BASE},
913 {"%fr24r", 24 + FP_REG_BASE + FP_REG_RSEL},
914 {"%fr25", 25 + FP_REG_BASE},
915 {"%fr25l", 25 + FP_REG_BASE},
916 {"%fr25r", 25 + FP_REG_BASE + FP_REG_RSEL},
917 {"%fr26", 26 + FP_REG_BASE},
918 {"%fr26l", 26 + FP_REG_BASE},
919 {"%fr26r", 26 + FP_REG_BASE + FP_REG_RSEL},
920 {"%fr27", 27 + FP_REG_BASE},
921 {"%fr27l", 27 + FP_REG_BASE},
922 {"%fr27r", 27 + FP_REG_BASE + FP_REG_RSEL},
923 {"%fr28", 28 + FP_REG_BASE},
924 {"%fr28l", 28 + FP_REG_BASE},
925 {"%fr28r", 28 + FP_REG_BASE + FP_REG_RSEL},
926 {"%fr29", 29 + FP_REG_BASE},
927 {"%fr29l", 29 + FP_REG_BASE},
928 {"%fr29r", 29 + FP_REG_BASE + FP_REG_RSEL},
929 {"%fr2l", 2 + FP_REG_BASE},
930 {"%fr2r", 2 + FP_REG_BASE + FP_REG_RSEL},
931 {"%fr3", 3 + FP_REG_BASE},
932 {"%fr30", 30 + FP_REG_BASE},
933 {"%fr30l", 30 + FP_REG_BASE},
934 {"%fr30r", 30 + FP_REG_BASE + FP_REG_RSEL},
935 {"%fr31", 31 + FP_REG_BASE},
936 {"%fr31l", 31 + FP_REG_BASE},
937 {"%fr31r", 31 + FP_REG_BASE + FP_REG_RSEL},
938 {"%fr3l", 3 + FP_REG_BASE},
939 {"%fr3r", 3 + FP_REG_BASE + FP_REG_RSEL},
940 {"%fr4", 4 + FP_REG_BASE},
941 {"%fr4l", 4 + FP_REG_BASE},
942 {"%fr4r", 4 + FP_REG_BASE + FP_REG_RSEL},
943 {"%fr5", 5 + FP_REG_BASE},
944 {"%fr5l", 5 + FP_REG_BASE},
945 {"%fr5r", 5 + FP_REG_BASE + FP_REG_RSEL},
946 {"%fr6", 6 + FP_REG_BASE},
947 {"%fr6l", 6 + FP_REG_BASE},
948 {"%fr6r", 6 + FP_REG_BASE + FP_REG_RSEL},
949 {"%fr7", 7 + FP_REG_BASE},
950 {"%fr7l", 7 + FP_REG_BASE},
951 {"%fr7r", 7 + FP_REG_BASE + FP_REG_RSEL},
952 {"%fr8", 8 + FP_REG_BASE},
953 {"%fr8l", 8 + FP_REG_BASE},
954 {"%fr8r", 8 + FP_REG_BASE + FP_REG_RSEL},
955 {"%fr9", 9 + FP_REG_BASE},
956 {"%fr9l", 9 + FP_REG_BASE},
957 {"%fr9r", 9 + FP_REG_BASE + FP_REG_RSEL},
85cf2a8a 958 {"%fret", 4},
ecacdc7a
AM		 959 {"%hta", 25},
960 {"%iir", 19},
961 {"%ior", 21},
962 {"%ipsw", 22},
963 {"%isr", 20},
964 {"%itmr", 16},
965 {"%iva", 14},
8be31359
NC		 966#if TARGET_ARCH_SIZE == 64
967 {"%mrp", 2},
968#else
969 {"%mrp", 31},
970#endif
ecacdc7a
AM		 971 {"%pcoq", 18},
972 {"%pcsq", 17},
973 {"%pidr1", 8},
974 {"%pidr2", 9},
252b5132
RH		 975 {"%pidr3", 12},
976 {"%pidr4", 13},
ecacdc7a
AM		 977 {"%ppda", 24},
978 {"%r0", 0},
979 {"%r1", 1},
980 {"%r10", 10},
981 {"%r11", 11},
982 {"%r12", 12},
983 {"%r13", 13},
984 {"%r14", 14},
985 {"%r15", 15},
986 {"%r16", 16},
987 {"%r17", 17},
988 {"%r18", 18},
989 {"%r19", 19},
990 {"%r2", 2},
991 {"%r20", 20},
992 {"%r21", 21},
993 {"%r22", 22},
994 {"%r23", 23},
995 {"%r24", 24},
996 {"%r25", 25},
997 {"%r26", 26},
998 {"%r27", 27},
999 {"%r28", 28},
1000 {"%r29", 29},
1001 {"%r3", 3},
1002 {"%r30", 30},
1003 {"%r31", 31},
1004 {"%r4", 4},
1005 {"%r5", 5},
1006 {"%r6", 6},
1007 {"%r7", 7},
1008 {"%r8", 8},
1009 {"%r9", 9},
1010 {"%rctr", 0},
1011 {"%ret0", 28},
1012 {"%ret1", 29},
1013 {"%rp", 2},
1014 {"%sar", 11},
1015 {"%sp", 30},
1016 {"%sr0", 0},
1017 {"%sr1", 1},
1018 {"%sr2", 2},
1019 {"%sr3", 3},
1020 {"%sr4", 4},
1021 {"%sr5", 5},
1022 {"%sr6", 6},
1023 {"%sr7", 7},
85cf2a8a
NC		 1024 {"%t1", 22},
1025 {"%t2", 21},
1026 {"%t3", 20},
1027 {"%t4", 19},
1028 {"%tf1", 11},
1029 {"%tf2", 10},
1030 {"%tf3", 9},
1031 {"%tf4", 8},
ecacdc7a
AM		 1032 {"%tr0", 24},
1033 {"%tr1", 25},
1034 {"%tr2", 26},
1035 {"%tr3", 27},
1036 {"%tr4", 28},
1037 {"%tr5", 29},
1038 {"%tr6", 30},
1039 {"%tr7", 31}
252b5132
RH		 1040};
1041
1042/* This table is sorted by order of the length of the string. This is
1043 so we check for <> before we check for <. If we had a <> and checked
1044 for < first, we would get a false match. */
1045static const struct fp_cond_map fp_cond_map[] =
1046{
1047 {"false?", 0},
1048 {"false", 1},
1049 {"true?", 30},
1050 {"true", 31},
1051 {"!<=>", 3},
1052 {"!?>=", 8},
1053 {"!?<=", 16},
1054 {"!<>", 7},
1055 {"!>=", 11},
1056 {"!?>", 12},
1057 {"?<=", 14},
1058 {"!<=", 19},
1059 {"!?<", 20},
1060 {"?>=", 22},
1061 {"!?=", 24},
1062 {"!=t", 27},
1063 {"<=>", 29},
1064 {"=t", 5},
1065 {"?=", 6},
1066 {"?<", 10},
1067 {"<=", 13},
1068 {"!>", 15},
1069 {"?>", 18},
1070 {">=", 21},
1071 {"!<", 23},
1072 {"<>", 25},
1073 {"!=", 26},
1074 {"!?", 28},
1075 {"?", 2},
1076 {"=", 4},
1077 {"<", 9},
1078 {">", 17}
1079};
1080
1081static const struct selector_entry selector_table[] =
1082{
1083 {"f", e_fsel},
1084 {"l", e_lsel},
1085 {"ld", e_ldsel},
1086 {"lp", e_lpsel},
1087 {"lr", e_lrsel},
1088 {"ls", e_lssel},
1089 {"lt", e_ltsel},
39ba5561 1090 {"ltp", e_ltpsel},
252b5132
RH		 1091 {"n", e_nsel},
1092 {"nl", e_nlsel},
1093 {"nlr", e_nlrsel},
1094 {"p", e_psel},
1095 {"r", e_rsel},
1096 {"rd", e_rdsel},
1097 {"rp", e_rpsel},
1098 {"rr", e_rrsel},
1099 {"rs", e_rssel},
1100 {"rt", e_rtsel},
39ba5561 1101 {"rtp", e_rtpsel},
252b5132
RH		 1102 {"t", e_tsel},
1103};
1104
49863f82 1105#ifdef OBJ_SOM
252b5132
RH		 1106/* default space and subspace dictionaries */
1107
1108#define GDB_SYMBOLS GDB_SYMBOLS_SUBSPACE_NAME
1109#define GDB_STRINGS GDB_STRINGS_SUBSPACE_NAME
1110
1111/* pre-defined subsegments (subspaces) for the HPPA. */
1112#define SUBSEG_CODE 0
1113#define SUBSEG_LIT 1
1114#define SUBSEG_MILLI 2
1115#define SUBSEG_DATA 0
1116#define SUBSEG_BSS 2
1117#define SUBSEG_UNWIND 3
1118#define SUBSEG_GDB_STRINGS 0
1119#define SUBSEG_GDB_SYMBOLS 1
1120
1121static struct default_subspace_dict pa_def_subspaces[] =
1122{
351e2b5a
DA		 1123 {"$CODE$", 1, 1, 1, 0, 0, 0, 0, 24, 0x2c, 0, 8, 0, 0, SUBSEG_CODE},
1124 {"$DATA$", 1, 1, 0, 0, 0, 0, 0, 24, 0x1f, 1, 8, 1, 1, SUBSEG_DATA},
1125 {"$LIT$", 1, 1, 0, 0, 0, 0, 0, 16, 0x2c, 0, 8, 0, 0, SUBSEG_LIT},
1126 {"$MILLICODE$", 1, 1, 0, 0, 0, 0, 0, 8, 0x2c, 0, 8, 0, 0, SUBSEG_MILLI},
1127 {"$BSS$", 1, 1, 0, 0, 0, 0, 1, 80, 0x1f, 1, 8, 1, 1, SUBSEG_BSS},
1128 {NULL, 0, 1, 0, 0, 0, 0, 0, 255, 0x1f, 0, 4, 0, 0, 0}
252b5132
RH		 1129};
1130
1131static struct default_space_dict pa_def_spaces[] =
1132{
49863f82
JL		 1133 {"$TEXT$", 0, 1, 1, 0, 8, ASEC_NULL},
1134 {"$PRIVATE$", 1, 1, 1, 1, 16, ASEC_NULL},
1135 {NULL, 0, 0, 0, 0, 0, ASEC_NULL}
252b5132
RH		 1136};
1137
1138/* Misc local definitions used by the assembler. */
1139
252b5132
RH		 1140/* These macros are used to maintain spaces/subspaces. */
1141#define SPACE_DEFINED(space_chain) (space_chain)->sd_defined
1142#define SPACE_USER_DEFINED(space_chain) (space_chain)->sd_user_defined
1143#define SPACE_SPNUM(space_chain) (space_chain)->sd_spnum
1144#define SPACE_NAME(space_chain) (space_chain)->sd_name
1145
1146#define SUBSPACE_DEFINED(ss_chain) (ss_chain)->ssd_defined
1147#define SUBSPACE_NAME(ss_chain) (ss_chain)->ssd_name
49863f82
JL		 1148#endif
1149
1150/* Return nonzero if the string pointed to by S potentially represents
1151 a right or left half of a FP register */
1152#define IS_R_SELECT(S) (*(S) == 'R' || *(S) == 'r')
1153#define IS_L_SELECT(S) (*(S) == 'L' || *(S) == 'l')
252b5132
RH		 1154
1155/* Insert FIELD into OPCODE starting at bit START. Continue pa_ip
1156 main loop after insertion. */
1157
1158#define INSERT_FIELD_AND_CONTINUE(OPCODE, FIELD, START) \
1159 { \
1160 ((OPCODE) |= (FIELD) << (START)); \
1161 continue; \
1162 }
1163
0234cb7c 1164/* Simple range checking for FIELD against HIGH and LOW bounds.
252b5132
RH		 1165 IGNORE is used to suppress the error message. */
1166
1167#define CHECK_FIELD(FIELD, HIGH, LOW, IGNORE) \
1168 { \
1169 if ((FIELD) > (HIGH) || (FIELD) < (LOW)) \
1170 { \
1171 if (! IGNORE) \
1172 as_bad (_("Field out of range [%d..%d] (%d)."), (LOW), (HIGH), \
1173 (int) (FIELD));\
1174 break; \
1175 } \
1176 }
1177
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. */
b8fc22bc
DA		 5931 if (exact_log2 (bytes) != -1)
5932 record_alignment (current_subspace->ssd_seg, exact_log2 (bytes));
252b5132 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
ee192366
MM		 5954 if (temp_size > 0x3FFFFFFF)
5955 {
5956 as_bad (_("Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff"));
5957 temp_size = 0;
5958 }
5959
252b5132
RH		 5960 /* Always fill with zeros, that's what the HP assembler does. */
5961 temp_fill = 0;
5962
5963 p = frag_var (rs_fill, (int) temp_size, (int) temp_size,
5964 (relax_substateT) 0, (symbolS *) 0, (offsetT) 1, NULL);
5965 memset (p, 0, temp_size);
5966
5967 /* Convert 2 bytes at a time. */
5968
5969 for (i = 0; i < temp_size; i += 2)
5970 {
5971 md_number_to_chars (p + i,
5972 (valueT) temp_fill,
5973 (int) ((temp_size - i) > 2 ? 2 : (temp_size - i)));
5974 }
5975
5976 pa_undefine_label ();
5977 demand_empty_rest_of_line ();
5978}
5979
5980/* Handle a .begin_brtab and .end_brtab pseudo-op. */
5981
5982static void
5983pa_brtab (begin)
3f9b03b5 5984 int begin ATTRIBUTE_UNUSED;
252b5132
RH		 5985{
5986
5987#ifdef OBJ_SOM
0234cb7c 5988 /* The BRTAB relocations are only available in SOM (to denote
252b5132
RH		 5989 the beginning and end of branch tables). */
5990 char *where = frag_more (0);
5991
5992 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
5993 NULL, (offsetT) 0, NULL,
5994 0, begin ? R_HPPA_BEGIN_BRTAB : R_HPPA_END_BRTAB,
da6c73e0 5995 e_fsel, 0, 0, 0);
252b5132
RH		 5996#endif
5997
5998 demand_empty_rest_of_line ();
5999}
6000
6001/* Handle a .begin_try and .end_try pseudo-op. */
6002
6003static void
6004pa_try (begin)
3f9b03b5 6005 int begin ATTRIBUTE_UNUSED;
252b5132
RH		 6006{
6007#ifdef OBJ_SOM
6008 expressionS exp;
6009 char *where = frag_more (0);
6010
6011 if (! begin)
6012 expression (&exp);
6013
0234cb7c 6014 /* The TRY relocations are only available in SOM (to denote
252b5132
RH		 6015 the beginning and end of exception handling regions). */
6016
6017 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6018 NULL, (offsetT) 0, begin ? NULL : &exp,
6019 0, begin ? R_HPPA_BEGIN_TRY : R_HPPA_END_TRY,
da6c73e0 6020 e_fsel, 0, 0, 0);
252b5132
RH		 6021#endif
6022
6023 demand_empty_rest_of_line ();
6024}
6025
6026/* Handle a .CALL pseudo-op. This involves storing away information
6027 about where arguments are to be found so the linker can detect
6028 (and correct) argument location mismatches between caller and callee. */
6029
6030static void
6031pa_call (unused)
3f9b03b5 6032 int unused ATTRIBUTE_UNUSED;
252b5132 6033{
49863f82 6034#ifdef OBJ_SOM
252b5132
RH		 6035 /* We must have a valid space and subspace. */
6036 pa_check_current_space_and_subspace ();
49863f82 6037#endif
252b5132
RH		 6038
6039 pa_call_args (&last_call_desc);
6040 demand_empty_rest_of_line ();
6041}
6042
6043/* Do the dirty work of building a call descriptor which describes
6044 where the caller placed arguments to a function call. */
6045
6046static void
6047pa_call_args (call_desc)
6048 struct call_desc *call_desc;
6049{
6050 char *name, c, *p;
6051 unsigned int temp, arg_reloc;
6052
6053 while (!is_end_of_statement ())
6054 {
6055 name = input_line_pointer;
6056 c = get_symbol_end ();
6057 /* Process a source argument. */
6058 if ((strncasecmp (name, "argw", 4) == 0))
6059 {
6060 temp = atoi (name + 4);
6061 p = input_line_pointer;
6062 *p = c;
6063 input_line_pointer++;
6064 name = input_line_pointer;
6065 c = get_symbol_end ();
6066 arg_reloc = pa_build_arg_reloc (name);
6067 call_desc->arg_reloc |= pa_align_arg_reloc (temp, arg_reloc);
6068 }
6069 /* Process a return value. */
6070 else if ((strncasecmp (name, "rtnval", 6) == 0))
6071 {
6072 p = input_line_pointer;
6073 *p = c;
6074 input_line_pointer++;
6075 name = input_line_pointer;
6076 c = get_symbol_end ();
6077 arg_reloc = pa_build_arg_reloc (name);
6078 call_desc->arg_reloc |= (arg_reloc & 0x3);
6079 }
6080 else
6081 {
6082 as_bad (_("Invalid .CALL argument: %s"), name);
6083 }
6084 p = input_line_pointer;
6085 *p = c;
6086 if (!is_end_of_statement ())
6087 input_line_pointer++;
6088 }
6089}
6090
6091/* Return TRUE if FRAG1 and FRAG2 are the same. */
6092
6093static int
6094is_same_frag (frag1, frag2)
6095 fragS *frag1;
6096 fragS *frag2;
6097{
6098
6099 if (frag1 == NULL)
6100 return (FALSE);
6101 else if (frag2 == NULL)
6102 return (FALSE);
6103 else if (frag1 == frag2)
6104 return (TRUE);
6105 else if (frag2->fr_type == rs_fill && frag2->fr_fix == 0)
6106 return (is_same_frag (frag1, frag2->fr_next));
6107 else
6108 return (FALSE);
6109}
6110
6111#ifdef OBJ_ELF
6112/* Build an entry in the UNWIND subspace from the given function
6113 attributes in CALL_INFO. This is not needed for SOM as using
6114 R_ENTRY and R_EXIT relocations allow the linker to handle building
6115 of the unwind spaces. */
6116
6117static void
6118pa_build_unwind_subspace (call_info)
6119 struct call_info *call_info;
6120{
252b5132 6121 asection *seg, *save_seg;
3f9b03b5 6122 subsegT save_subseg;
da6c73e0 6123 unsigned int unwind;
3f9b03b5 6124 int reloc;
da6c73e0 6125 char *p;
252b5132 6126
1d3d5051
AM		 6127 if ((bfd_get_section_flags (stdoutput, now_seg)
6128 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
6129 != (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
7acbfc6b
JL		 6130 return;
6131
c46b7515 6132 reloc = R_PARISC_SEGREL32;
c97305a1
JL		 6133 save_seg = now_seg;
6134 save_subseg = now_subseg;
252b5132
RH		 6135 /* Get into the right seg/subseg. This may involve creating
6136 the seg the first time through. Make sure to have the
6137 old seg/subseg so that we can reset things when we are done. */
252b5132
RH		 6138 seg = bfd_get_section_by_name (stdoutput, UNWIND_SECTION_NAME);
6139 if (seg == ASEC_NULL)
6140 {
c97305a1 6141 seg = subseg_new (UNWIND_SECTION_NAME, 0);
252b5132
RH		 6142 bfd_set_section_flags (stdoutput, seg,
6143 SEC_READONLY | SEC_HAS_CONTENTS
b100be66
JL		 6144 | SEC_LOAD | SEC_RELOC | SEC_ALLOC | SEC_DATA);
6145 bfd_set_section_alignment (stdoutput, seg, 2);
252b5132
RH		 6146 }
6147
46031ca9 6148 subseg_set (seg, 0);
252b5132 6149
252b5132
RH		 6150 /* Get some space to hold relocation information for the unwind
6151 descriptor. */
da6c73e0 6152 p = frag_more (16);
252b5132
RH		 6153
6154 /* Relocation info. for start offset of the function. */
8ea46bbd 6155 md_number_to_chars (p, 0, 4);
252b5132
RH		 6156 fix_new_hppa (frag_now, p - frag_now->fr_literal, 4,
6157 call_info->start_symbol, (offsetT) 0,
46031ca9 6158 (expressionS *) NULL, 0, reloc,
da6c73e0 6159 e_fsel, 32, 0, 0);
252b5132
RH		 6160
6161 /* Relocation info. for end offset of the function.
6162
6163 Because we allow reductions of 32bit relocations for ELF, this will be
6164 reduced to section_sym + offset which avoids putting the temporary
6165 symbol into the symbol table. It (should) end up giving the same
6166 value as call_info->start_symbol + function size once the linker is
6167 finished with its work. */
8ea46bbd 6168 md_number_to_chars (p + 4, 0, 4);
da6c73e0 6169 fix_new_hppa (frag_now, p + 4 - frag_now->fr_literal, 4,
252b5132 6170 call_info->end_symbol, (offsetT) 0,
46031ca9 6171 (expressionS *) NULL, 0, reloc,
da6c73e0 6172 e_fsel, 32, 0, 0);
252b5132 6173
da6c73e0
AM		 6174 /* Dump the descriptor. */
6175 unwind = UNWIND_LOW32 (&call_info->ci_unwind.descriptor);
6176 md_number_to_chars (p + 8, unwind, 4);
6177
6178 unwind = UNWIND_HIGH32 (&call_info->ci_unwind.descriptor);
6179 md_number_to_chars (p + 12, unwind, 4);
252b5132
RH		 6180
6181 /* Return back to the original segment/subsegment. */
6182 subseg_set (save_seg, save_subseg);
6183}
6184#endif
6185
6186/* Process a .CALLINFO pseudo-op. This information is used later
6187 to build unwind descriptors and maybe one day to support
6188 .ENTER and .LEAVE. */
6189
6190static void
6191pa_callinfo (unused)
3f9b03b5 6192 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6193{
6194 char *name, c, *p;
6195 int temp;
6196
49863f82 6197#ifdef OBJ_SOM
252b5132
RH		 6198 /* We must have a valid space and subspace. */
6199 pa_check_current_space_and_subspace ();
49863f82 6200#endif
252b5132
RH		 6201
6202 /* .CALLINFO must appear within a procedure definition. */
6203 if (!within_procedure)
6204 as_bad (_(".callinfo is not within a procedure definition"));
6205
6206 /* Mark the fact that we found the .CALLINFO for the
6207 current procedure. */
6208 callinfo_found = TRUE;
6209
6210 /* Iterate over the .CALLINFO arguments. */
6211 while (!is_end_of_statement ())
6212 {
6213 name = input_line_pointer;
6214 c = get_symbol_end ();
6215 /* Frame size specification. */
6216 if ((strncasecmp (name, "frame", 5) == 0))
6217 {
6218 p = input_line_pointer;
6219 *p = c;
6220 input_line_pointer++;
6221 temp = get_absolute_expression ();
6222 if ((temp & 0x3) != 0)
6223 {
6224 as_bad (_("FRAME parameter must be a multiple of 8: %d\n"), temp);
6225 temp = 0;
6226 }
6227
6228 /* callinfo is in bytes and unwind_desc is in 8 byte units. */
6229 last_call_info->ci_unwind.descriptor.frame_size = temp / 8;
6230
6231 }
6232 /* Entry register (GR, GR and SR) specifications. */
6233 else if ((strncasecmp (name, "entry_gr", 8) == 0))
6234 {
6235 p = input_line_pointer;
6236 *p = c;
6237 input_line_pointer++;
6238 temp = get_absolute_expression ();
6239 /* The HP assembler accepts 19 as the high bound for ENTRY_GR
6240 even though %r19 is caller saved. I think this is a bug in
6241 the HP assembler, and we are not going to emulate it. */
6242 if (temp < 3 || temp > 18)
6243 as_bad (_("Value for ENTRY_GR must be in the range 3..18\n"));
6244 last_call_info->ci_unwind.descriptor.entry_gr = temp - 2;
6245 }
6246 else if ((strncasecmp (name, "entry_fr", 8) == 0))
6247 {
6248 p = input_line_pointer;
6249 *p = c;
6250 input_line_pointer++;
6251 temp = get_absolute_expression ();
6252 /* Similarly the HP assembler takes 31 as the high bound even
6253 though %fr21 is the last callee saved floating point register. */
6254 if (temp < 12 || temp > 21)
6255 as_bad (_("Value for ENTRY_FR must be in the range 12..21\n"));
6256 last_call_info->ci_unwind.descriptor.entry_fr = temp - 11;
6257 }
6258 else if ((strncasecmp (name, "entry_sr", 8) == 0))
6259 {
6260 p = input_line_pointer;
6261 *p = c;
6262 input_line_pointer++;
6263 temp = get_absolute_expression ();
6264 if (temp != 3)
6265 as_bad (_("Value for ENTRY_SR must be 3\n"));
6266 }
6267 /* Note whether or not this function performs any calls. */
6268 else if ((strncasecmp (name, "calls", 5) == 0) ||
6269 (strncasecmp (name, "caller", 6) == 0))
6270 {
6271 p = input_line_pointer;
6272 *p = c;
6273 }
6274 else if ((strncasecmp (name, "no_calls", 8) == 0))
6275 {
6276 p = input_line_pointer;
6277 *p = c;
6278 }
6279 /* Should RP be saved into the stack. */
6280 else if ((strncasecmp (name, "save_rp", 7) == 0))
6281 {
6282 p = input_line_pointer;
6283 *p = c;
6284 last_call_info->ci_unwind.descriptor.save_rp = 1;
6285 }
6286 /* Likewise for SP. */
6287 else if ((strncasecmp (name, "save_sp", 7) == 0))
6288 {
6289 p = input_line_pointer;
6290 *p = c;
6291 last_call_info->ci_unwind.descriptor.save_sp = 1;
6292 }
6293 /* Is this an unwindable procedure. If so mark it so
6294 in the unwind descriptor. */
6295 else if ((strncasecmp (name, "no_unwind", 9) == 0))
6296 {
6297 p = input_line_pointer;
6298 *p = c;
6299 last_call_info->ci_unwind.descriptor.cannot_unwind = 1;
6300 }
6301 /* Is this an interrupt routine. If so mark it in the
6302 unwind descriptor. */
6303 else if ((strncasecmp (name, "hpux_int", 7) == 0))
6304 {
6305 p = input_line_pointer;
6306 *p = c;
6307 last_call_info->ci_unwind.descriptor.hpux_interrupt_marker = 1;
6308 }
6309 /* Is this a millicode routine. "millicode" isn't in my
6310 assembler manual, but my copy is old. The HP assembler
6311 accepts it, and there's a place in the unwind descriptor
6312 to drop the information, so we'll accept it too. */
6313 else if ((strncasecmp (name, "millicode", 9) == 0))
6314 {
6315 p = input_line_pointer;
6316 *p = c;
6317 last_call_info->ci_unwind.descriptor.millicode = 1;
6318 }
6319 else
6320 {
6321 as_bad (_("Invalid .CALLINFO argument: %s"), name);
6322 *input_line_pointer = c;
6323 }
6324 if (!is_end_of_statement ())
6325 input_line_pointer++;
6326 }
6327
6328 demand_empty_rest_of_line ();
6329}
6330
85cf2a8a 6331#if !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD)))
ad1079af
AM		 6332/* Switch to the text space. Like s_text, but delete our
6333 label when finished. */
252b5132 6334static void
ad1079af 6335pa_text (unused)
3f9b03b5 6336 int unused ATTRIBUTE_UNUSED;
252b5132 6337{
49863f82 6338#ifdef OBJ_SOM
252b5132
RH		 6339 current_space = is_defined_space ("$TEXT$");
6340 current_subspace
6341 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
49863f82 6342#endif
ad1079af 6343
252b5132
RH		 6344 s_text (0);
6345 pa_undefine_label ();
6346}
6347
ad1079af
AM		 6348/* Switch to the data space. As usual delete our label. */
6349static void
6350pa_data (unused)
6351 int unused ATTRIBUTE_UNUSED;
6352{
6353#ifdef OBJ_SOM
6354 current_space = is_defined_space ("$PRIVATE$");
6355 current_subspace
6356 = pa_subsegment_to_subspace (current_space->sd_seg, 0);
6357#endif
6358 s_data (0);
6359 pa_undefine_label ();
6360}
6361
252b5132
RH		 6362/* This is different than the standard GAS s_comm(). On HP9000/800 machines,
6363 the .comm pseudo-op has the following symtax:
6364
6365 <label> .comm <length>
6366
6367 where <label> is optional and is a symbol whose address will be the start of
6368 a block of memory <length> bytes long. <length> must be an absolute
6369 expression. <length> bytes will be allocated in the current space
6370 and subspace.
6371
6372 Also note the label may not even be on the same line as the .comm.
6373
6374 This difference in syntax means the colon function will be called
6375 on the symbol before we arrive in pa_comm. colon will set a number
6376 of attributes of the symbol that need to be fixed here. In particular
6377 the value, section pointer, fragment pointer, flags, etc. What
6378 a pain.
6379
6380 This also makes error detection all but impossible. */
6381
6382static void
6383pa_comm (unused)
3f9b03b5 6384 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6385{
6386 unsigned int size;
6387 symbolS *symbol;
6388 label_symbol_struct *label_symbol = pa_get_label ();
6389
6390 if (label_symbol)
6391 symbol = label_symbol->lss_label;
6392 else
6393 symbol = NULL;
6394
6395 SKIP_WHITESPACE ();
6396 size = get_absolute_expression ();
6397
6398 if (symbol)
6399 {
9992270f 6400 symbol_get_bfdsym (symbol)->flags |= BSF_OBJECT;
252b5132
RH		 6401 S_SET_VALUE (symbol, size);
6402 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6403 S_SET_EXTERNAL (symbol);
6404
6405 /* colon() has already set the frag to the current location in the
6406 current subspace; we need to reset the fragment to the zero address
6407 fragment. We also need to reset the segment pointer. */
a0f75b47 6408 symbol_set_frag (symbol, &zero_address_frag);
252b5132
RH		 6409 }
6410 demand_empty_rest_of_line ();
6411}
85cf2a8a 6412#endif /* !(defined (OBJ_ELF) && (defined (TE_LINUX) || defined (TE_NetBSD))) */
252b5132
RH		 6413
6414/* Process a .END pseudo-op. */
6415
6416static void
6417pa_end (unused)
3f9b03b5 6418 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6419{
6420 demand_empty_rest_of_line ();
6421}
6422
6423/* Process a .ENTER pseudo-op. This is not supported. */
6424static void
6425pa_enter (unused)
3f9b03b5 6426 int unused ATTRIBUTE_UNUSED;
252b5132 6427{
49863f82 6428#ifdef OBJ_SOM
252b5132
RH		 6429 /* We must have a valid space and subspace. */
6430 pa_check_current_space_and_subspace ();
49863f82 6431#endif
252b5132
RH		 6432
6433 as_bad (_("The .ENTER pseudo-op is not supported"));
6434 demand_empty_rest_of_line ();
6435}
6436
6437/* Process a .ENTRY pseudo-op. .ENTRY marks the beginning of the
0234cb7c 6438 procedure. */
252b5132
RH		 6439static void
6440pa_entry (unused)
3f9b03b5 6441 int unused ATTRIBUTE_UNUSED;
252b5132 6442{
49863f82 6443#ifdef OBJ_SOM
252b5132
RH		 6444 /* We must have a valid space and subspace. */
6445 pa_check_current_space_and_subspace ();
49863f82 6446#endif
252b5132
RH		 6447
6448 if (!within_procedure)
6449 as_bad (_("Misplaced .entry. Ignored."));
6450 else
6451 {
6452 if (!callinfo_found)
6453 as_bad (_("Missing .callinfo."));
6454 }
6455 demand_empty_rest_of_line ();
6456 within_entry_exit = TRUE;
6457
6458#ifdef OBJ_SOM
6459 /* SOM defers building of unwind descriptors until the link phase.
6460 The assembler is responsible for creating an R_ENTRY relocation
6461 to mark the beginning of a region and hold the unwind bits, and
6462 for creating an R_EXIT relocation to mark the end of the region.
6463
6464 FIXME. ELF should be using the same conventions! The problem
6465 is an unwind requires too much relocation space. Hmmm. Maybe
6466 if we split the unwind bits up between the relocations which
6467 denote the entry and exit points. */
6468 if (last_call_info->start_symbol != NULL)
6469 {
da6c73e0
AM		 6470 char *where;
6471 unsigned int u;
252b5132 6472
da6c73e0
AM		 6473 where = frag_more (0);
6474 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
252b5132
RH		 6475 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6476 NULL, (offsetT) 0, NULL,
da6c73e0 6477 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
252b5132
RH		 6478 }
6479#endif
6480}
6481
ecacdc7a
AM		 6482/* Silly nonsense for pa_equ. The only half-sensible use for this is
6483 being able to subtract two register symbols that specify a range of
6484 registers, to get the size of the range. */
6485static int fudge_reg_expressions;
6486
6487int
6488hppa_force_reg_syms_absolute (resultP, op, rightP)
6489 expressionS *resultP;
6490 operatorT op ATTRIBUTE_UNUSED;
6491 expressionS *rightP;
6492{
6493 if (fudge_reg_expressions
6494 && rightP->X_op == O_register
6495 && resultP->X_op == O_register)
6496 {
6497 rightP->X_op = O_constant;
6498 resultP->X_op = O_constant;
6499 }
6500 return 0; /* Continue normal expr handling. */
6501}
6502
252b5132
RH		 6503/* Handle a .EQU pseudo-op. */
6504
6505static void
6506pa_equ (reg)
6507 int reg;
6508{
6509 label_symbol_struct *label_symbol = pa_get_label ();
6510 symbolS *symbol;
6511
6512 if (label_symbol)
6513 {
6514 symbol = label_symbol->lss_label;
6515 if (reg)
ecacdc7a
AM		 6516 {
6517 strict = 1;
6518 if (!pa_parse_number (&input_line_pointer, 0))
6519 as_bad (_(".REG expression must be a register"));
6520 S_SET_VALUE (symbol, pa_number);
6521 S_SET_SEGMENT (symbol, reg_section);
6522 }
252b5132 6523 else
ecacdc7a
AM		 6524 {
6525 expressionS exp;
6526 segT seg;
6527
6528 fudge_reg_expressions = 1;
6529 seg = expression (&exp);
6530 fudge_reg_expressions = 0;
6531 if (exp.X_op != O_constant
6532 && exp.X_op != O_register)
6533 {
6534 if (exp.X_op != O_absent)
6535 as_bad (_("bad or irreducible absolute expression; zero assumed"));
6536 exp.X_add_number = 0;
6537 seg = absolute_section;
6538 }
6539 S_SET_VALUE (symbol, (unsigned int) exp.X_add_number);
6540 S_SET_SEGMENT (symbol, seg);
6541 }
252b5132
RH		 6542 }
6543 else
6544 {
6545 if (reg)
6546 as_bad (_(".REG must use a label"));
6547 else
6548 as_bad (_(".EQU must use a label"));
6549 }
6550
6551 pa_undefine_label ();
6552 demand_empty_rest_of_line ();
6553}
6554
6555/* Helper function. Does processing for the end of a function. This
6556 usually involves creating some relocations or building special
6557 symbols to mark the end of the function. */
6558
6559static void
6560process_exit ()
6561{
6562 char *where;
6563
6564 where = frag_more (0);
6565
6566#ifdef OBJ_ELF
6567 /* Mark the end of the function, stuff away the location of the frag
6568 for the end of the function, and finally call pa_build_unwind_subspace
6569 to add an entry in the unwind table. */
6570 hppa_elf_mark_end_of_function ();
6571 pa_build_unwind_subspace (last_call_info);
6572#else
6573 /* SOM defers building of unwind descriptors until the link phase.
6574 The assembler is responsible for creating an R_ENTRY relocation
6575 to mark the beginning of a region and hold the unwind bits, and
6576 for creating an R_EXIT relocation to mark the end of the region.
6577
6578 FIXME. ELF should be using the same conventions! The problem
6579 is an unwind requires too much relocation space. Hmmm. Maybe
6580 if we split the unwind bits up between the relocations which
6581 denote the entry and exit points. */
6582 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
6583 NULL, (offsetT) 0,
6584 NULL, 0, R_HPPA_EXIT, e_fsel, 0, 0,
da6c73e0 6585 UNWIND_HIGH32 (&last_call_info->ci_unwind.descriptor));
252b5132
RH		 6586#endif
6587}
6588
6589/* Process a .EXIT pseudo-op. */
6590
6591static void
6592pa_exit (unused)
3f9b03b5 6593 int unused ATTRIBUTE_UNUSED;
252b5132 6594{
49863f82 6595#ifdef OBJ_SOM
252b5132
RH		 6596 /* We must have a valid space and subspace. */
6597 pa_check_current_space_and_subspace ();
49863f82 6598#endif
252b5132
RH		 6599
6600 if (!within_procedure)
6601 as_bad (_(".EXIT must appear within a procedure"));
6602 else
6603 {
6604 if (!callinfo_found)
6605 as_bad (_("Missing .callinfo"));
6606 else
6607 {
6608 if (!within_entry_exit)
6609 as_bad (_("No .ENTRY for this .EXIT"));
6610 else
6611 {
6612 within_entry_exit = FALSE;
6613 process_exit ();
6614 }
6615 }
6616 }
6617 demand_empty_rest_of_line ();
6618}
6619
6620/* Process a .EXPORT directive. This makes functions external
6621 and provides information such as argument relocation entries
6622 to callers. */
6623
6624static void
6625pa_export (unused)
3f9b03b5 6626 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6627{
6628 char *name, c, *p;
6629 symbolS *symbol;
6630
6631 name = input_line_pointer;
6632 c = get_symbol_end ();
6633 /* Make sure the given symbol exists. */
6634 if ((symbol = symbol_find_or_make (name)) == NULL)
6635 {
6636 as_bad (_("Cannot define export symbol: %s\n"), name);
6637 p = input_line_pointer;
6638 *p = c;
6639 input_line_pointer++;
6640 }
6641 else
6642 {
20348649 6643 /* OK. Set the external bits and process argument relocations.
a28a3ccf 6644 For the HP, weak and global are not mutually exclusive.
20348649
JL		 6645 S_SET_EXTERNAL will not set BSF_GLOBAL if WEAK is set.
6646 Call S_SET_EXTERNAL to get the other processing. Manually
6647 set BSF_GLOBAL when we get back. */
252b5132 6648 S_SET_EXTERNAL (symbol);
20348649 6649 symbol_get_bfdsym (symbol)->flags |= BSF_GLOBAL;
252b5132
RH		 6650 p = input_line_pointer;
6651 *p = c;
6652 if (!is_end_of_statement ())
6653 {
6654 input_line_pointer++;
6655 pa_type_args (symbol, 1);
6656 }
6657 }
6658
6659 demand_empty_rest_of_line ();
6660}
6661
6662/* Helper function to process arguments to a .EXPORT pseudo-op. */
6663
6664static void
6665pa_type_args (symbolP, is_export)
6666 symbolS *symbolP;
6667 int is_export;
6668{
6669 char *name, c, *p;
6670 unsigned int temp, arg_reloc;
6671 pa_symbol_type type = SYMBOL_TYPE_UNKNOWN;
904a31bf 6672 asymbol *bfdsym = symbol_get_bfdsym (symbolP);
252b5132
RH		 6673
6674 if (strncasecmp (input_line_pointer, "absolute", 8) == 0)
6675
6676 {
6677 input_line_pointer += 8;
904a31bf 6678 bfdsym->flags &= ~BSF_FUNCTION;
252b5132
RH		 6679 S_SET_SEGMENT (symbolP, bfd_abs_section_ptr);
6680 type = SYMBOL_TYPE_ABSOLUTE;
6681 }
6682 else if (strncasecmp (input_line_pointer, "code", 4) == 0)
6683 {
6684 input_line_pointer += 4;
6685 /* IMPORTing/EXPORTing CODE types for functions is meaningless for SOM,
6686 instead one should be IMPORTing/EXPORTing ENTRY types.
6687
6688 Complain if one tries to EXPORT a CODE type since that's never
6689 done. Both GCC and HP C still try to IMPORT CODE types, so
6690 silently fix them to be ENTRY types. */
a0f75b47 6691 if (S_IS_FUNCTION (symbolP))
252b5132
RH		 6692 {
6693 if (is_export)
a0f75b47
ILT		 6694 as_tsktsk (_("Using ENTRY rather than CODE in export directive for %s"),
6695 S_GET_NAME (symbolP));
252b5132 6696
904a31bf 6697 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6698 type = SYMBOL_TYPE_ENTRY;
6699 }
6700 else
6701 {
904a31bf 6702 bfdsym->flags &= ~BSF_FUNCTION;
252b5132
RH		 6703 type = SYMBOL_TYPE_CODE;
6704 }
6705 }
6706 else if (strncasecmp (input_line_pointer, "data", 4) == 0)
6707 {
6708 input_line_pointer += 4;
904a31bf
AM		 6709 bfdsym->flags &= ~BSF_FUNCTION;
6710 bfdsym->flags |= BSF_OBJECT;
252b5132
RH		 6711 type = SYMBOL_TYPE_DATA;
6712 }
6713 else if ((strncasecmp (input_line_pointer, "entry", 5) == 0))
6714 {
6715 input_line_pointer += 5;
904a31bf 6716 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6717 type = SYMBOL_TYPE_ENTRY;
6718 }
6719 else if (strncasecmp (input_line_pointer, "millicode", 9) == 0)
6720 {
6721 input_line_pointer += 9;
904a31bf
AM		 6722 bfdsym->flags |= BSF_FUNCTION;
6723#ifdef OBJ_ELF
6724 {
6725 elf_symbol_type *elfsym = (elf_symbol_type *) bfdsym;
6726 elfsym->internal_elf_sym.st_info =
6727 ELF_ST_INFO (ELF_ST_BIND (elfsym->internal_elf_sym.st_info),
6728 STT_PARISC_MILLI);
6729 }
6730#endif
252b5132
RH		 6731 type = SYMBOL_TYPE_MILLICODE;
6732 }
6733 else if (strncasecmp (input_line_pointer, "plabel", 6) == 0)
6734 {
6735 input_line_pointer += 6;
904a31bf 6736 bfdsym->flags &= ~BSF_FUNCTION;
252b5132
RH		 6737 type = SYMBOL_TYPE_PLABEL;
6738 }
6739 else if (strncasecmp (input_line_pointer, "pri_prog", 8) == 0)
6740 {
6741 input_line_pointer += 8;
904a31bf 6742 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6743 type = SYMBOL_TYPE_PRI_PROG;
6744 }
6745 else if (strncasecmp (input_line_pointer, "sec_prog", 8) == 0)
6746 {
6747 input_line_pointer += 8;
904a31bf 6748 bfdsym->flags |= BSF_FUNCTION;
252b5132
RH		 6749 type = SYMBOL_TYPE_SEC_PROG;
6750 }
6751
6752 /* SOM requires much more information about symbol types
6753 than BFD understands. This is how we get this information
6754 to the SOM BFD backend. */
6755#ifdef obj_set_symbol_type
904a31bf 6756 obj_set_symbol_type (bfdsym, (int) type);
252b5132
RH		 6757#endif
6758
6759 /* Now that the type of the exported symbol has been handled,
6760 handle any argument relocation information. */
6761 while (!is_end_of_statement ())
6762 {
6763 if (*input_line_pointer == ',')
6764 input_line_pointer++;
6765 name = input_line_pointer;
6766 c = get_symbol_end ();
6767 /* Argument sources. */
6768 if ((strncasecmp (name, "argw", 4) == 0))
6769 {
6770 p = input_line_pointer;
6771 *p = c;
6772 input_line_pointer++;
6773 temp = atoi (name + 4);
6774 name = input_line_pointer;
6775 c = get_symbol_end ();
6776 arg_reloc = pa_align_arg_reloc (temp, pa_build_arg_reloc (name));
25a8b250 6777#if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
ad1079af 6778 symbol_arg_reloc_info (symbolP) |= arg_reloc;
49863f82 6779#endif
252b5132
RH		 6780 *input_line_pointer = c;
6781 }
6782 /* The return value. */
6783 else if ((strncasecmp (name, "rtnval", 6)) == 0)
6784 {
6785 p = input_line_pointer;
6786 *p = c;
6787 input_line_pointer++;
6788 name = input_line_pointer;
6789 c = get_symbol_end ();
6790 arg_reloc = pa_build_arg_reloc (name);
25a8b250 6791#if defined (OBJ_SOM) || defined (ELF_ARG_RELOC)
ad1079af 6792 symbol_arg_reloc_info (symbolP) |= arg_reloc;
49863f82 6793#endif
252b5132
RH		 6794 *input_line_pointer = c;
6795 }
0234cb7c 6796 /* Privilege level. */
252b5132
RH		 6797 else if ((strncasecmp (name, "priv_lev", 8)) == 0)
6798 {
6799 p = input_line_pointer;
6800 *p = c;
6801 input_line_pointer++;
6802 temp = atoi (input_line_pointer);
49863f82 6803#ifdef OBJ_SOM
904a31bf 6804 ((obj_symbol_type *) bfdsym)->tc_data.ap.hppa_priv_level = temp;
49863f82 6805#endif
252b5132
RH		 6806 c = get_symbol_end ();
6807 *input_line_pointer = c;
6808 }
6809 else
6810 {
6811 as_bad (_("Undefined .EXPORT/.IMPORT argument (ignored): %s"), name);
6812 p = input_line_pointer;
6813 *p = c;
6814 }
6815 if (!is_end_of_statement ())
6816 input_line_pointer++;
6817 }
6818}
6819
6820/* Handle an .IMPORT pseudo-op. Any symbol referenced in a given
6821 assembly file must either be defined in the assembly file, or
6822 explicitly IMPORTED from another. */
6823
6824static void
6825pa_import (unused)
3f9b03b5 6826 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6827{
6828 char *name, c, *p;
6829 symbolS *symbol;
6830
6831 name = input_line_pointer;
6832 c = get_symbol_end ();
6833
6834 symbol = symbol_find (name);
6835 /* Ugh. We might be importing a symbol defined earlier in the file,
6836 in which case all the code below will really screw things up
6837 (set the wrong segment, symbol flags & type, etc). */
6838 if (symbol == NULL || !S_IS_DEFINED (symbol))
6839 {
6840 symbol = symbol_find_or_make (name);
6841 p = input_line_pointer;
6842 *p = c;
6843
6844 if (!is_end_of_statement ())
6845 {
6846 input_line_pointer++;
6847 pa_type_args (symbol, 0);
6848 }
6849 else
6850 {
0234cb7c 6851 /* Sigh. To be compatible with the HP assembler and to help
252b5132 6852 poorly written assembly code, we assign a type based on
b6ff326e 6853 the current segment. Note only BSF_FUNCTION really
252b5132
RH		 6854 matters, we do not need to set the full SYMBOL_TYPE_* info. */
6855 if (now_seg == text_section)
a0f75b47 6856 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
252b5132
RH		 6857
6858 /* If the section is undefined, then the symbol is undefined
6859 Since this is an import, leave the section undefined. */
6860 S_SET_SEGMENT (symbol, bfd_und_section_ptr);
6861 }
6862 }
6863 else
6864 {
6865 /* The symbol was already defined. Just eat everything up to
6866 the end of the current statement. */
6867 while (!is_end_of_statement ())
6868 input_line_pointer++;
6869 }
6870
6871 demand_empty_rest_of_line ();
6872}
6873
6874/* Handle a .LABEL pseudo-op. */
6875
6876static void
6877pa_label (unused)
3f9b03b5 6878 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6879{
6880 char *name, c, *p;
6881
6882 name = input_line_pointer;
6883 c = get_symbol_end ();
6884
6885 if (strlen (name) > 0)
6886 {
6887 colon (name);
6888 p = input_line_pointer;
6889 *p = c;
6890 }
6891 else
6892 {
6893 as_warn (_("Missing label name on .LABEL"));
6894 }
6895
6896 if (!is_end_of_statement ())
6897 {
6898 as_warn (_("extra .LABEL arguments ignored."));
6899 ignore_rest_of_line ();
6900 }
6901 demand_empty_rest_of_line ();
6902}
6903
6904/* Handle a .LEAVE pseudo-op. This is not supported yet. */
6905
6906static void
6907pa_leave (unused)
3f9b03b5 6908 int unused ATTRIBUTE_UNUSED;
252b5132 6909{
49863f82 6910#ifdef OBJ_SOM
252b5132
RH		 6911 /* We must have a valid space and subspace. */
6912 pa_check_current_space_and_subspace ();
49863f82 6913#endif
252b5132
RH		 6914
6915 as_bad (_("The .LEAVE pseudo-op is not supported"));
6916 demand_empty_rest_of_line ();
6917}
6918
6919/* Handle a .LEVEL pseudo-op. */
6920
6921static void
6922pa_level (unused)
3f9b03b5 6923 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6924{
6925 char *level;
6926
6927 level = input_line_pointer;
6928 if (strncmp (level, "1.0", 3) == 0)
6929 {
6930 input_line_pointer += 3;
6931 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 10))
6932 as_warn (_("could not set architecture and machine"));
6933 }
6934 else if (strncmp (level, "1.1", 3) == 0)
6935 {
6936 input_line_pointer += 3;
6937 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 11))
6938 as_warn (_("could not set architecture and machine"));
6939 }
46031ca9
JL		 6940 else if (strncmp (level, "2.0w", 4) == 0)
6941 {
6942 input_line_pointer += 4;
6943 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 25))
6944 as_warn (_("could not set architecture and machine"));
6945 }
252b5132
RH		 6946 else if (strncmp (level, "2.0", 3) == 0)
6947 {
6948 input_line_pointer += 3;
6949 if (!bfd_set_arch_mach (stdoutput, bfd_arch_hppa, 20))
6950 as_warn (_("could not set architecture and machine"));
6951 }
6952 else
6953 {
6954 as_bad (_("Unrecognized .LEVEL argument\n"));
6955 ignore_rest_of_line ();
6956 }
6957 demand_empty_rest_of_line ();
6958}
6959
6960/* Handle a .ORIGIN pseudo-op. */
6961
6962static void
6963pa_origin (unused)
3f9b03b5 6964 int unused ATTRIBUTE_UNUSED;
252b5132 6965{
49863f82 6966#ifdef OBJ_SOM
252b5132
RH		 6967 /* We must have a valid space and subspace. */
6968 pa_check_current_space_and_subspace ();
49863f82 6969#endif
252b5132
RH		 6970
6971 s_org (0);
6972 pa_undefine_label ();
6973}
6974
6975/* Handle a .PARAM pseudo-op. This is much like a .EXPORT, except it
6976 is for static functions. FIXME. Should share more code with .EXPORT. */
6977
6978static void
6979pa_param (unused)
3f9b03b5 6980 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 6981{
6982 char *name, c, *p;
6983 symbolS *symbol;
6984
6985 name = input_line_pointer;
6986 c = get_symbol_end ();
6987
6988 if ((symbol = symbol_find_or_make (name)) == NULL)
6989 {
6990 as_bad (_("Cannot define static symbol: %s\n"), name);
6991 p = input_line_pointer;
6992 *p = c;
6993 input_line_pointer++;
6994 }
6995 else
6996 {
6997 S_CLEAR_EXTERNAL (symbol);
6998 p = input_line_pointer;
6999 *p = c;
7000 if (!is_end_of_statement ())
7001 {
7002 input_line_pointer++;
7003 pa_type_args (symbol, 0);
7004 }
7005 }
7006
7007 demand_empty_rest_of_line ();
7008}
7009
7010/* Handle a .PROC pseudo-op. It is used to mark the beginning
ad1079af 7011 of a procedure from a syntactical point of view. */
252b5132
RH		 7012
7013static void
7014pa_proc (unused)
3f9b03b5 7015 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7016{
7017 struct call_info *call_info;
7018
49863f82 7019#ifdef OBJ_SOM
252b5132
RH		 7020 /* We must have a valid space and subspace. */
7021 pa_check_current_space_and_subspace ();
49863f82 7022#endif
252b5132
RH		 7023
7024 if (within_procedure)
7025 as_fatal (_("Nested procedures"));
7026
7027 /* Reset global variables for new procedure. */
7028 callinfo_found = FALSE;
7029 within_procedure = TRUE;
7030
7031 /* Create another call_info structure. */
7032 call_info = (struct call_info *) xmalloc (sizeof (struct call_info));
7033
7034 if (!call_info)
7035 as_fatal (_("Cannot allocate unwind descriptor\n"));
7036
7037 memset (call_info, 0, sizeof (struct call_info));
7038
7039 call_info->ci_next = NULL;
7040
7041 if (call_info_root == NULL)
7042 {
7043 call_info_root = call_info;
7044 last_call_info = call_info;
7045 }
7046 else
7047 {
7048 last_call_info->ci_next = call_info;
7049 last_call_info = call_info;
7050 }
7051
7052 /* set up defaults on call_info structure */
7053
7054 call_info->ci_unwind.descriptor.cannot_unwind = 0;
7055 call_info->ci_unwind.descriptor.region_desc = 1;
7056 call_info->ci_unwind.descriptor.hpux_interrupt_marker = 0;
7057
7058 /* If we got a .PROC pseudo-op, we know that the function is defined
7059 locally. Make sure it gets into the symbol table. */
7060 {
7061 label_symbol_struct *label_symbol = pa_get_label ();
7062
7063 if (label_symbol)
7064 {
7065 if (label_symbol->lss_label)
7066 {
7067 last_call_info->start_symbol = label_symbol->lss_label;
a0f75b47 7068 symbol_get_bfdsym (label_symbol->lss_label)->flags |= BSF_FUNCTION;
252b5132
RH		 7069 }
7070 else
7071 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7072 }
7073 else
7074 last_call_info->start_symbol = NULL;
7075 }
7076
7077 demand_empty_rest_of_line ();
7078}
7079
0234cb7c 7080/* Process the syntactical end of a procedure. Make sure all the
252b5132
RH		 7081 appropriate pseudo-ops were found within the procedure. */
7082
7083static void
7084pa_procend (unused)
3f9b03b5 7085 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7086{
7087
49863f82 7088#ifdef OBJ_SOM
252b5132
RH		 7089 /* We must have a valid space and subspace. */
7090 pa_check_current_space_and_subspace ();
49863f82 7091#endif
252b5132
RH		 7092
7093 /* If we are within a procedure definition, make sure we've
7094 defined a label for the procedure; handle case where the
7095 label was defined after the .PROC directive.
7096
7097 Note there's not need to diddle with the segment or fragment
7098 for the label symbol in this case. We have already switched
7099 into the new $CODE$ subspace at this point. */
7100 if (within_procedure && last_call_info->start_symbol == NULL)
7101 {
7102 label_symbol_struct *label_symbol = pa_get_label ();
7103
7104 if (label_symbol)
7105 {
7106 if (label_symbol->lss_label)
7107 {
7108 last_call_info->start_symbol = label_symbol->lss_label;
a0f75b47
ILT		 7109 symbol_get_bfdsym (label_symbol->lss_label)->flags
7110 |= BSF_FUNCTION;
252b5132
RH		 7111#ifdef OBJ_SOM
7112 /* Also handle allocation of a fixup to hold the unwind
7113 information when the label appears after the proc/procend. */
7114 if (within_entry_exit)
7115 {
da6c73e0
AM		 7116 char *where;
7117 unsigned int u;
252b5132 7118
da6c73e0
AM		 7119 where = frag_more (0);
7120 u = UNWIND_LOW32 (&last_call_info->ci_unwind.descriptor);
252b5132
RH		 7121 fix_new_hppa (frag_now, where - frag_now->fr_literal, 0,
7122 NULL, (offsetT) 0, NULL,
da6c73e0 7123 0, R_HPPA_ENTRY, e_fsel, 0, 0, u);
252b5132
RH		 7124 }
7125#endif
7126 }
7127 else
7128 as_bad (_("Missing function name for .PROC (corrupted label chain)"));
7129 }
7130 else
7131 as_bad (_("Missing function name for .PROC"));
7132 }
7133
7134 if (!within_procedure)
7135 as_bad (_("misplaced .procend"));
7136
7137 if (!callinfo_found)
7138 as_bad (_("Missing .callinfo for this procedure"));
7139
7140 if (within_entry_exit)
7141 as_bad (_("Missing .EXIT for a .ENTRY"));
7142
7143#ifdef OBJ_ELF
7144 /* ELF needs to mark the end of each function so that it can compute
7145 the size of the function (apparently its needed in the symbol table). */
7146 hppa_elf_mark_end_of_function ();
7147#endif
7148
7149 within_procedure = FALSE;
7150 demand_empty_rest_of_line ();
7151 pa_undefine_label ();
7152}
7153
3f9b03b5 7154#ifdef OBJ_SOM
49863f82
JL		 7155/* If VALUE is an exact power of two between zero and 2^31, then
7156 return log2 (VALUE). Else return -1. */
7157
7158static int
b8fc22bc 7159exact_log2 (value)
49863f82
JL		 7160 int value;
7161{
7162 int shift = 0;
7163
7164 while ((1 << shift) != value && shift < 32)
7165 shift++;
7166
7167 if (shift >= 32)
7168 return -1;
7169 else
7170 return shift;
7171}
7172
49863f82
JL		 7173/* Check to make sure we have a valid space and subspace. */
7174
7175static void
7176pa_check_current_space_and_subspace ()
7177{
7178 if (current_space == NULL)
7179 as_fatal (_("Not in a space.\n"));
7180
7181 if (current_subspace == NULL)
7182 as_fatal (_("Not in a subspace.\n"));
7183}
7184
252b5132
RH		 7185/* Parse the parameters to a .SPACE directive; if CREATE_FLAG is nonzero,
7186 then create a new space entry to hold the information specified
7187 by the parameters to the .SPACE directive. */
7188
7189static sd_chain_struct *
7190pa_parse_space_stmt (space_name, create_flag)
7191 char *space_name;
7192 int create_flag;
7193{
7194 char *name, *ptemp, c;
7195 char loadable, defined, private, sort;
ecacdc7a 7196 int spnum;
252b5132
RH		 7197 asection *seg = NULL;
7198 sd_chain_struct *space;
7199
7200 /* load default values */
7201 spnum = 0;
7202 sort = 0;
7203 loadable = TRUE;
7204 defined = TRUE;
7205 private = FALSE;
7206 if (strcmp (space_name, "$TEXT$") == 0)
7207 {
7208 seg = pa_def_spaces[0].segment;
7209 defined = pa_def_spaces[0].defined;
7210 private = pa_def_spaces[0].private;
7211 sort = pa_def_spaces[0].sort;
7212 spnum = pa_def_spaces[0].spnum;
7213 }
7214 else if (strcmp (space_name, "$PRIVATE$") == 0)
7215 {
7216 seg = pa_def_spaces[1].segment;
7217 defined = pa_def_spaces[1].defined;
7218 private = pa_def_spaces[1].private;
7219 sort = pa_def_spaces[1].sort;
7220 spnum = pa_def_spaces[1].spnum;
7221 }
7222
7223 if (!is_end_of_statement ())
7224 {
7225 print_errors = FALSE;
7226 ptemp = input_line_pointer + 1;
7227 /* First see if the space was specified as a number rather than
7228 as a name. According to the PA assembly manual the rest of
7229 the line should be ignored. */
ecacdc7a
AM		 7230 strict = 0;
7231 pa_parse_number (&ptemp, 0);
7232 if (pa_number >= 0)
252b5132 7233 {
ecacdc7a 7234 spnum = pa_number;
252b5132
RH		 7235 input_line_pointer = ptemp;
7236 }
7237 else
7238 {
7239 while (!is_end_of_statement ())
7240 {
7241 input_line_pointer++;
7242 name = input_line_pointer;
7243 c = get_symbol_end ();
7244 if ((strncasecmp (name, "spnum", 5) == 0))
7245 {
7246 *input_line_pointer = c;
7247 input_line_pointer++;
7248 spnum = get_absolute_expression ();
7249 }
7250 else if ((strncasecmp (name, "sort", 4) == 0))
7251 {
7252 *input_line_pointer = c;
7253 input_line_pointer++;
7254 sort = get_absolute_expression ();
7255 }
7256 else if ((strncasecmp (name, "unloadable", 10) == 0))
7257 {
7258 *input_line_pointer = c;
7259 loadable = FALSE;
7260 }
7261 else if ((strncasecmp (name, "notdefined", 10) == 0))
7262 {
7263 *input_line_pointer = c;
7264 defined = FALSE;
7265 }
7266 else if ((strncasecmp (name, "private", 7) == 0))
7267 {
7268 *input_line_pointer = c;
7269 private = TRUE;
7270 }
7271 else
7272 {
7273 as_bad (_("Invalid .SPACE argument"));
7274 *input_line_pointer = c;
7275 if (!is_end_of_statement ())
7276 input_line_pointer++;
7277 }
7278 }
7279 }
7280 print_errors = TRUE;
7281 }
7282
7283 if (create_flag && seg == NULL)
7284 seg = subseg_new (space_name, 0);
7285
7286 /* If create_flag is nonzero, then create the new space with
7287 the attributes computed above. Else set the values in
7288 an already existing space -- this can only happen for
0234cb7c 7289 the first occurrence of a built-in space. */
252b5132
RH		 7290 if (create_flag)
7291 space = create_new_space (space_name, spnum, loadable, defined,
7292 private, sort, seg, 1);
7293 else
7294 {
7295 space = is_defined_space (space_name);
7296 SPACE_SPNUM (space) = spnum;
7297 SPACE_DEFINED (space) = defined & 1;
7298 SPACE_USER_DEFINED (space) = 1;
7299 }
7300
7301#ifdef obj_set_section_attributes
7302 obj_set_section_attributes (seg, defined, private, sort, spnum);
7303#endif
7304
7305 return space;
7306}
7307
7308/* Handle a .SPACE pseudo-op; this switches the current space to the
7309 given space, creating the new space if necessary. */
7310
7311static void
7312pa_space (unused)
3f9b03b5 7313 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7314{
7315 char *name, c, *space_name, *save_s;
252b5132
RH		 7316 sd_chain_struct *sd_chain;
7317
7318 if (within_procedure)
7319 {
7320 as_bad (_("Can\'t change spaces within a procedure definition. Ignored"));
7321 ignore_rest_of_line ();
7322 }
7323 else
7324 {
7325 /* Check for some of the predefined spaces. FIXME: most of the code
7326 below is repeated several times, can we extract the common parts
7327 and place them into a subroutine or something similar? */
7328 /* FIXME Is this (and the next IF stmt) really right?
7329 What if INPUT_LINE_POINTER points to "$TEXT$FOO"? */
7330 if (strncmp (input_line_pointer, "$TEXT$", 6) == 0)
7331 {
7332 input_line_pointer += 6;
7333 sd_chain = is_defined_space ("$TEXT$");
7334 if (sd_chain == NULL)
7335 sd_chain = pa_parse_space_stmt ("$TEXT$", 1);
7336 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7337 sd_chain = pa_parse_space_stmt ("$TEXT$", 0);
7338
7339 current_space = sd_chain;
7340 subseg_set (text_section, sd_chain->sd_last_subseg);
7341 current_subspace
7342 = pa_subsegment_to_subspace (text_section,
7343 sd_chain->sd_last_subseg);
7344 demand_empty_rest_of_line ();
7345 return;
7346 }
7347 if (strncmp (input_line_pointer, "$PRIVATE$", 9) == 0)
7348 {
7349 input_line_pointer += 9;
7350 sd_chain = is_defined_space ("$PRIVATE$");
7351 if (sd_chain == NULL)
7352 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 1);
7353 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7354 sd_chain = pa_parse_space_stmt ("$PRIVATE$", 0);
7355
7356 current_space = sd_chain;
7357 subseg_set (data_section, sd_chain->sd_last_subseg);
7358 current_subspace
7359 = pa_subsegment_to_subspace (data_section,
7360 sd_chain->sd_last_subseg);
7361 demand_empty_rest_of_line ();
7362 return;
7363 }
7364 if (!strncasecmp (input_line_pointer,
7365 GDB_DEBUG_SPACE_NAME,
7366 strlen (GDB_DEBUG_SPACE_NAME)))
7367 {
7368 input_line_pointer += strlen (GDB_DEBUG_SPACE_NAME);
7369 sd_chain = is_defined_space (GDB_DEBUG_SPACE_NAME);
7370 if (sd_chain == NULL)
7371 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 1);
7372 else if (SPACE_USER_DEFINED (sd_chain) == 0)
7373 sd_chain = pa_parse_space_stmt (GDB_DEBUG_SPACE_NAME, 0);
7374
7375 current_space = sd_chain;
7376
7377 {
7378 asection *gdb_section
7379 = bfd_make_section_old_way (stdoutput, GDB_DEBUG_SPACE_NAME);
7380
7381 subseg_set (gdb_section, sd_chain->sd_last_subseg);
7382 current_subspace
7383 = pa_subsegment_to_subspace (gdb_section,
7384 sd_chain->sd_last_subseg);
7385 }
7386 demand_empty_rest_of_line ();
7387 return;
7388 }
7389
7390 /* It could be a space specified by number. */
7391 print_errors = 0;
7392 save_s = input_line_pointer;
ecacdc7a
AM		 7393 strict = 0;
7394 pa_parse_number (&input_line_pointer, 0);
7395 if (pa_number >= 0)
252b5132 7396 {
ecacdc7a 7397 if ((sd_chain = pa_find_space_by_number (pa_number)))
252b5132
RH		 7398 {
7399 current_space = sd_chain;
7400
7401 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7402 current_subspace
7403 = pa_subsegment_to_subspace (sd_chain->sd_seg,
7404 sd_chain->sd_last_subseg);
7405 demand_empty_rest_of_line ();
7406 return;
7407 }
7408 }
7409
7410 /* Not a number, attempt to create a new space. */
7411 print_errors = 1;
7412 input_line_pointer = save_s;
7413 name = input_line_pointer;
7414 c = get_symbol_end ();
7415 space_name = xmalloc (strlen (name) + 1);
7416 strcpy (space_name, name);
7417 *input_line_pointer = c;
7418
7419 sd_chain = pa_parse_space_stmt (space_name, 1);
7420 current_space = sd_chain;
7421
7422 subseg_set (sd_chain->sd_seg, sd_chain->sd_last_subseg);
7423 current_subspace = pa_subsegment_to_subspace (sd_chain->sd_seg,
7424 sd_chain->sd_last_subseg);
7425 demand_empty_rest_of_line ();
7426 }
7427}
7428
7429/* Switch to a new space. (I think). FIXME. */
7430
7431static void
7432pa_spnum (unused)
3f9b03b5 7433 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 7434{
7435 char *name;
7436 char c;
7437 char *p;
7438 sd_chain_struct *space;
7439
7440 name = input_line_pointer;
7441 c = get_symbol_end ();
7442 space = is_defined_space (name);
7443 if (space)
7444 {
7445 p = frag_more (4);
7446 md_number_to_chars (p, SPACE_SPNUM (space), 4);
7447 }
7448 else
7449 as_warn (_("Undefined space: '%s' Assuming space number = 0."), name);
7450
7451 *input_line_pointer = c;
7452 demand_empty_rest_of_line ();
7453}
7454
252b5132
RH		 7455/* Handle a .SUBSPACE pseudo-op; this switches the current subspace to the
7456 given subspace, creating the new subspace if necessary.
7457
7458 FIXME. Should mirror pa_space more closely, in particular how
7459 they're broken up into subroutines. */
7460
7461static void
7462pa_subspace (create_new)
7463 int create_new;
7464{
49863f82 7465 char *name, *ss_name, c;
351e2b5a 7466 char loadable, code_only, comdat, common, dup_common, zero, sort;
252b5132
RH		 7467 int i, access, space_index, alignment, quadrant, applicable, flags;
7468 sd_chain_struct *space;
7469 ssd_chain_struct *ssd;
7470 asection *section;
7471
7472 if (current_space == NULL)
7473 as_fatal (_("Must be in a space before changing or declaring subspaces.\n"));
7474
7475 if (within_procedure)
7476 {
7477 as_bad (_("Can\'t change subspaces within a procedure definition. Ignored"));
7478 ignore_rest_of_line ();
7479 }
7480 else
7481 {
7482 name = input_line_pointer;
7483 c = get_symbol_end ();
7484 ss_name = xmalloc (strlen (name) + 1);
7485 strcpy (ss_name, name);
7486 *input_line_pointer = c;
7487
7488 /* Load default values. */
7489 sort = 0;
7490 access = 0x7f;
7491 loadable = 1;
351e2b5a 7492 comdat = 0;
252b5132
RH		 7493 common = 0;
7494 dup_common = 0;
7495 code_only = 0;
7496 zero = 0;
7497 space_index = ~0;
7498 alignment = 1;
7499 quadrant = 0;
252b5132
RH		 7500
7501 space = current_space;
7502 if (create_new)
7503 ssd = NULL;
7504 else
7505 ssd = is_defined_subspace (ss_name);
7506 /* Allow user to override the builtin attributes of subspaces. But
7507 only allow the attributes to be changed once! */
7508 if (ssd && SUBSPACE_DEFINED (ssd))
7509 {
7510 subseg_set (ssd->ssd_seg, ssd->ssd_subseg);
7511 current_subspace = ssd;
7512 if (!is_end_of_statement ())
7513 as_warn (_("Parameters of an existing subspace can\'t be modified"));
7514 demand_empty_rest_of_line ();
7515 return;
7516 }
7517 else
7518 {
7519 /* A new subspace. Load default values if it matches one of
7520 the builtin subspaces. */
7521 i = 0;
7522 while (pa_def_subspaces[i].name)
7523 {
7524 if (strcasecmp (pa_def_subspaces[i].name, ss_name) == 0)
7525 {
7526 loadable = pa_def_subspaces[i].loadable;
351e2b5a 7527 comdat = pa_def_subspaces[i].comdat;
252b5132
RH		 7528 common = pa_def_subspaces[i].common;
7529 dup_common = pa_def_subspaces[i].dup_common;
7530 code_only = pa_def_subspaces[i].code_only;
7531 zero = pa_def_subspaces[i].zero;
7532 space_index = pa_def_subspaces[i].space_index;
7533 alignment = pa_def_subspaces[i].alignment;
7534 quadrant = pa_def_subspaces[i].quadrant;
7535 access = pa_def_subspaces[i].access;
7536 sort = pa_def_subspaces[i].sort;
252b5132
RH		 7537 break;
7538 }
7539 i++;
7540 }
7541 }
7542
7543 /* We should be working with a new subspace now. Fill in
7544 any information as specified by the user. */
7545 if (!is_end_of_statement ())
7546 {
7547 input_line_pointer++;
7548 while (!is_end_of_statement ())
7549 {
7550 name = input_line_pointer;
7551 c = get_symbol_end ();
7552 if ((strncasecmp (name, "quad", 4) == 0))
7553 {
7554 *input_line_pointer = c;
7555 input_line_pointer++;
7556 quadrant = get_absolute_expression ();
7557 }
7558 else if ((strncasecmp (name, "align", 5) == 0))
7559 {
7560 *input_line_pointer = c;
7561 input_line_pointer++;
7562 alignment = get_absolute_expression ();
b8fc22bc 7563 if (exact_log2 (alignment) == -1)
252b5132
RH		 7564 {
7565 as_bad (_("Alignment must be a power of 2"));
7566 alignment = 1;
7567 }
7568 }
7569 else if ((strncasecmp (name, "access", 6) == 0))
7570 {
7571 *input_line_pointer = c;
7572 input_line_pointer++;
7573 access = get_absolute_expression ();
7574 }
7575 else if ((strncasecmp (name, "sort", 4) == 0))
7576 {
7577 *input_line_pointer = c;
7578 input_line_pointer++;
7579 sort = get_absolute_expression ();
7580 }
7581 else if ((strncasecmp (name, "code_only", 9) == 0))
7582 {
7583 *input_line_pointer = c;
7584 code_only = 1;
7585 }
7586 else if ((strncasecmp (name, "unloadable", 10) == 0))
7587 {
7588 *input_line_pointer = c;
7589 loadable = 0;
7590 }
351e2b5a
DA		 7591 else if ((strncasecmp (name, "comdat", 6) == 0))
7592 {
7593 *input_line_pointer = c;
7594 comdat = 1;
7595 }
252b5132
RH		 7596 else if ((strncasecmp (name, "common", 6) == 0))
7597 {
7598 *input_line_pointer = c;
7599 common = 1;
7600 }
7601 else if ((strncasecmp (name, "dup_comm", 8) == 0))
7602 {
7603 *input_line_pointer = c;
7604 dup_common = 1;
7605 }
7606 else if ((strncasecmp (name, "zero", 4) == 0))
7607 {
7608 *input_line_pointer = c;
7609 zero = 1;
7610 }
7611 else if ((strncasecmp (name, "first", 5) == 0))
7612 as_bad (_("FIRST not supported as a .SUBSPACE argument"));
7613 else
7614 as_bad (_("Invalid .SUBSPACE argument"));
7615 if (!is_end_of_statement ())
7616 input_line_pointer++;
7617 }
7618 }
7619
7620 /* Compute a reasonable set of BFD flags based on the information
7621 in the .subspace directive. */
7622 applicable = bfd_applicable_section_flags (stdoutput);
7623 flags = 0;
7624 if (loadable)
7625 flags |= (SEC_ALLOC | SEC_LOAD);
7626 if (code_only)
7627 flags |= SEC_CODE;
351e2b5a
DA		 7628
7629 /* These flags are used to implement various flavors of initialized
7630 common. The SOM linker discards duplicate subspaces when they
7631 have the same "key" symbol name. This support is more like
7632 GNU linkonce than BFD common. Further, pc-relative relocations
7633 are converted to section relative relocations in BFD common
7634 sections. This complicates the handling of relocations in
7635 common sections containing text and isn't currently supported
7636 correctly in the SOM BFD backend. */
7637 if (comdat || common || dup_common)
7638 flags |= SEC_LINK_ONCE;
252b5132
RH		 7639
7640 flags |= SEC_RELOC | SEC_HAS_CONTENTS;
7641
7642 /* This is a zero-filled subspace (eg BSS). */
7643 if (zero)
7644 flags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
7645
7646 applicable &= flags;
7647
7648 /* If this is an existing subspace, then we want to use the
7649 segment already associated with the subspace.
7650
7651 FIXME NOW! ELF BFD doesn't appear to be ready to deal with
7652 lots of sections. It might be a problem in the PA ELF
7653 code, I do not know yet. For now avoid creating anything
7654 but the "standard" sections for ELF. */
7655 if (create_new)
7656 section = subseg_force_new (ss_name, 0);
7657 else if (ssd)
7658 section = ssd->ssd_seg;
252b5132
RH		 7659 else
7660 section = subseg_new (ss_name, 0);
7661
7662 if (zero)
7663 seg_info (section)->bss = 1;
7664
7665 /* Now set the flags. */
7666 bfd_set_section_flags (stdoutput, section, applicable);
7667
7668 /* Record any alignment request for this section. */
b8fc22bc 7669 record_alignment (section, exact_log2 (alignment));
252b5132
RH		 7670
7671 /* Set the starting offset for this section. */
7672 bfd_set_section_vma (stdoutput, section,
7673 pa_subspace_start (space, quadrant));
7674
7675 /* Now that all the flags are set, update an existing subspace,
7676 or create a new one. */
7677 if (ssd)
7678
7679 current_subspace = update_subspace (space, ss_name, loadable,
351e2b5a
DA		 7680 code_only, comdat, common,
7681 dup_common, sort, zero, access,
7682 space_index, alignment, quadrant,
252b5132
RH		 7683 section);
7684 else
7685 current_subspace = create_new_subspace (space, ss_name, loadable,
351e2b5a 7686 code_only, comdat, common,
252b5132
RH		 7687 dup_common, zero, sort,
7688 access, space_index,
351e2b5a 7689 alignment, quadrant, section);
252b5132
RH		 7690
7691 demand_empty_rest_of_line ();
7692 current_subspace->ssd_seg = section;
7693 subseg_set (current_subspace->ssd_seg, current_subspace->ssd_subseg);
7694 }
7695 SUBSPACE_DEFINED (current_subspace) = 1;
7696}
7697
252b5132
RH		 7698/* Create default space and subspace dictionaries. */
7699
7700static void
7701pa_spaces_begin ()
7702{
7703 int i;
7704
7705 space_dict_root = NULL;
7706 space_dict_last = NULL;
7707
7708 i = 0;
7709 while (pa_def_spaces[i].name)
7710 {
7711 char *name;
7712
7713 /* Pick the right name to use for the new section. */
49863f82 7714 name = pa_def_spaces[i].name;
252b5132
RH		 7715
7716 pa_def_spaces[i].segment = subseg_new (name, 0);
7717 create_new_space (pa_def_spaces[i].name, pa_def_spaces[i].spnum,
7718 pa_def_spaces[i].loadable, pa_def_spaces[i].defined,
7719 pa_def_spaces[i].private, pa_def_spaces[i].sort,
7720 pa_def_spaces[i].segment, 0);
7721 i++;
7722 }
7723
7724 i = 0;
7725 while (pa_def_subspaces[i].name)
7726 {
7727 char *name;
7728 int applicable, subsegment;
7729 asection *segment = NULL;
7730 sd_chain_struct *space;
7731
7732 /* Pick the right name for the new section and pick the right
7733 subsegment number. */
49863f82
JL		 7734 name = pa_def_subspaces[i].name;
7735 subsegment = 0;
252b5132
RH		 7736
7737 /* Create the new section. */
7738 segment = subseg_new (name, subsegment);
7739
252b5132
RH		 7740 /* For SOM we want to replace the standard .text, .data, and .bss
7741 sections with our own. We also want to set BFD flags for
7742 all the built-in subspaces. */
49863f82 7743 if (!strcmp (pa_def_subspaces[i].name, "$CODE$"))
252b5132
RH		 7744 {
7745 text_section = segment;
7746 applicable = bfd_applicable_section_flags (stdoutput);
7747 bfd_set_section_flags (stdoutput, segment,
7748 applicable & (SEC_ALLOC | SEC_LOAD
7749 | SEC_RELOC | SEC_CODE
7750 | SEC_READONLY
7751 | SEC_HAS_CONTENTS));
7752 }
49863f82 7753 else if (!strcmp (pa_def_subspaces[i].name, "$DATA$"))
252b5132
RH		 7754 {
7755 data_section = segment;
7756 applicable = bfd_applicable_section_flags (stdoutput);
7757 bfd_set_section_flags (stdoutput, segment,
7758 applicable & (SEC_ALLOC | SEC_LOAD
7759 | SEC_RELOC
7760 | SEC_HAS_CONTENTS));
7761
252b5132 7762 }
49863f82 7763 else if (!strcmp (pa_def_subspaces[i].name, "$BSS$"))
252b5132
RH		 7764 {
7765 bss_section = segment;
7766 applicable = bfd_applicable_section_flags (stdoutput);
7767 bfd_set_section_flags (stdoutput, segment,
7768 applicable & SEC_ALLOC);
7769 }
49863f82 7770 else if (!strcmp (pa_def_subspaces[i].name, "$LIT$"))
252b5132
RH		 7771 {
7772 applicable = bfd_applicable_section_flags (stdoutput);
7773 bfd_set_section_flags (stdoutput, segment,
7774 applicable & (SEC_ALLOC | SEC_LOAD
7775 | SEC_RELOC
7776 | SEC_READONLY
7777 | SEC_HAS_CONTENTS));
7778 }
49863f82 7779 else if (!strcmp (pa_def_subspaces[i].name, "$MILLICODE$"))
252b5132
RH		 7780 {
7781 applicable = bfd_applicable_section_flags (stdoutput);
7782 bfd_set_section_flags (stdoutput, segment,
7783 applicable & (SEC_ALLOC | SEC_LOAD
7784 | SEC_RELOC
7785 | SEC_READONLY
7786 | SEC_HAS_CONTENTS));
7787 }
49863f82 7788 else if (!strcmp (pa_def_subspaces[i].name, "$UNWIND$"))
252b5132
RH		 7789 {
7790 applicable = bfd_applicable_section_flags (stdoutput);
7791 bfd_set_section_flags (stdoutput, segment,
7792 applicable & (SEC_ALLOC | SEC_LOAD
7793 | SEC_RELOC
7794 | SEC_READONLY
7795 | SEC_HAS_CONTENTS));
7796 }
7797
7798 /* Find the space associated with this subspace. */
7799 space = pa_segment_to_space (pa_def_spaces[pa_def_subspaces[i].
7800 def_space_index].segment);
7801 if (space == NULL)
7802 {
7803 as_fatal (_("Internal error: Unable to find containing space for %s."),
7804 pa_def_subspaces[i].name);
7805 }
7806
7807 create_new_subspace (space, name,
7808 pa_def_subspaces[i].loadable,
7809 pa_def_subspaces[i].code_only,
351e2b5a 7810 pa_def_subspaces[i].comdat,
252b5132
RH		 7811 pa_def_subspaces[i].common,
7812 pa_def_subspaces[i].dup_common,
7813 pa_def_subspaces[i].zero,
7814 pa_def_subspaces[i].sort,
7815 pa_def_subspaces[i].access,
7816 pa_def_subspaces[i].space_index,
7817 pa_def_subspaces[i].alignment,
7818 pa_def_subspaces[i].quadrant,
7819 segment);
7820 i++;
7821 }
7822}
7823
252b5132
RH		 7824/* Create a new space NAME, with the appropriate flags as defined
7825 by the given parameters. */
7826
7827static sd_chain_struct *
7828create_new_space (name, spnum, loadable, defined, private,
7829 sort, seg, user_defined)
7830 char *name;
7831 int spnum;
b8fc22bc 7832 int loadable ATTRIBUTE_UNUSED;
252b5132
RH		 7833 int defined;
7834 int private;
7835 int sort;
7836 asection *seg;
7837 int user_defined;
7838{
7839 sd_chain_struct *chain_entry;
7840
7841 chain_entry = (sd_chain_struct *) xmalloc (sizeof (sd_chain_struct));
7842 if (!chain_entry)
7843 as_fatal (_("Out of memory: could not allocate new space chain entry: %s\n"),
7844 name);
7845
7846 SPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7847 strcpy (SPACE_NAME (chain_entry), name);
7848 SPACE_DEFINED (chain_entry) = defined;
7849 SPACE_USER_DEFINED (chain_entry) = user_defined;
7850 SPACE_SPNUM (chain_entry) = spnum;
7851
7852 chain_entry->sd_seg = seg;
7853 chain_entry->sd_last_subseg = -1;
7854 chain_entry->sd_subspaces = NULL;
7855 chain_entry->sd_next = NULL;
7856
7857 /* Find spot for the new space based on its sort key. */
7858 if (!space_dict_last)
7859 space_dict_last = chain_entry;
7860
7861 if (space_dict_root == NULL)
7862 space_dict_root = chain_entry;
7863 else
7864 {
7865 sd_chain_struct *chain_pointer;
7866 sd_chain_struct *prev_chain_pointer;
7867
7868 chain_pointer = space_dict_root;
7869 prev_chain_pointer = NULL;
7870
7871 while (chain_pointer)
7872 {
7873 prev_chain_pointer = chain_pointer;
7874 chain_pointer = chain_pointer->sd_next;
7875 }
7876
7877 /* At this point we've found the correct place to add the new
7878 entry. So add it and update the linked lists as appropriate. */
7879 if (prev_chain_pointer)
7880 {
7881 chain_entry->sd_next = chain_pointer;
7882 prev_chain_pointer->sd_next = chain_entry;
7883 }
7884 else
7885 {
7886 space_dict_root = chain_entry;
7887 chain_entry->sd_next = chain_pointer;
7888 }
7889
7890 if (chain_entry->sd_next == NULL)
7891 space_dict_last = chain_entry;
7892 }
7893
7894 /* This is here to catch predefined spaces which do not get
7895 modified by the user's input. Another call is found at
7896 the bottom of pa_parse_space_stmt to handle cases where
7897 the user modifies a predefined space. */
7898#ifdef obj_set_section_attributes
7899 obj_set_section_attributes (seg, defined, private, sort, spnum);
7900#endif
7901
7902 return chain_entry;
7903}
7904
7905/* Create a new subspace NAME, with the appropriate flags as defined
7906 by the given parameters.
7907
7908 Add the new subspace to the subspace dictionary chain in numerical
7909 order as defined by the SORT entries. */
7910
7911static ssd_chain_struct *
351e2b5a 7912create_new_subspace (space, name, loadable, code_only, comdat, common,
252b5132
RH		 7913 dup_common, is_zero, sort, access, space_index,
7914 alignment, quadrant, seg)
7915 sd_chain_struct *space;
7916 char *name;
b8fc22bc
DA		 7917 int loadable ATTRIBUTE_UNUSED;
7918 int code_only ATTRIBUTE_UNUSED;
7919 int comdat, common, dup_common;
7920 int is_zero ATTRIBUTE_UNUSED;
252b5132
RH		 7921 int sort;
7922 int access;
b8fc22bc
DA		 7923 int space_index ATTRIBUTE_UNUSED;
7924 int alignment ATTRIBUTE_UNUSED;
252b5132
RH		 7925 int quadrant;
7926 asection *seg;
7927{
7928 ssd_chain_struct *chain_entry;
7929
7930 chain_entry = (ssd_chain_struct *) xmalloc (sizeof (ssd_chain_struct));
7931 if (!chain_entry)
7932 as_fatal (_("Out of memory: could not allocate new subspace chain entry: %s\n"), name);
7933
7934 SUBSPACE_NAME (chain_entry) = (char *) xmalloc (strlen (name) + 1);
7935 strcpy (SUBSPACE_NAME (chain_entry), name);
7936
7937 /* Initialize subspace_defined. When we hit a .subspace directive
7938 we'll set it to 1 which "locks-in" the subspace attributes. */
7939 SUBSPACE_DEFINED (chain_entry) = 0;
7940
49863f82 7941 chain_entry->ssd_subseg = 0;
252b5132
RH		 7942 chain_entry->ssd_seg = seg;
7943 chain_entry->ssd_next = NULL;
7944
7945 /* Find spot for the new subspace based on its sort key. */
7946 if (space->sd_subspaces == NULL)
7947 space->sd_subspaces = chain_entry;
7948 else
7949 {
7950 ssd_chain_struct *chain_pointer;
7951 ssd_chain_struct *prev_chain_pointer;
7952
7953 chain_pointer = space->sd_subspaces;
7954 prev_chain_pointer = NULL;
7955
7956 while (chain_pointer)
7957 {
7958 prev_chain_pointer = chain_pointer;
7959 chain_pointer = chain_pointer->ssd_next;
7960 }
7961
7962 /* Now we have somewhere to put the new entry. Insert it and update
7963 the links. */
7964 if (prev_chain_pointer)
7965 {
7966 chain_entry->ssd_next = chain_pointer;
7967 prev_chain_pointer->ssd_next = chain_entry;
7968 }
7969 else
7970 {
7971 space->sd_subspaces = chain_entry;
7972 chain_entry->ssd_next = chain_pointer;
7973 }
7974 }
7975
7976#ifdef obj_set_subsection_attributes
351e2b5a
DA		 7977 obj_set_subsection_attributes (seg, space->sd_seg, access, sort,
7978 quadrant, comdat, common, dup_common);
252b5132
RH		 7979#endif
7980
7981 return chain_entry;
7982}
7983
7984/* Update the information for the given subspace based upon the
7985 various arguments. Return the modified subspace chain entry. */
7986
7987static ssd_chain_struct *
351e2b5a
DA		 7988update_subspace (space, name, loadable, code_only, comdat, common, dup_common,
7989 sort, zero, access, space_index, alignment, quadrant, section)
252b5132
RH		 7990 sd_chain_struct *space;
7991 char *name;
e12904d2
DA		 7992 int loadable ATTRIBUTE_UNUSED;
7993 int code_only ATTRIBUTE_UNUSED;
351e2b5a 7994 int comdat;
252b5132
RH		 7995 int common;
7996 int dup_common;
e12904d2 7997 int zero ATTRIBUTE_UNUSED;
252b5132
RH		 7998 int sort;
7999 int access;
e12904d2
DA		 8000 int space_index ATTRIBUTE_UNUSED;
8001 int alignment ATTRIBUTE_UNUSED;
252b5132
RH		 8002 int quadrant;
8003 asection *section;
8004{
8005 ssd_chain_struct *chain_entry;
8006
8007 chain_entry = is_defined_subspace (name);
8008
8009#ifdef obj_set_subsection_attributes
351e2b5a
DA		 8010 obj_set_subsection_attributes (section, space->sd_seg, access, sort,
8011 quadrant, comdat, common, dup_common);
252b5132
RH		 8012#endif
8013
8014 return chain_entry;
8015}
8016
8017/* Return the space chain entry for the space with the name NAME or
8018 NULL if no such space exists. */
8019
8020static sd_chain_struct *
8021is_defined_space (name)
8022 char *name;
8023{
8024 sd_chain_struct *chain_pointer;
8025
8026 for (chain_pointer = space_dict_root;
8027 chain_pointer;
8028 chain_pointer = chain_pointer->sd_next)
8029 {
8030 if (strcmp (SPACE_NAME (chain_pointer), name) == 0)
8031 return chain_pointer;
8032 }
8033
8034 /* No mapping from segment to space was found. Return NULL. */
8035 return NULL;
8036}
8037
8038/* Find and return the space associated with the given seg. If no mapping
8039 from the given seg to a space is found, then return NULL.
8040
8041 Unlike subspaces, the number of spaces is not expected to grow much,
8042 so a linear exhaustive search is OK here. */
8043
8044static sd_chain_struct *
8045pa_segment_to_space (seg)
8046 asection *seg;
8047{
8048 sd_chain_struct *space_chain;
8049
8050 /* Walk through each space looking for the correct mapping. */
8051 for (space_chain = space_dict_root;
8052 space_chain;
8053 space_chain = space_chain->sd_next)
8054 {
8055 if (space_chain->sd_seg == seg)
8056 return space_chain;
8057 }
8058
8059 /* Mapping was not found. Return NULL. */
8060 return NULL;
8061}
8062
e12904d2
DA		 8063/* Return the first space chain entry for the subspace with the name
8064 NAME or NULL if no such subspace exists.
252b5132 8065
e12904d2
DA		 8066 When there are multiple subspaces with the same name, switching to
8067 the first (i.e., default) subspace is preferable in most situations.
8068 For example, it wouldn't be desirable to merge COMDAT data with non
8069 COMDAT data.
8070
252b5132
RH		 8071 Uses a linear search through all the spaces and subspaces, this may
8072 not be appropriate if we ever being placing each function in its
8073 own subspace. */
8074
8075static ssd_chain_struct *
8076is_defined_subspace (name)
8077 char *name;
8078{
8079 sd_chain_struct *space_chain;
8080 ssd_chain_struct *subspace_chain;
8081
8082 /* Walk through each space. */
8083 for (space_chain = space_dict_root;
8084 space_chain;
8085 space_chain = space_chain->sd_next)
8086 {
8087 /* Walk through each subspace looking for a name which matches. */
8088 for (subspace_chain = space_chain->sd_subspaces;
8089 subspace_chain;
8090 subspace_chain = subspace_chain->ssd_next)
8091 if (strcmp (SUBSPACE_NAME (subspace_chain), name) == 0)
8092 return subspace_chain;
8093 }
8094
8095 /* Subspace wasn't found. Return NULL. */
8096 return NULL;
8097}
8098
8099/* Find and return the subspace associated with the given seg. If no
8100 mapping from the given seg to a subspace is found, then return NULL.
8101
8102 If we ever put each procedure/function within its own subspace
8103 (to make life easier on the compiler and linker), then this will have
8104 to become more efficient. */
8105
8106static ssd_chain_struct *
8107pa_subsegment_to_subspace (seg, subseg)
8108 asection *seg;
8109 subsegT subseg;
8110{
8111 sd_chain_struct *space_chain;
8112 ssd_chain_struct *subspace_chain;
8113
8114 /* Walk through each space. */
8115 for (space_chain = space_dict_root;
8116 space_chain;
8117 space_chain = space_chain->sd_next)
8118 {
8119 if (space_chain->sd_seg == seg)
8120 {
8121 /* Walk through each subspace within each space looking for
8122 the correct mapping. */
8123 for (subspace_chain = space_chain->sd_subspaces;
8124 subspace_chain;
8125 subspace_chain = subspace_chain->ssd_next)
8126 if (subspace_chain->ssd_subseg == (int) subseg)
8127 return subspace_chain;
8128 }
8129 }
8130
8131 /* No mapping from subsegment to subspace found. Return NULL. */
8132 return NULL;
8133}
8134
8135/* Given a number, try and find a space with the name number.
8136
8137 Return a pointer to a space dictionary chain entry for the space
8138 that was found or NULL on failure. */
8139
8140static sd_chain_struct *
8141pa_find_space_by_number (number)
8142 int number;
8143{
8144 sd_chain_struct *space_chain;
8145
8146 for (space_chain = space_dict_root;
8147 space_chain;
8148 space_chain = space_chain->sd_next)
8149 {
8150 if (SPACE_SPNUM (space_chain) == (unsigned int) number)
8151 return space_chain;
8152 }
8153
8154 /* No appropriate space found. Return NULL. */
8155 return NULL;
8156}
8157
8158/* Return the starting address for the given subspace. If the starting
8159 address is unknown then return zero. */
8160
8161static unsigned int
8162pa_subspace_start (space, quadrant)
8163 sd_chain_struct *space;
8164 int quadrant;
8165{
252b5132
RH		 8166 /* FIXME. Assumes everyone puts read/write data at 0x4000000, this
8167 is not correct for the PA OSF1 port. */
8168 if ((strcmp (SPACE_NAME (space), "$PRIVATE$") == 0) && quadrant == 1)
8169 return 0x40000000;
8170 else if (space->sd_seg == data_section && quadrant == 1)
8171 return 0x40000000;
8172 else
8173 return 0;
252b5132
RH		 8174 return 0;
8175}
49863f82 8176#endif
252b5132
RH		 8177
8178/* Helper function for pa_stringer. Used to find the end of
8179 a string. */
8180
8181static unsigned int
8182pa_stringer_aux (s)
8183 char *s;
8184{
8185 unsigned int c = *s & CHAR_MASK;
8186
252b5132
RH		 8187 switch (c)
8188 {
8189 case '\"':
8190 c = NOT_A_CHAR;
8191 break;
8192 default:
8193 break;
8194 }
8195 return c;
8196}
8197
8198/* Handle a .STRING type pseudo-op. */
8199
8200static void
8201pa_stringer (append_zero)
8202 int append_zero;
8203{
8204 char *s, num_buf[4];
8205 unsigned int c;
8206 int i;
8207
8208 /* Preprocess the string to handle PA-specific escape sequences.
ad1079af 8209 For example, \xDD where DD is a hexadecimal number should be
252b5132
RH		 8210 changed to \OOO where OOO is an octal number. */
8211
ad1079af
AM		 8212#ifdef OBJ_SOM
8213 /* We must have a valid space and subspace. */
8214 pa_check_current_space_and_subspace ();
8215#endif
8216
252b5132
RH		 8217 /* Skip the opening quote. */
8218 s = input_line_pointer + 1;
8219
8220 while (is_a_char (c = pa_stringer_aux (s++)))
8221 {
8222 if (c == '\\')
8223 {
8224 c = *s;
8225 switch (c)
8226 {
8227 /* Handle \x<num>. */
8228 case 'x':
8229 {
8230 unsigned int number;
8231 int num_digit;
8232 char dg;
8233 char *s_start = s;
8234
ad1079af 8235 /* Get past the 'x'. */
252b5132
RH		 8236 s++;
8237 for (num_digit = 0, number = 0, dg = *s;
8238 num_digit < 2
3882b010 8239 && (ISDIGIT (dg) || (dg >= 'a' && dg <= 'f')
252b5132
RH		 8240 || (dg >= 'A' && dg <= 'F'));
8241 num_digit++)
8242 {
3882b010 8243 if (ISDIGIT (dg))
252b5132
RH		 8244 number = number * 16 + dg - '0';
8245 else if (dg >= 'a' && dg <= 'f')
8246 number = number * 16 + dg - 'a' + 10;
8247 else
8248 number = number * 16 + dg - 'A' + 10;
8249
8250 s++;
8251 dg = *s;
8252 }
8253 if (num_digit > 0)
8254 {
8255 switch (num_digit)
8256 {
8257 case 1:
8258 sprintf (num_buf, "%02o", number);
8259 break;
8260 case 2:
8261 sprintf (num_buf, "%03o", number);
8262 break;
8263 }
8264 for (i = 0; i <= num_digit; i++)
8265 s_start[i] = num_buf[i];
8266 }
8267 break;
8268 }
8269 /* This might be a "\"", skip over the escaped char. */
8270 default:
8271 s++;
8272 break;
8273 }
8274 }
8275 }
8276 stringer (append_zero);
8277 pa_undefine_label ();
8278}
8279
8280/* Handle a .VERSION pseudo-op. */
8281
8282static void
8283pa_version (unused)
3f9b03b5 8284 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 8285{
8286 obj_version (0);
8287 pa_undefine_label ();
8288}
8289
8290#ifdef OBJ_SOM
8291
8292/* Handle a .COMPILER pseudo-op. */
8293
8294static void
8295pa_compiler (unused)
3f9b03b5 8296 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 8297{
8298 obj_som_compiler (0);
8299 pa_undefine_label ();
8300}
8301
8302#endif
8303
8304/* Handle a .COPYRIGHT pseudo-op. */
8305
8306static void
8307pa_copyright (unused)
3f9b03b5 8308 int unused ATTRIBUTE_UNUSED;
252b5132
RH		 8309{
8310 obj_copyright (0);
8311 pa_undefine_label ();
8312}
8313
8314/* Just like a normal cons, but when finished we have to undefine
8315 the latest space label. */
8316
8317static void
8318pa_cons (nbytes)
8319 int nbytes;
8320{
8321 cons (nbytes);
8322 pa_undefine_label ();
8323}
8324
252b5132
RH		 8325/* Like float_cons, but we need to undefine our label. */
8326
8327static void
8328pa_float_cons (float_type)
8329 int float_type;
8330{
8331 float_cons (float_type);
8332 pa_undefine_label ();
8333}
8334
8335/* Like s_fill, but delete our label when finished. */
8336
8337static void
8338pa_fill (unused)
3f9b03b5 8339 int unused ATTRIBUTE_UNUSED;
252b5132 8340{
49863f82 8341#ifdef OBJ_SOM
252b5132
RH		 8342 /* We must have a valid space and subspace. */
8343 pa_check_current_space_and_subspace ();
49863f82 8344#endif
252b5132
RH		 8345
8346 s_fill (0);
8347 pa_undefine_label ();
8348}
8349
8350/* Like lcomm, but delete our label when finished. */
8351
8352static void
8353pa_lcomm (needs_align)
8354 int needs_align;
8355{
49863f82 8356#ifdef OBJ_SOM
252b5132
RH		 8357 /* We must have a valid space and subspace. */
8358 pa_check_current_space_and_subspace ();
49863f82 8359#endif
252b5132
RH		 8360
8361 s_lcomm (needs_align);
8362 pa_undefine_label ();
8363}
8364
8365/* Like lsym, but delete our label when finished. */
8366
8367static void
8368pa_lsym (unused)
3f9b03b5 8369 int unused ATTRIBUTE_UNUSED;
252b5132 8370{
49863f82 8371#ifdef OBJ_SOM
252b5132
RH		 8372 /* We must have a valid space and subspace. */
8373 pa_check_current_space_and_subspace ();
49863f82 8374#endif
252b5132
RH		 8375
8376 s_lsym (0);
8377 pa_undefine_label ();
8378}
8379
252b5132
RH		 8380/* On the PA relocations which involve function symbols must not be
8381 adjusted. This so that the linker can know when/how to create argument
8382 relocation stubs for indirect calls and calls to static functions.
8383
8384 "T" field selectors create DLT relative fixups for accessing
8385 globals and statics in PIC code; each DLT relative fixup creates
8386 an entry in the DLT table. The entries contain the address of
8387 the final target (eg accessing "foo" would create a DLT entry
8388 with the address of "foo").
8389
8390 Unfortunately, the HP linker doesn't take into account any addend
8391 when generating the DLT; so accessing $LIT$+8 puts the address of
8392 $LIT$ into the DLT rather than the address of $LIT$+8.
8393
8394 The end result is we can't perform relocation symbol reductions for
8395 any fixup which creates entries in the DLT (eg they use "T" field
8396 selectors).
8397
8398 Reject reductions involving symbols with external scope; such
d53d2751 8399 reductions make life a living hell for object file editors.
252b5132
RH		 8400
8401 FIXME. Also reject R_HPPA relocations which are 32bits wide in
8402 the code space. The SOM BFD backend doesn't know how to pull the
8403 right bits out of an instruction. */
8404
8405int
8406hppa_fix_adjustable (fixp)
8407 fixS *fixp;
8408{
2337eb33 8409#ifdef OBJ_ELF
3dcfe21d 8410 reloc_type code;
2337eb33 8411#endif
252b5132
RH		 8412 struct hppa_fix_struct *hppa_fix;
8413
8414 hppa_fix = (struct hppa_fix_struct *) fixp->tc_fix_data;
8415
8416#ifdef OBJ_SOM
2337eb33
DA		 8417 /* Reject reductions of symbols in 32bit relocs unless they
8418 are fake labels. */
8419 if (fixp->fx_r_type == R_HPPA
8420 && hppa_fix->fx_r_format == 32
8421 && strncmp (S_GET_NAME (fixp->fx_addsy),
8422 FAKE_LABEL_NAME,
8423 strlen (FAKE_LABEL_NAME)))
252b5132 8424 return 0;
1cd1c99b 8425#endif
252b5132 8426
904a31bf 8427#ifdef OBJ_ELF
3dcfe21d
AM		 8428 /* LR/RR selectors are implicitly used for a number of different relocation
8429 types. We must ensure that none of these types are adjusted (see below)
8430 even if they occur with a different selector. */
8431 code = elf_hppa_reloc_final_type (stdoutput, fixp->fx_r_type,
8432 hppa_fix->fx_r_format,
8433 hppa_fix->fx_r_field);
8434
8435 switch (code)
8436 {
8437 /* Relocation types which use e_lrsel. */
8438 case R_PARISC_DIR21L:
3dcfe21d
AM		 8439 case R_PARISC_DLTREL21L:
8440 case R_PARISC_DPREL21L:
3dcfe21d
AM		 8441 case R_PARISC_PLTOFF21L:
8442
8443 /* Relocation types which use e_rrsel. */
8444 case R_PARISC_DIR14R:
8445 case R_PARISC_DIR14DR:
8446 case R_PARISC_DIR14WR:
8447 case R_PARISC_DIR17R:
3dcfe21d
AM		 8448 case R_PARISC_DLTREL14R:
8449 case R_PARISC_DLTREL14DR:
8450 case R_PARISC_DLTREL14WR:
8451 case R_PARISC_DPREL14R:
8452 case R_PARISC_DPREL14DR:
8453 case R_PARISC_DPREL14WR:
40d74fb1
JL		 8454 case R_PARISC_PLTOFF14R:
8455 case R_PARISC_PLTOFF14DR:
8456 case R_PARISC_PLTOFF14WR:
3dcfe21d
AM		 8457
8458 /* Other types that we reject for reduction. */
8459 case R_PARISC_GNU_VTENTRY:
8460 case R_PARISC_GNU_VTINHERIT:
8461 return 0;
8462 default:
8463 break;
8464 }
5506e1a5 8465#endif
959ee541 8466
252b5132 8467 /* Reject reductions of symbols in sym1-sym2 expressions when
d53d2751 8468 the fixup will occur in a CODE subspace.
252b5132
RH		 8469
8470 XXX FIXME: Long term we probably want to reject all of these;
8471 for example reducing in the debug section would lose if we ever
8472 supported using the optimizing hp linker. */
8473 if (fixp->fx_addsy
8474 && fixp->fx_subsy
8475 && (hppa_fix->segment->flags & SEC_CODE))
a161fe53 8476 return 0;
252b5132
RH		 8477
8478 /* We can't adjust any relocs that use LR% and RR% field selectors.
1cd1c99b
AM		 8479
8480 If a symbol is reduced to a section symbol, the assembler will
8481 adjust the addend unless the symbol happens to reside right at
8482 the start of the section. Additionally, the linker has no choice
8483 but to manipulate the addends when coalescing input sections for
8484 "ld -r". Since an LR% field selector is defined to round the
8485 addend, we can't change the addend without risking that a LR% and
8486 it's corresponding (possible multiple) RR% field will no longer
8487 sum to the right value.
8488
8489 eg. Suppose we have
8490 . ldil LR%foo+0,%r21
8491 . ldw RR%foo+0(%r21),%r26
25a8b250
AM		 8492 . ldw RR%foo+4(%r21),%r25
8493
8494 If foo is at address 4092 (decimal) in section `sect', then after
8495 reducing to the section symbol we get
8496 . LR%sect+4092 == (L%sect)+0
8497 . RR%sect+4092 == (R%sect)+4092
8498 . RR%sect+4096 == (R%sect)-4096
8499 and the last address loses because rounding the addend to 8k
0234cb7c 8500 multiples takes us up to 8192 with an offset of -4096.
25a8b250
AM		 8501
8502 In cases where the LR% expression is identical to the RR% one we
8503 will never have a problem, but is so happens that gcc rounds
8504 addends involved in LR% field selectors to work around a HP
8505 linker bug. ie. We often have addresses like the last case
1cd1c99b
AM		 8506 above where the LR% expression is offset from the RR% one. */
8507
252b5132
RH		 8508 if (hppa_fix->fx_r_field == e_lrsel
8509 || hppa_fix->fx_r_field == e_rrsel
8510 || hppa_fix->fx_r_field == e_nlrsel)
8511 return 0;
252b5132
RH		 8512
8513 /* Reject reductions of symbols in DLT relative relocs,
8514 relocations with plabels. */
8515 if (hppa_fix->fx_r_field == e_tsel
8516 || hppa_fix->fx_r_field == e_ltsel
8517 || hppa_fix->fx_r_field == e_rtsel
8518 || hppa_fix->fx_r_field == e_psel
8519 || hppa_fix->fx_r_field == e_rpsel
8520 || hppa_fix->fx_r_field == e_lpsel)
8521 return 0;
8522
252b5132
RH		 8523 /* Reject absolute calls (jumps). */
8524 if (hppa_fix->fx_r_type == R_HPPA_ABS_CALL)
8525 return 0;
8526
8527 /* Reject reductions of function symbols. */
5506e1a5
AM		 8528 if (fixp->fx_addsy != 0 && S_IS_FUNCTION (fixp->fx_addsy))
8529 return 0;
252b5132 8530
5506e1a5 8531 return 1;
252b5132
RH		 8532}
8533
8534/* Return nonzero if the fixup in FIXP will require a relocation,
8535 even it if appears that the fixup could be completely handled
8536 within GAS. */
8537
8538int
8539hppa_force_relocation (fixp)
ad1079af 8540 struct fix *fixp;
252b5132
RH		 8541{
8542 struct hppa_fix_struct *hppa_fixp;
252b5132
RH		 8543
8544 hppa_fixp = (struct hppa_fix_struct *) fixp->tc_fix_data;
8545#ifdef OBJ_SOM
ad1079af
AM		 8546 if (fixp->fx_r_type == (int) R_HPPA_ENTRY
8547 || fixp->fx_r_type == (int) R_HPPA_EXIT
8548 || fixp->fx_r_type == (int) R_HPPA_BEGIN_BRTAB
8549 || fixp->fx_r_type == (int) R_HPPA_END_BRTAB
8550 || fixp->fx_r_type == (int) R_HPPA_BEGIN_TRY
8551 || fixp->fx_r_type == (int) R_HPPA_END_TRY
252b5132
RH		 8552 || (fixp->fx_addsy != NULL && fixp->fx_subsy != NULL
8553 && (hppa_fixp->segment->flags & SEC_CODE) != 0))
8554 return 1;
8555#endif
904a31bf
AM		 8556#ifdef OBJ_ELF
8557 if (fixp->fx_r_type == (int) R_PARISC_GNU_VTINHERIT
8558 || fixp->fx_r_type == (int) R_PARISC_GNU_VTENTRY)
8559 return 1;
5506e1a5
AM		 8560#endif
8561
8562 assert (fixp->fx_addsy != NULL);
252b5132 8563
9e754211
AM		 8564 /* Ensure we emit a relocation for global symbols so that dynamic
8565 linking works. */
ae6063d4 8566 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
9e754211
AM		 8567 return 1;
8568
252b5132 8569 /* It is necessary to force PC-relative calls/jumps to have a relocation
b6ff326e 8570 entry if they're going to need either an argument relocation or long
9e754211 8571 call stub. */
5506e1a5
AM		 8572 if (fixp->fx_pcrel
8573 && arg_reloc_stub_needed (symbol_arg_reloc_info (fixp->fx_addsy),
8574 hppa_fixp->fx_arg_reloc))
252b5132 8575 return 1;
ad1079af 8576
5506e1a5
AM		 8577 /* Now check to see if we're going to need a long-branch stub. */
8578 if (fixp->fx_r_type == (int) R_HPPA_PCREL_CALL)
8579 {
ec8b3afd
JL		 8580 long pc = md_pcrel_from (fixp);
8581 valueT distance, min_stub_distance;
5506e1a5 8582
ec8b3afd
JL		 8583 distance = fixp->fx_offset + S_GET_VALUE (fixp->fx_addsy) - pc - 8;
8584
8585 /* Distance to the closest possible stub. This will detect most
8586 but not all circumstances where a stub will not work. */
8587 min_stub_distance = pc + 16;
8588#ifdef OBJ_SOM
8589 if (last_call_info != NULL)
8590 min_stub_distance -= S_GET_VALUE (last_call_info->start_symbol);
27df9f40 8591#endif
ec8b3afd
JL		 8592
8593 if ((distance + 8388608 >= 16777216
8594 && min_stub_distance <= 8388608)
8595 || (hppa_fixp->fx_r_format == 17
8596 && distance + 262144 >= 524288
8597 && min_stub_distance <= 262144)
8598 || (hppa_fixp->fx_r_format == 12
8599 && distance + 8192 >= 16384
8600 && min_stub_distance <= 8192)
27df9f40 8601 )
5506e1a5
AM		 8602 return 1;
8603 }
252b5132 8604
ad1079af 8605 if (fixp->fx_r_type == (int) R_HPPA_ABS_CALL)
252b5132 8606 return 1;
252b5132
RH		 8607
8608 /* No need (yet) to force another relocations to be emitted. */
8609 return 0;
8610}
8611
8612/* Now for some ELF specific code. FIXME. */
8613#ifdef OBJ_ELF
8614/* Mark the end of a function so that it's possible to compute
ec8b3afd 8615 the size of the function in elf_hppa_final_processing. */
252b5132
RH		 8616
8617static void
8618hppa_elf_mark_end_of_function ()
8619{
8620 /* ELF does not have EXIT relocations. All we do is create a
8621 temporary symbol marking the end of the function. */
ad1079af
AM		 8622 char *name;
8623
8624 if (last_call_info == NULL || last_call_info->start_symbol == NULL)
8625 {
8626 /* We have already warned about a missing label,
8627 or other problems. */
8628 return;
8629 }
252b5132 8630
ad1079af
AM		 8631 name = (char *) xmalloc (strlen ("L$\001end_")
8632 + strlen (S_GET_NAME (last_call_info->start_symbol))
8633 + 1);
252b5132
RH		 8634 if (name)
8635 {
8636 symbolS *symbolP;
8637
8638 strcpy (name, "L$\001end_");
8639 strcat (name, S_GET_NAME (last_call_info->start_symbol));
8640
8641 /* If we have a .exit followed by a .procend, then the
8642 symbol will have already been defined. */
8643 symbolP = symbol_find (name);
8644 if (symbolP)
8645 {
8646 /* The symbol has already been defined! This can
8647 happen if we have a .exit followed by a .procend.
8648
8649 This is *not* an error. All we want to do is free
8650 the memory we just allocated for the name and continue. */
8651 xfree (name);
8652 }
8653 else
8654 {
8655 /* symbol value should be the offset of the
8656 last instruction of the function */
8657 symbolP = symbol_new (name, now_seg, (valueT) (frag_now_fix () - 4),
8658 frag_now);
8659
8660 assert (symbolP);
a0f75b47 8661 S_CLEAR_EXTERNAL (symbolP);
252b5132
RH		 8662 symbol_table_insert (symbolP);
8663 }
8664
8665 if (symbolP)
8666 last_call_info->end_symbol = symbolP;
8667 else
8668 as_bad (_("Symbol '%s' could not be created."), name);
8669
8670 }
8671 else
8672 as_bad (_("No memory for symbol name."));
8673
8674}
8675
8676/* For ELF, this function serves one purpose: to setup the st_size
8677 field of STT_FUNC symbols. To do this, we need to scan the
8678 call_info structure list, determining st_size in by taking the
8679 difference in the address of the beginning/end marker symbols. */
8680
8681void
8682elf_hppa_final_processing ()
8683{
8684 struct call_info *call_info_pointer;
8685
8686 for (call_info_pointer = call_info_root;
8687 call_info_pointer;
8688 call_info_pointer = call_info_pointer->ci_next)
8689 {
8690 elf_symbol_type *esym
a0f75b47
ILT		 8691 = ((elf_symbol_type *)
8692 symbol_get_bfdsym (call_info_pointer->start_symbol));
252b5132
RH		 8693 esym->internal_elf_sym.st_size =
8694 S_GET_VALUE (call_info_pointer->end_symbol)
8695 - S_GET_VALUE (call_info_pointer->start_symbol) + 4;
8696 }
8697}
2d93dcc4 8698
904a31bf
AM		 8699static void
8700pa_vtable_entry (ignore)
8701 int ignore ATTRIBUTE_UNUSED;
8702{
8703 struct fix *new_fix;
8704
8705 new_fix = obj_elf_vtable_entry (0);
8706
8707 if (new_fix)
8708 {
8709 struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8710 obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8711 hppa_fix->fx_r_type = R_HPPA;
8712 hppa_fix->fx_r_field = e_fsel;
8713 hppa_fix->fx_r_format = 32;
8714 hppa_fix->fx_arg_reloc = 0;
8715 hppa_fix->segment = now_seg;
8716 new_fix->tc_fix_data = (void *) hppa_fix;
8717 new_fix->fx_r_type = (int) R_PARISC_GNU_VTENTRY;
8718 }
8719}
8720
8721static void
8722pa_vtable_inherit (ignore)
8723 int ignore ATTRIBUTE_UNUSED;
8724{
8725 struct fix *new_fix;
8726
8727 new_fix = obj_elf_vtable_inherit (0);
8728
8729 if (new_fix)
8730 {
8731 struct hppa_fix_struct *hppa_fix = (struct hppa_fix_struct *)
8732 obstack_alloc (&notes, sizeof (struct hppa_fix_struct));
8733 hppa_fix->fx_r_type = R_HPPA;
8734 hppa_fix->fx_r_field = e_fsel;
8735 hppa_fix->fx_r_format = 32;
8736 hppa_fix->fx_arg_reloc = 0;
8737 hppa_fix->segment = now_seg;
8738 new_fix->tc_fix_data = (void *) hppa_fix;
8739 new_fix->fx_r_type = (int) R_PARISC_GNU_VTINHERIT;
8740 }
8741}
2d93dcc4 8742#endif
GDB Binutils - Deliverables
This page took 0.770399 seconds and 4 git commands to generate.