OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [config/] [tc-hppa.c] - Blame information for rev 16

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.