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