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