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