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