1 /* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
2 Copyright (C) 1989-2015 Free Software Foundation, Inc.
3 Contributed by Carnegie Mellon University, 1993.
4 Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
5 Modified by Ken Raeburn for gas-2.x and ECOFF support.
6 Modified by Richard Henderson for ELF support.
7 Modified by Klaus K"ampf for EVAX (OpenVMS/Alpha) support.
9 This file is part of GAS, the GNU Assembler.
11 GAS is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GAS is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GAS; see the file COPYING. If not, write to the Free
23 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
26 /* Mach Operating System
27 Copyright (c) 1993 Carnegie Mellon University
30 Permission to use, copy, modify and distribute this software and its
31 documentation is hereby granted, provided that both the copyright
32 notice and this permission notice appear in all copies of the
33 software, derivative works or modified versions, and any portions
34 thereof, and that both notices appear in supporting documentation.
36 CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
37 CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38 ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
40 Carnegie Mellon requests users of this software to return to
42 Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
43 School of Computer Science
44 Carnegie Mellon University
45 Pittsburgh PA 15213-3890
47 any improvements or extensions that they make and grant Carnegie the
48 rights to redistribute these changes. */
52 #include "struc-symbol.h"
55 #include "opcode/alpha.h"
58 #include "elf/alpha.h"
66 #include "dwarf2dbg.h"
67 #include "dw2gencfi.h"
68 #include "safe-ctype.h"
72 #define TOKENIZE_ERROR -1
73 #define TOKENIZE_ERROR_REPORT -2
74 #define MAX_INSN_FIXUPS 2
75 #define MAX_INSN_ARGS 5
77 /* Used since new relocation types are introduced in this
78 file (DUMMY_RELOC_LITUSE_*) */
79 typedef int extended_bfd_reloc_code_real_type;
84 /* bfd_reloc_code_real_type reloc; */
85 extended_bfd_reloc_code_real_type reloc;
87 /* The symbol of the item in the linkage section. */
90 /* The symbol of the procedure descriptor. */
99 struct alpha_fixup fixups[MAX_INSN_FIXUPS];
117 void (*emit) (const expressionS *, int, const void *);
119 enum alpha_macro_arg argsets[16];
122 /* Extra expression types. */
124 #define O_pregister O_md1 /* O_register, in parentheses. */
125 #define O_cpregister O_md2 /* + a leading comma. */
127 /* The alpha_reloc_op table below depends on the ordering of these. */
128 #define O_literal O_md3 /* !literal relocation. */
129 #define O_lituse_addr O_md4 /* !lituse_addr relocation. */
130 #define O_lituse_base O_md5 /* !lituse_base relocation. */
131 #define O_lituse_bytoff O_md6 /* !lituse_bytoff relocation. */
132 #define O_lituse_jsr O_md7 /* !lituse_jsr relocation. */
133 #define O_lituse_tlsgd O_md8 /* !lituse_tlsgd relocation. */
134 #define O_lituse_tlsldm O_md9 /* !lituse_tlsldm relocation. */
135 #define O_lituse_jsrdirect O_md10 /* !lituse_jsrdirect relocation. */
136 #define O_gpdisp O_md11 /* !gpdisp relocation. */
137 #define O_gprelhigh O_md12 /* !gprelhigh relocation. */
138 #define O_gprellow O_md13 /* !gprellow relocation. */
139 #define O_gprel O_md14 /* !gprel relocation. */
140 #define O_samegp O_md15 /* !samegp relocation. */
141 #define O_tlsgd O_md16 /* !tlsgd relocation. */
142 #define O_tlsldm O_md17 /* !tlsldm relocation. */
143 #define O_gotdtprel O_md18 /* !gotdtprel relocation. */
144 #define O_dtprelhi O_md19 /* !dtprelhi relocation. */
145 #define O_dtprello O_md20 /* !dtprello relocation. */
146 #define O_dtprel O_md21 /* !dtprel relocation. */
147 #define O_gottprel O_md22 /* !gottprel relocation. */
148 #define O_tprelhi O_md23 /* !tprelhi relocation. */
149 #define O_tprello O_md24 /* !tprello relocation. */
150 #define O_tprel O_md25 /* !tprel relocation. */
152 #define DUMMY_RELOC_LITUSE_ADDR (BFD_RELOC_UNUSED + 1)
153 #define DUMMY_RELOC_LITUSE_BASE (BFD_RELOC_UNUSED + 2)
154 #define DUMMY_RELOC_LITUSE_BYTOFF (BFD_RELOC_UNUSED + 3)
155 #define DUMMY_RELOC_LITUSE_JSR (BFD_RELOC_UNUSED + 4)
156 #define DUMMY_RELOC_LITUSE_TLSGD (BFD_RELOC_UNUSED + 5)
157 #define DUMMY_RELOC_LITUSE_TLSLDM (BFD_RELOC_UNUSED + 6)
158 #define DUMMY_RELOC_LITUSE_JSRDIRECT (BFD_RELOC_UNUSED + 7)
160 #define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_tprel)
162 /* Macros for extracting the type and number of encoded register tokens. */
164 #define is_ir_num(x) (((x) & 32) == 0)
165 #define is_fpr_num(x) (((x) & 32) != 0)
166 #define regno(x) ((x) & 31)
168 /* Something odd inherited from the old assembler. */
170 #define note_gpreg(R) (alpha_gprmask |= (1 << (R)))
171 #define note_fpreg(R) (alpha_fprmask |= (1 << (R)))
173 /* Predicates for 16- and 32-bit ranges */
174 /* XXX: The non-shift version appears to trigger a compiler bug when
175 cross-assembling from x86 w/ gcc 2.7.2. */
178 #define range_signed_16(x) \
179 (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
180 #define range_signed_32(x) \
181 (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
183 #define range_signed_16(x) ((offsetT) (x) >= -(offsetT) 0x8000 && \
184 (offsetT) (x) <= (offsetT) 0x7FFF)
185 #define range_signed_32(x) ((offsetT) (x) >= -(offsetT) 0x80000000 && \
186 (offsetT) (x) <= (offsetT) 0x7FFFFFFF)
189 /* Macros for sign extending from 16- and 32-bits. */
190 /* XXX: The cast macros will work on all the systems that I care about,
191 but really a predicate should be found to use the non-cast forms. */
194 #define sign_extend_16(x) ((short) (x))
195 #define sign_extend_32(x) ((int) (x))
197 #define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
198 #define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
199 ^ 0x80000000) - 0x80000000)
202 /* Macros to build tokens. */
204 #define set_tok_reg(t, r) (memset (&(t), 0, sizeof (t)), \
205 (t).X_op = O_register, \
206 (t).X_add_number = (r))
207 #define set_tok_preg(t, r) (memset (&(t), 0, sizeof (t)), \
208 (t).X_op = O_pregister, \
209 (t).X_add_number = (r))
210 #define set_tok_cpreg(t, r) (memset (&(t), 0, sizeof (t)), \
211 (t).X_op = O_cpregister, \
212 (t).X_add_number = (r))
213 #define set_tok_freg(t, r) (memset (&(t), 0, sizeof (t)), \
214 (t).X_op = O_register, \
215 (t).X_add_number = (r) + 32)
216 #define set_tok_sym(t, s, a) (memset (&(t), 0, sizeof (t)), \
217 (t).X_op = O_symbol, \
218 (t).X_add_symbol = (s), \
219 (t).X_add_number = (a))
220 #define set_tok_const(t, n) (memset (&(t), 0, sizeof (t)), \
221 (t).X_op = O_constant, \
222 (t).X_add_number = (n))
224 /* Generic assembler global variables which must be defined by all
227 /* Characters which always start a comment. */
228 const char comment_chars[] = "#";
230 /* Characters which start a comment at the beginning of a line. */
231 const char line_comment_chars[] = "#";
233 /* Characters which may be used to separate multiple commands on a
235 const char line_separator_chars[] = ";";
237 /* Characters which are used to indicate an exponent in a floating
239 const char EXP_CHARS[] = "eE";
241 /* Characters which mean that a number is a floating point constant,
243 /* XXX: Do all of these really get used on the alpha?? */
244 char FLT_CHARS[] = "rRsSfFdDxXpP";
247 const char *md_shortopts = "Fm:g+1h:HG:";
249 const char *md_shortopts = "Fm:gG:";
252 struct option md_longopts[] =
254 #define OPTION_32ADDR (OPTION_MD_BASE)
255 { "32addr", no_argument, NULL, OPTION_32ADDR },
256 #define OPTION_RELAX (OPTION_32ADDR + 1)
257 { "relax", no_argument, NULL, OPTION_RELAX },
259 #define OPTION_MDEBUG (OPTION_RELAX + 1)
260 #define OPTION_NO_MDEBUG (OPTION_MDEBUG + 1)
261 { "mdebug", no_argument, NULL, OPTION_MDEBUG },
262 { "no-mdebug", no_argument, NULL, OPTION_NO_MDEBUG },
265 #define OPTION_REPLACE (OPTION_RELAX + 1)
266 #define OPTION_NOREPLACE (OPTION_REPLACE+1)
267 { "replace", no_argument, NULL, OPTION_REPLACE },
268 { "noreplace", no_argument, NULL, OPTION_NOREPLACE },
270 { NULL, no_argument, NULL, 0 }
273 size_t md_longopts_size = sizeof (md_longopts);
277 #define AXP_REG_R16 16
278 #define AXP_REG_R17 17
280 #define AXP_REG_T9 22
282 #define AXP_REG_T10 23
284 #define AXP_REG_T11 24
286 #define AXP_REG_T12 25
287 #define AXP_REG_AI 25
289 #define AXP_REG_FP 29
292 #define AXP_REG_GP AXP_REG_PV
294 #endif /* OBJ_EVAX */
296 /* The cpu for which we are generating code. */
297 static unsigned alpha_target = AXP_OPCODE_BASE;
298 static const char *alpha_target_name = "<all>";
300 /* The hash table of instruction opcodes. */
301 static struct hash_control *alpha_opcode_hash;
303 /* The hash table of macro opcodes. */
304 static struct hash_control *alpha_macro_hash;
307 /* The $gp relocation symbol. */
308 static symbolS *alpha_gp_symbol;
310 /* XXX: what is this, and why is it exported? */
311 valueT alpha_gp_value;
314 /* The current $gp register. */
315 static int alpha_gp_register = AXP_REG_GP;
317 /* A table of the register symbols. */
318 static symbolS *alpha_register_table[64];
320 /* Constant sections, or sections of constants. */
322 static segT alpha_lita_section;
325 segT alpha_link_section;
328 static segT alpha_lit8_section;
331 /* Symbols referring to said sections. */
333 static symbolS *alpha_lita_symbol;
336 static symbolS *alpha_link_symbol;
339 static symbolS *alpha_lit8_symbol;
342 /* Literal for .litX+0x8000 within .lita. */
344 static offsetT alpha_lit8_literal;
347 /* Is the assembler not allowed to use $at? */
348 static int alpha_noat_on = 0;
350 /* Are macros enabled? */
351 static int alpha_macros_on = 1;
353 /* Are floats disabled? */
354 static int alpha_nofloats_on = 0;
356 /* Are addresses 32 bit? */
357 static int alpha_addr32_on = 0;
359 /* Symbol labelling the current insn. When the Alpha gas sees
362 and the section happens to not be on an eight byte boundary, it
363 will align both the symbol and the .quad to an eight byte boundary. */
364 static symbolS *alpha_insn_label;
365 #if defined(OBJ_ELF) || defined (OBJ_EVAX)
366 static symbolS *alpha_prologue_label;
370 /* Symbol associate with the current jsr instruction. */
371 static symbolS *alpha_linkage_symbol;
374 /* Whether we should automatically align data generation pseudo-ops.
375 .align 0 will turn this off. */
376 static int alpha_auto_align_on = 1;
378 /* The known current alignment of the current section. */
379 static int alpha_current_align;
381 /* These are exported to ECOFF code. */
382 unsigned long alpha_gprmask, alpha_fprmask;
384 /* Whether the debugging option was seen. */
385 static int alpha_debug;
388 /* Whether we are emitting an mdebug section. */
389 int alpha_flag_mdebug = -1;
393 /* Whether to perform the VMS procedure call optimization. */
394 int alpha_flag_replace = 1;
397 /* Don't fully resolve relocations, allowing code movement in the linker. */
398 static int alpha_flag_relax;
400 /* What value to give to bfd_set_gp_size. */
401 static int g_switch_value = 8;
404 /* Collect information about current procedure here. */
405 struct alpha_evax_procs
407 symbolS *symbol; /* Proc pdesc symbol. */
409 int framereg; /* Register for frame pointer. */
410 int framesize; /* Size of frame. */
422 /* Linked list of .linkage fixups. */
423 struct alpha_linkage_fixups *alpha_linkage_fixup_root;
424 static struct alpha_linkage_fixups *alpha_linkage_fixup_tail;
426 /* Current procedure descriptor. */
427 static struct alpha_evax_procs *alpha_evax_proc;
428 static struct alpha_evax_procs alpha_evax_proc_data;
430 static int alpha_flag_hash_long_names = 0; /* -+ */
431 static int alpha_flag_show_after_trunc = 0; /* -H */
433 /* If the -+ switch is given, then a hash is appended to any name that is
434 longer than 64 characters, else longer symbol names are truncated. */
439 /* A table to map the spelling of a relocation operand into an appropriate
440 bfd_reloc_code_real_type type. The table is assumed to be ordered such
441 that op-O_literal indexes into it. */
443 #define ALPHA_RELOC_TABLE(op) \
444 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
446 : (int) (op) - (int) O_literal) ])
448 #define DEF(NAME, RELOC, REQ, ALLOW) \
449 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
451 static const struct alpha_reloc_op_tag
453 const char *name; /* String to lookup. */
454 size_t length; /* Size of the string. */
455 operatorT op; /* Which operator to use. */
456 extended_bfd_reloc_code_real_type reloc;
457 unsigned int require_seq : 1; /* Require a sequence number. */
458 unsigned int allow_seq : 1; /* Allow a sequence number. */
462 DEF (literal, BFD_RELOC_ALPHA_ELF_LITERAL, 0, 1),
463 DEF (lituse_addr, DUMMY_RELOC_LITUSE_ADDR, 1, 1),
464 DEF (lituse_base, DUMMY_RELOC_LITUSE_BASE, 1, 1),
465 DEF (lituse_bytoff, DUMMY_RELOC_LITUSE_BYTOFF, 1, 1),
466 DEF (lituse_jsr, DUMMY_RELOC_LITUSE_JSR, 1, 1),
467 DEF (lituse_tlsgd, DUMMY_RELOC_LITUSE_TLSGD, 1, 1),
468 DEF (lituse_tlsldm, DUMMY_RELOC_LITUSE_TLSLDM, 1, 1),
469 DEF (lituse_jsrdirect, DUMMY_RELOC_LITUSE_JSRDIRECT, 1, 1),
470 DEF (gpdisp, BFD_RELOC_ALPHA_GPDISP, 1, 1),
471 DEF (gprelhigh, BFD_RELOC_ALPHA_GPREL_HI16, 0, 0),
472 DEF (gprellow, BFD_RELOC_ALPHA_GPREL_LO16, 0, 0),
473 DEF (gprel, BFD_RELOC_GPREL16, 0, 0),
474 DEF (samegp, BFD_RELOC_ALPHA_BRSGP, 0, 0),
475 DEF (tlsgd, BFD_RELOC_ALPHA_TLSGD, 0, 1),
476 DEF (tlsldm, BFD_RELOC_ALPHA_TLSLDM, 0, 1),
477 DEF (gotdtprel, BFD_RELOC_ALPHA_GOTDTPREL16, 0, 0),
478 DEF (dtprelhi, BFD_RELOC_ALPHA_DTPREL_HI16, 0, 0),
479 DEF (dtprello, BFD_RELOC_ALPHA_DTPREL_LO16, 0, 0),
480 DEF (dtprel, BFD_RELOC_ALPHA_DTPREL16, 0, 0),
481 DEF (gottprel, BFD_RELOC_ALPHA_GOTTPREL16, 0, 0),
482 DEF (tprelhi, BFD_RELOC_ALPHA_TPREL_HI16, 0, 0),
483 DEF (tprello, BFD_RELOC_ALPHA_TPREL_LO16, 0, 0),
484 DEF (tprel, BFD_RELOC_ALPHA_TPREL16, 0, 0),
489 static const int alpha_num_reloc_op
490 = sizeof (alpha_reloc_op) / sizeof (*alpha_reloc_op);
491 #endif /* RELOC_OP_P */
493 /* Maximum # digits needed to hold the largest sequence #. */
494 #define ALPHA_RELOC_DIGITS 25
496 /* Structure to hold explicit sequence information. */
497 struct alpha_reloc_tag
499 fixS *master; /* The literal reloc. */
501 struct symbol *sym; /* Linkage section item symbol. */
502 struct symbol *psym; /* Pdesc symbol. */
504 fixS *slaves; /* Head of linked list of lituses. */
505 segT segment; /* Segment relocs are in or undefined_section. */
506 long sequence; /* Sequence #. */
507 unsigned n_master; /* # of literals. */
508 unsigned n_slaves; /* # of lituses. */
509 unsigned saw_tlsgd : 1; /* True if ... */
510 unsigned saw_tlsldm : 1;
511 unsigned saw_lu_tlsgd : 1;
512 unsigned saw_lu_tlsldm : 1;
513 unsigned multi_section_p : 1; /* True if more than one section was used. */
514 char string[1]; /* Printable form of sequence to hash with. */
517 /* Hash table to link up literals with the appropriate lituse. */
518 static struct hash_control *alpha_literal_hash;
520 /* Sequence numbers for internal use by macros. */
521 static long next_sequence_num = -1;
523 /* A table of CPU names and opcode sets. */
525 static const struct cpu_type
532 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
533 This supports usage under DU 4.0b that does ".arch ev4", and
534 usage in MILO that does -m21064. Probably something more
535 specific like -m21064-pal should be used, but oh well. */
537 { "21064", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
538 { "21064a", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
539 { "21066", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
540 { "21068", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
541 { "21164", AXP_OPCODE_BASE|AXP_OPCODE_EV5 },
542 { "21164a", AXP_OPCODE_BASE|AXP_OPCODE_EV5|AXP_OPCODE_BWX },
543 { "21164pc", (AXP_OPCODE_BASE|AXP_OPCODE_EV5|AXP_OPCODE_BWX
545 { "21264", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
546 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
547 { "21264a", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
548 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
549 { "21264b", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
550 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
552 { "ev4", AXP_OPCODE_BASE },
553 { "ev45", AXP_OPCODE_BASE },
554 { "lca45", AXP_OPCODE_BASE },
555 { "ev5", AXP_OPCODE_BASE },
556 { "ev56", AXP_OPCODE_BASE|AXP_OPCODE_BWX },
557 { "pca56", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX },
558 { "ev6", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
559 { "ev67", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
560 { "ev68", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
562 { "all", AXP_OPCODE_BASE },
566 /* Some instruction sets indexed by lg(size). */
567 static const char * const sextX_op[] = { "sextb", "sextw", "sextl", NULL };
568 static const char * const insXl_op[] = { "insbl", "inswl", "insll", "insql" };
569 static const char * const insXh_op[] = { NULL, "inswh", "inslh", "insqh" };
570 static const char * const extXl_op[] = { "extbl", "extwl", "extll", "extql" };
571 static const char * const extXh_op[] = { NULL, "extwh", "extlh", "extqh" };
572 static const char * const mskXl_op[] = { "mskbl", "mskwl", "mskll", "mskql" };
573 static const char * const mskXh_op[] = { NULL, "mskwh", "msklh", "mskqh" };
574 static const char * const stX_op[] = { "stb", "stw", "stl", "stq" };
575 static const char * const ldXu_op[] = { "ldbu", "ldwu", NULL, NULL };
577 static void assemble_insn (const struct alpha_opcode *, const expressionS *, int, struct alpha_insn *, extended_bfd_reloc_code_real_type);
578 static void emit_insn (struct alpha_insn *);
579 static void assemble_tokens (const char *, const expressionS *, int, int);
581 static char *s_alpha_section_name (void);
582 static symbolS *add_to_link_pool (symbolS *, offsetT);
585 static struct alpha_reloc_tag *
586 get_alpha_reloc_tag (long sequence)
588 char buffer[ALPHA_RELOC_DIGITS];
589 struct alpha_reloc_tag *info;
591 sprintf (buffer, "!%ld", sequence);
593 info = (struct alpha_reloc_tag *) hash_find (alpha_literal_hash, buffer);
596 size_t len = strlen (buffer);
599 info = (struct alpha_reloc_tag *)
600 xcalloc (sizeof (struct alpha_reloc_tag) + len, 1);
602 info->segment = now_seg;
603 info->sequence = sequence;
604 strcpy (info->string, buffer);
605 errmsg = hash_insert (alpha_literal_hash, info->string, (void *) info);
607 as_fatal ("%s", errmsg);
620 alpha_adjust_relocs (bfd *abfd ATTRIBUTE_UNUSED,
622 void * ptr ATTRIBUTE_UNUSED)
624 segment_info_type *seginfo = seg_info (sec);
630 /* If seginfo is NULL, we did not create this section; don't do
631 anything with it. By using a pointer to a pointer, we can update
632 the links in place. */
636 /* If there are no relocations, skip the section. */
637 if (! seginfo->fix_root)
640 /* First rebuild the fixup chain without the explicit lituse and
641 gpdisp_lo16 relocs. */
642 prevP = &seginfo->fix_root;
643 for (fixp = seginfo->fix_root; fixp; fixp = next)
645 next = fixp->fx_next;
646 fixp->fx_next = (fixS *) 0;
648 switch (fixp->fx_r_type)
650 case BFD_RELOC_ALPHA_LITUSE:
651 if (fixp->tc_fix_data.info->n_master == 0)
652 as_bad_where (fixp->fx_file, fixp->fx_line,
653 _("No !literal!%ld was found"),
654 fixp->tc_fix_data.info->sequence);
656 if (fixp->fx_offset == LITUSE_ALPHA_TLSGD)
658 if (! fixp->tc_fix_data.info->saw_tlsgd)
659 as_bad_where (fixp->fx_file, fixp->fx_line,
660 _("No !tlsgd!%ld was found"),
661 fixp->tc_fix_data.info->sequence);
663 else if (fixp->fx_offset == LITUSE_ALPHA_TLSLDM)
665 if (! fixp->tc_fix_data.info->saw_tlsldm)
666 as_bad_where (fixp->fx_file, fixp->fx_line,
667 _("No !tlsldm!%ld was found"),
668 fixp->tc_fix_data.info->sequence);
673 case BFD_RELOC_ALPHA_GPDISP_LO16:
674 if (fixp->tc_fix_data.info->n_master == 0)
675 as_bad_where (fixp->fx_file, fixp->fx_line,
676 _("No ldah !gpdisp!%ld was found"),
677 fixp->tc_fix_data.info->sequence);
680 case BFD_RELOC_ALPHA_ELF_LITERAL:
681 if (fixp->tc_fix_data.info
682 && (fixp->tc_fix_data.info->saw_tlsgd
683 || fixp->tc_fix_data.info->saw_tlsldm))
689 prevP = &fixp->fx_next;
694 /* Go back and re-chain dependent relocations. They are currently
695 linked through the next_reloc field in reverse order, so as we
696 go through the next_reloc chain, we effectively reverse the chain
699 Except if there is more than one !literal for a given sequence
700 number. In that case, the programmer and/or compiler is not sure
701 how control flows from literal to lituse, and we can't be sure to
702 get the relaxation correct.
704 ??? Well, actually we could, if there are enough lituses such that
705 we can make each literal have at least one of each lituse type
706 present. Not implemented.
708 Also suppress the optimization if the !literals/!lituses are spread
709 in different segments. This can happen with "intersting" uses of
710 inline assembly; examples are present in the Linux kernel semaphores. */
712 for (fixp = seginfo->fix_root; fixp; fixp = next)
714 next = fixp->fx_next;
715 switch (fixp->fx_r_type)
717 case BFD_RELOC_ALPHA_TLSGD:
718 case BFD_RELOC_ALPHA_TLSLDM:
719 if (!fixp->tc_fix_data.info)
721 if (fixp->tc_fix_data.info->n_master == 0)
723 else if (fixp->tc_fix_data.info->n_master > 1)
725 as_bad_where (fixp->fx_file, fixp->fx_line,
726 _("too many !literal!%ld for %s"),
727 fixp->tc_fix_data.info->sequence,
728 (fixp->fx_r_type == BFD_RELOC_ALPHA_TLSGD
729 ? "!tlsgd" : "!tlsldm"));
733 fixp->tc_fix_data.info->master->fx_next = fixp->fx_next;
734 fixp->fx_next = fixp->tc_fix_data.info->master;
735 fixp = fixp->fx_next;
738 case BFD_RELOC_ALPHA_ELF_LITERAL:
739 if (fixp->tc_fix_data.info
740 && fixp->tc_fix_data.info->n_master == 1
741 && ! fixp->tc_fix_data.info->multi_section_p)
743 for (slave = fixp->tc_fix_data.info->slaves;
745 slave = slave->tc_fix_data.next_reloc)
747 slave->fx_next = fixp->fx_next;
748 fixp->fx_next = slave;
753 case BFD_RELOC_ALPHA_GPDISP_HI16:
754 if (fixp->tc_fix_data.info->n_slaves == 0)
755 as_bad_where (fixp->fx_file, fixp->fx_line,
756 _("No lda !gpdisp!%ld was found"),
757 fixp->tc_fix_data.info->sequence);
760 slave = fixp->tc_fix_data.info->slaves;
761 slave->fx_next = next;
762 fixp->fx_next = slave;
772 /* Before the relocations are written, reorder them, so that user
773 supplied !lituse relocations follow the appropriate !literal
774 relocations, and similarly for !gpdisp relocations. */
777 alpha_before_fix (void)
779 if (alpha_literal_hash)
780 bfd_map_over_sections (stdoutput, alpha_adjust_relocs, NULL);
787 debug_exp (expressionS tok[], int ntok)
791 fprintf (stderr, "debug_exp: %d tokens", ntok);
792 for (i = 0; i < ntok; i++)
794 expressionS *t = &tok[i];
799 default: name = "unknown"; break;
800 case O_illegal: name = "O_illegal"; break;
801 case O_absent: name = "O_absent"; break;
802 case O_constant: name = "O_constant"; break;
803 case O_symbol: name = "O_symbol"; break;
804 case O_symbol_rva: name = "O_symbol_rva"; break;
805 case O_register: name = "O_register"; break;
806 case O_big: name = "O_big"; break;
807 case O_uminus: name = "O_uminus"; break;
808 case O_bit_not: name = "O_bit_not"; break;
809 case O_logical_not: name = "O_logical_not"; break;
810 case O_multiply: name = "O_multiply"; break;
811 case O_divide: name = "O_divide"; break;
812 case O_modulus: name = "O_modulus"; break;
813 case O_left_shift: name = "O_left_shift"; break;
814 case O_right_shift: name = "O_right_shift"; break;
815 case O_bit_inclusive_or: name = "O_bit_inclusive_or"; break;
816 case O_bit_or_not: name = "O_bit_or_not"; break;
817 case O_bit_exclusive_or: name = "O_bit_exclusive_or"; break;
818 case O_bit_and: name = "O_bit_and"; break;
819 case O_add: name = "O_add"; break;
820 case O_subtract: name = "O_subtract"; break;
821 case O_eq: name = "O_eq"; break;
822 case O_ne: name = "O_ne"; break;
823 case O_lt: name = "O_lt"; break;
824 case O_le: name = "O_le"; break;
825 case O_ge: name = "O_ge"; break;
826 case O_gt: name = "O_gt"; break;
827 case O_logical_and: name = "O_logical_and"; break;
828 case O_logical_or: name = "O_logical_or"; break;
829 case O_index: name = "O_index"; break;
830 case O_pregister: name = "O_pregister"; break;
831 case O_cpregister: name = "O_cpregister"; break;
832 case O_literal: name = "O_literal"; break;
833 case O_lituse_addr: name = "O_lituse_addr"; break;
834 case O_lituse_base: name = "O_lituse_base"; break;
835 case O_lituse_bytoff: name = "O_lituse_bytoff"; break;
836 case O_lituse_jsr: name = "O_lituse_jsr"; break;
837 case O_lituse_tlsgd: name = "O_lituse_tlsgd"; break;
838 case O_lituse_tlsldm: name = "O_lituse_tlsldm"; break;
839 case O_lituse_jsrdirect: name = "O_lituse_jsrdirect"; break;
840 case O_gpdisp: name = "O_gpdisp"; break;
841 case O_gprelhigh: name = "O_gprelhigh"; break;
842 case O_gprellow: name = "O_gprellow"; break;
843 case O_gprel: name = "O_gprel"; break;
844 case O_samegp: name = "O_samegp"; break;
845 case O_tlsgd: name = "O_tlsgd"; break;
846 case O_tlsldm: name = "O_tlsldm"; break;
847 case O_gotdtprel: name = "O_gotdtprel"; break;
848 case O_dtprelhi: name = "O_dtprelhi"; break;
849 case O_dtprello: name = "O_dtprello"; break;
850 case O_dtprel: name = "O_dtprel"; break;
851 case O_gottprel: name = "O_gottprel"; break;
852 case O_tprelhi: name = "O_tprelhi"; break;
853 case O_tprello: name = "O_tprello"; break;
854 case O_tprel: name = "O_tprel"; break;
857 fprintf (stderr, ", %s(%s, %s, %d)", name,
858 (t->X_add_symbol) ? S_GET_NAME (t->X_add_symbol) : "--",
859 (t->X_op_symbol) ? S_GET_NAME (t->X_op_symbol) : "--",
860 (int) t->X_add_number);
862 fprintf (stderr, "\n");
867 /* Parse the arguments to an opcode. */
870 tokenize_arguments (char *str,
874 expressionS *end_tok = tok + ntok;
875 char *old_input_line_pointer;
876 int saw_comma = 0, saw_arg = 0;
878 expressionS *orig_tok = tok;
882 const struct alpha_reloc_op_tag *r;
885 int reloc_found_p = 0;
888 memset (tok, 0, sizeof (*tok) * ntok);
890 /* Save and restore input_line_pointer around this function. */
891 old_input_line_pointer = input_line_pointer;
892 input_line_pointer = str;
895 /* ??? Wrest control of ! away from the regular expression parser. */
896 is_end_of_line[(unsigned char) '!'] = 1;
899 while (tok < end_tok && *input_line_pointer)
902 switch (*input_line_pointer)
909 /* A relocation operand can be placed after the normal operand on an
910 assembly language statement, and has the following form:
911 !relocation_type!sequence_number. */
914 /* Only support one relocation op per insn. */
915 as_bad (_("More than one relocation op per insn"));
922 ++input_line_pointer;
924 p = input_line_pointer;
925 c = get_symbol_end ();
927 /* Parse !relocation_type. */
928 len = input_line_pointer - p;
931 as_bad (_("No relocation operand"));
935 r = &alpha_reloc_op[0];
936 for (i = alpha_num_reloc_op - 1; i >= 0; i--, r++)
937 if (len == r->length && memcmp (p, r->name, len) == 0)
941 as_bad (_("Unknown relocation operand: !%s"), p);
945 *input_line_pointer = c;
947 if (*input_line_pointer != '!')
951 as_bad (_("no sequence number after !%s"), p);
955 tok->X_add_number = 0;
961 as_bad (_("!%s does not use a sequence number"), p);
965 input_line_pointer++;
967 /* Parse !sequence_number. */
969 if (tok->X_op != O_constant || tok->X_add_number <= 0)
971 as_bad (_("Bad sequence number: !%s!%s"),
972 r->name, input_line_pointer);
981 #endif /* RELOC_OP_P */
984 ++input_line_pointer;
985 if (saw_comma || !saw_arg)
992 char *hold = input_line_pointer++;
994 /* First try for parenthesized register ... */
996 if (*input_line_pointer == ')' && tok->X_op == O_register)
998 tok->X_op = (saw_comma ? O_cpregister : O_pregister);
1001 ++input_line_pointer;
1006 /* ... then fall through to plain expression. */
1007 input_line_pointer = hold;
1011 if (saw_arg && !saw_comma)
1015 if (tok->X_op == O_illegal || tok->X_op == O_absent)
1028 input_line_pointer = old_input_line_pointer;
1031 debug_exp (orig_tok, ntok - (end_tok - tok));
1034 is_end_of_line[(unsigned char) '!'] = 0;
1037 return ntok - (end_tok - tok);
1041 is_end_of_line[(unsigned char) '!'] = 0;
1043 input_line_pointer = old_input_line_pointer;
1044 return TOKENIZE_ERROR;
1048 is_end_of_line[(unsigned char) '!'] = 0;
1050 input_line_pointer = old_input_line_pointer;
1051 return TOKENIZE_ERROR_REPORT;
1054 /* Search forward through all variants of an opcode looking for a
1057 static const struct alpha_opcode *
1058 find_opcode_match (const struct alpha_opcode *first_opcode,
1059 const expressionS *tok,
1063 const struct alpha_opcode *opcode = first_opcode;
1065 int got_cpu_match = 0;
1069 const unsigned char *opidx;
1072 /* Don't match opcodes that don't exist on this architecture. */
1073 if (!(opcode->flags & alpha_target))
1078 for (opidx = opcode->operands; *opidx; ++opidx)
1080 const struct alpha_operand *operand = &alpha_operands[*opidx];
1082 /* Only take input from real operands. */
1083 if (operand->flags & AXP_OPERAND_FAKE)
1086 /* When we expect input, make sure we have it. */
1089 if ((operand->flags & AXP_OPERAND_OPTIONAL_MASK) == 0)
1094 /* Match operand type with expression type. */
1095 switch (operand->flags & AXP_OPERAND_TYPECHECK_MASK)
1097 case AXP_OPERAND_IR:
1098 if (tok[tokidx].X_op != O_register
1099 || !is_ir_num (tok[tokidx].X_add_number))
1102 case AXP_OPERAND_FPR:
1103 if (tok[tokidx].X_op != O_register
1104 || !is_fpr_num (tok[tokidx].X_add_number))
1107 case AXP_OPERAND_IR | AXP_OPERAND_PARENS:
1108 if (tok[tokidx].X_op != O_pregister
1109 || !is_ir_num (tok[tokidx].X_add_number))
1112 case AXP_OPERAND_IR | AXP_OPERAND_PARENS | AXP_OPERAND_COMMA:
1113 if (tok[tokidx].X_op != O_cpregister
1114 || !is_ir_num (tok[tokidx].X_add_number))
1118 case AXP_OPERAND_RELATIVE:
1119 case AXP_OPERAND_SIGNED:
1120 case AXP_OPERAND_UNSIGNED:
1121 switch (tok[tokidx].X_op)
1136 /* Everything else should have been fake. */
1142 /* Possible match -- did we use all of our input? */
1151 while (++opcode - alpha_opcodes < (int) alpha_num_opcodes
1152 && !strcmp (opcode->name, first_opcode->name));
1155 *pcpumatch = got_cpu_match;
1160 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1161 the insn, but do not emit it.
1163 Note that this implies no macros allowed, since we can't store more
1164 than one insn in an insn structure. */
1167 assemble_tokens_to_insn (const char *opname,
1168 const expressionS *tok,
1170 struct alpha_insn *insn)
1172 const struct alpha_opcode *opcode;
1174 /* Search opcodes. */
1175 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
1179 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
1182 assemble_insn (opcode, tok, ntok, insn, BFD_RELOC_UNUSED);
1186 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
1188 as_bad (_("opcode `%s' not supported for target %s"), opname,
1192 as_bad (_("unknown opcode `%s'"), opname);
1195 /* Build a BFD section with its flags set appropriately for the .lita,
1196 .lit8, or .lit4 sections. */
1199 create_literal_section (const char *name,
1203 segT current_section = now_seg;
1204 int current_subsec = now_subseg;
1207 *secp = new_sec = subseg_new (name, 0);
1208 subseg_set (current_section, current_subsec);
1209 bfd_set_section_alignment (stdoutput, new_sec, 4);
1210 bfd_set_section_flags (stdoutput, new_sec,
1211 SEC_RELOC | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1214 S_CLEAR_EXTERNAL (*symp = section_symbol (new_sec));
1217 /* Load a (partial) expression into a target register.
1219 If poffset is not null, after the call it will either contain
1220 O_constant 0, or a 16-bit offset appropriate for any MEM format
1221 instruction. In addition, pbasereg will be modified to point to
1222 the base register to use in that MEM format instruction.
1224 In any case, *pbasereg should contain a base register to add to the
1225 expression. This will normally be either AXP_REG_ZERO or
1226 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1227 so "foo($0)" is interpreted as adding the address of foo to $0;
1228 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1229 but this is what OSF/1 does.
1231 If explicit relocations of the form !literal!<number> are allowed,
1232 and used, then explicit_reloc with be an expression pointer.
1234 Finally, the return value is nonzero if the calling macro may emit
1235 a LITUSE reloc if otherwise appropriate; the return value is the
1236 sequence number to use. */
1239 load_expression (int targreg,
1240 const expressionS *exp,
1242 expressionS *poffset,
1245 long emit_lituse = 0;
1246 offsetT addend = exp->X_add_number;
1247 int basereg = *pbasereg;
1248 struct alpha_insn insn;
1249 expressionS newtok[3];
1258 /* Attempt to reduce .lit load by splitting the offset from
1259 its symbol when possible, but don't create a situation in
1261 if (!range_signed_32 (addend) &&
1262 (alpha_noat_on || targreg == AXP_REG_AT))
1264 lit = add_to_literal_pool (exp->X_add_symbol, addend,
1265 alpha_lita_section, 8);
1269 lit = add_to_literal_pool (exp->X_add_symbol, 0,
1270 alpha_lita_section, 8);
1273 as_fatal (_("overflow in literal (.lita) table"));
1275 /* Emit "ldq r, lit(gp)". */
1277 if (basereg != alpha_gp_register && targreg == basereg)
1280 as_bad (_("macro requires $at register while noat in effect"));
1281 if (targreg == AXP_REG_AT)
1282 as_bad (_("macro requires $at while $at in use"));
1284 set_tok_reg (newtok[0], AXP_REG_AT);
1287 set_tok_reg (newtok[0], targreg);
1289 set_tok_sym (newtok[1], alpha_lita_symbol, lit);
1290 set_tok_preg (newtok[2], alpha_gp_register);
1292 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1294 gas_assert (insn.nfixups == 1);
1295 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1296 insn.sequence = emit_lituse = next_sequence_num--;
1297 #endif /* OBJ_ECOFF */
1299 /* Emit "ldq r, gotoff(gp)". */
1301 if (basereg != alpha_gp_register && targreg == basereg)
1304 as_bad (_("macro requires $at register while noat in effect"));
1305 if (targreg == AXP_REG_AT)
1306 as_bad (_("macro requires $at while $at in use"));
1308 set_tok_reg (newtok[0], AXP_REG_AT);
1311 set_tok_reg (newtok[0], targreg);
1313 /* XXX: Disable this .got minimizing optimization so that we can get
1314 better instruction offset knowledge in the compiler. This happens
1315 very infrequently anyway. */
1317 || (!range_signed_32 (addend)
1318 && (alpha_noat_on || targreg == AXP_REG_AT)))
1324 set_tok_sym (newtok[1], exp->X_add_symbol, 0);
1326 set_tok_preg (newtok[2], alpha_gp_register);
1328 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1330 gas_assert (insn.nfixups == 1);
1331 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1332 insn.sequence = emit_lituse = next_sequence_num--;
1333 #endif /* OBJ_ELF */
1335 /* Find symbol or symbol pointer in link section. */
1337 if (exp->X_add_symbol == alpha_evax_proc->symbol)
1339 /* Linkage-relative expression. */
1340 set_tok_reg (newtok[0], targreg);
1342 if (range_signed_16 (addend))
1344 set_tok_const (newtok[1], addend);
1349 set_tok_const (newtok[1], 0);
1351 set_tok_preg (newtok[2], basereg);
1352 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
1356 const char *symname = S_GET_NAME (exp->X_add_symbol);
1357 const char *ptr1, *ptr2;
1358 int symlen = strlen (symname);
1361 strcmp (ptr2 = &symname [symlen - 4], "..lk") == 0))
1363 /* Access to an item whose address is stored in the linkage
1364 section. Just read the address. */
1365 set_tok_reg (newtok[0], targreg);
1368 newtok[1].X_op = O_subtract;
1369 newtok[1].X_op_symbol = alpha_evax_proc->symbol;
1371 set_tok_preg (newtok[2], basereg);
1372 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1373 alpha_linkage_symbol = exp->X_add_symbol;
1376 set_tok_const (*poffset, 0);
1378 if (alpha_flag_replace && targreg == 26)
1380 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1384 /* Build the entry name as 'NAME..en'. */
1385 ptr1 = strstr (symname, "..") + 2;
1388 ensymname = (char *) alloca (ptr2 - ptr1 + 5);
1389 memcpy (ensymname, ptr1, ptr2 - ptr1);
1390 memcpy (ensymname + (ptr2 - ptr1), "..en", 5);
1392 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1393 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_NOP;
1394 ensym = symbol_find_or_make (ensymname);
1395 symbol_mark_used (ensym);
1396 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1397 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1399 insn.fixups[insn.nfixups].exp.X_op = O_symbol;
1400 insn.fixups[insn.nfixups].exp.X_add_symbol = ensym;
1401 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1402 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1403 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1406 /* ??? Force bsym to be instantiated now, as it will be
1407 too late to do so in tc_gen_reloc. */
1408 symbol_get_bfdsym (exp->X_add_symbol);
1410 else if (alpha_flag_replace && targreg == 27)
1412 /* Add a lda fixup for 'ldX $27,YYY.NAME..lk+8'. */
1417 ptr1 = strstr (symname, "..") + 2;
1420 psymname = (char *) alloca (ptr2 - ptr1 + 1);
1421 memcpy (psymname, ptr1, ptr2 - ptr1);
1422 psymname [ptr2 - ptr1] = 0;
1424 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1425 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_LDA;
1426 psym = symbol_find_or_make (psymname);
1427 symbol_mark_used (psym);
1428 insn.fixups[insn.nfixups].exp.X_op = O_subtract;
1429 insn.fixups[insn.nfixups].exp.X_add_symbol = psym;
1430 insn.fixups[insn.nfixups].exp.X_op_symbol = alpha_evax_proc->symbol;
1431 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1432 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1433 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1442 /* Not in the linkage section. Put the value into the linkage
1446 if (!range_signed_32 (addend))
1447 addend = sign_extend_32 (addend);
1448 linkexp = add_to_link_pool (exp->X_add_symbol, 0);
1449 set_tok_reg (newtok[0], targreg);
1450 set_tok_sym (newtok[1], linkexp, 0);
1451 set_tok_preg (newtok[2], basereg);
1452 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1455 #endif /* OBJ_EVAX */
1460 if (basereg != alpha_gp_register && basereg != AXP_REG_ZERO)
1462 /* Emit "addq r, base, r". */
1464 set_tok_reg (newtok[1], basereg);
1465 set_tok_reg (newtok[2], targreg);
1466 assemble_tokens ("addq", newtok, 3, 0);
1477 /* Assume that this difference expression will be resolved to an
1478 absolute value and that that value will fit in 16 bits. */
1480 set_tok_reg (newtok[0], targreg);
1482 set_tok_preg (newtok[2], basereg);
1483 assemble_tokens (opname, newtok, 3, 0);
1486 set_tok_const (*poffset, 0);
1490 if (exp->X_add_number > 0)
1491 as_bad (_("bignum invalid; zero assumed"));
1493 as_bad (_("floating point number invalid; zero assumed"));
1498 as_bad (_("can't handle expression"));
1503 if (!range_signed_32 (addend))
1509 long seq_num = next_sequence_num--;
1512 /* For 64-bit addends, just put it in the literal pool. */
1514 /* Emit "ldq targreg, lit(basereg)". */
1515 litexp = add_to_link_pool (section_symbol (absolute_section), addend);
1516 set_tok_reg (newtok[0], targreg);
1517 set_tok_sym (newtok[1], litexp, 0);
1518 set_tok_preg (newtok[2], alpha_gp_register);
1519 assemble_tokens ("ldq", newtok, 3, 0);
1522 if (alpha_lit8_section == NULL)
1524 create_literal_section (".lit8",
1525 &alpha_lit8_section,
1526 &alpha_lit8_symbol);
1529 alpha_lit8_literal = add_to_literal_pool (alpha_lit8_symbol, 0x8000,
1530 alpha_lita_section, 8);
1531 if (alpha_lit8_literal >= 0x8000)
1532 as_fatal (_("overflow in literal (.lita) table"));
1536 lit = add_to_literal_pool (NULL, addend, alpha_lit8_section, 8) - 0x8000;
1538 as_fatal (_("overflow in literal (.lit8) table"));
1540 /* Emit "lda litreg, .lit8+0x8000". */
1542 if (targreg == basereg)
1545 as_bad (_("macro requires $at register while noat in effect"));
1546 if (targreg == AXP_REG_AT)
1547 as_bad (_("macro requires $at while $at in use"));
1549 set_tok_reg (newtok[0], AXP_REG_AT);
1552 set_tok_reg (newtok[0], targreg);
1554 set_tok_sym (newtok[1], alpha_lita_symbol, alpha_lit8_literal);
1557 set_tok_sym (newtok[1], alpha_lit8_symbol, 0x8000);
1559 set_tok_preg (newtok[2], alpha_gp_register);
1561 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1563 gas_assert (insn.nfixups == 1);
1565 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1568 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1570 insn.sequence = seq_num;
1574 /* Emit "ldq litreg, lit(litreg)". */
1576 set_tok_const (newtok[1], lit);
1577 set_tok_preg (newtok[2], newtok[0].X_add_number);
1579 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1581 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
1582 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
1583 insn.fixups[insn.nfixups].exp.X_op = O_absent;
1585 insn.sequence = seq_num;
1590 /* Emit "addq litreg, base, target". */
1592 if (basereg != AXP_REG_ZERO)
1594 set_tok_reg (newtok[1], basereg);
1595 set_tok_reg (newtok[2], targreg);
1596 assemble_tokens ("addq", newtok, 3, 0);
1598 #endif /* !OBJ_EVAX */
1601 set_tok_const (*poffset, 0);
1602 *pbasereg = targreg;
1606 offsetT low, high, extra, tmp;
1608 /* For 32-bit operands, break up the addend. */
1610 low = sign_extend_16 (addend);
1612 high = sign_extend_16 (tmp >> 16);
1614 if (tmp - (high << 16))
1618 high = sign_extend_16 (tmp >> 16);
1623 set_tok_reg (newtok[0], targreg);
1624 set_tok_preg (newtok[2], basereg);
1628 /* Emit "ldah r, extra(r). */
1629 set_tok_const (newtok[1], extra);
1630 assemble_tokens ("ldah", newtok, 3, 0);
1631 set_tok_preg (newtok[2], basereg = targreg);
1636 /* Emit "ldah r, high(r). */
1637 set_tok_const (newtok[1], high);
1638 assemble_tokens ("ldah", newtok, 3, 0);
1640 set_tok_preg (newtok[2], basereg);
1643 if ((low && !poffset) || (!poffset && basereg != targreg))
1645 /* Emit "lda r, low(base)". */
1646 set_tok_const (newtok[1], low);
1647 assemble_tokens ("lda", newtok, 3, 0);
1653 set_tok_const (*poffset, low);
1654 *pbasereg = basereg;
1660 /* The lda macro differs from the lda instruction in that it handles
1661 most simple expressions, particularly symbol address loads and
1665 emit_lda (const expressionS *tok,
1667 const void * unused ATTRIBUTE_UNUSED)
1672 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
1674 basereg = tok[2].X_add_number;
1676 (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL, "lda");
1679 /* The ldah macro differs from the ldah instruction in that it has $31
1680 as an implied base register. */
1683 emit_ldah (const expressionS *tok,
1684 int ntok ATTRIBUTE_UNUSED,
1685 const void * unused ATTRIBUTE_UNUSED)
1687 expressionS newtok[3];
1691 set_tok_preg (newtok[2], AXP_REG_ZERO);
1693 assemble_tokens ("ldah", newtok, 3, 0);
1696 /* Called internally to handle all alignment needs. This takes care
1697 of eliding calls to frag_align if'n the cached current alignment
1698 says we've already got it, as well as taking care of the auto-align
1699 feature wrt labels. */
1705 int force ATTRIBUTE_UNUSED)
1707 if (alpha_current_align >= n)
1712 if (subseg_text_p (now_seg))
1713 frag_align_code (n, 0);
1715 frag_align (n, 0, 0);
1718 frag_align (n, *pfill, 0);
1720 alpha_current_align = n;
1722 if (label != NULL && S_GET_SEGMENT (label) == now_seg)
1724 symbol_set_frag (label, frag_now);
1725 S_SET_VALUE (label, (valueT) frag_now_fix ());
1728 record_alignment (now_seg, n);
1730 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1731 in a reloc for the linker to see. */
1734 /* Actually output an instruction with its fixup. */
1737 emit_insn (struct alpha_insn *insn)
1742 /* Take care of alignment duties. */
1743 if (alpha_auto_align_on && alpha_current_align < 2)
1744 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
1745 if (alpha_current_align > 2)
1746 alpha_current_align = 2;
1747 alpha_insn_label = NULL;
1749 /* Write out the instruction. */
1751 md_number_to_chars (f, insn->insn, 4);
1754 dwarf2_emit_insn (4);
1757 /* Apply the fixups in order. */
1758 for (i = 0; i < insn->nfixups; ++i)
1760 const struct alpha_operand *operand = (const struct alpha_operand *) 0;
1761 struct alpha_fixup *fixup = &insn->fixups[i];
1762 struct alpha_reloc_tag *info = NULL;
1766 /* Some fixups are only used internally and so have no howto. */
1767 if ((int) fixup->reloc < 0)
1769 operand = &alpha_operands[-(int) fixup->reloc];
1771 pcrel = ((operand->flags & AXP_OPERAND_RELATIVE) != 0);
1773 else if (fixup->reloc > BFD_RELOC_UNUSED
1774 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_HI16
1775 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_LO16)
1782 reloc_howto_type *reloc_howto =
1783 bfd_reloc_type_lookup (stdoutput,
1784 (bfd_reloc_code_real_type) fixup->reloc);
1785 gas_assert (reloc_howto);
1787 size = bfd_get_reloc_size (reloc_howto);
1789 switch (fixup->reloc)
1792 case BFD_RELOC_ALPHA_NOP:
1793 case BFD_RELOC_ALPHA_BSR:
1794 case BFD_RELOC_ALPHA_LDA:
1795 case BFD_RELOC_ALPHA_BOH:
1799 gas_assert (size >= 1 && size <= 4);
1802 pcrel = reloc_howto->pc_relative;
1805 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
1806 &fixup->exp, pcrel, (bfd_reloc_code_real_type) fixup->reloc);
1808 /* Turn off complaints that the addend is too large for some fixups,
1809 and copy in the sequence number for the explicit relocations. */
1810 switch (fixup->reloc)
1812 case BFD_RELOC_ALPHA_HINT:
1813 case BFD_RELOC_GPREL32:
1814 case BFD_RELOC_GPREL16:
1815 case BFD_RELOC_ALPHA_GPREL_HI16:
1816 case BFD_RELOC_ALPHA_GPREL_LO16:
1817 case BFD_RELOC_ALPHA_GOTDTPREL16:
1818 case BFD_RELOC_ALPHA_DTPREL_HI16:
1819 case BFD_RELOC_ALPHA_DTPREL_LO16:
1820 case BFD_RELOC_ALPHA_DTPREL16:
1821 case BFD_RELOC_ALPHA_GOTTPREL16:
1822 case BFD_RELOC_ALPHA_TPREL_HI16:
1823 case BFD_RELOC_ALPHA_TPREL_LO16:
1824 case BFD_RELOC_ALPHA_TPREL16:
1825 fixP->fx_no_overflow = 1;
1828 case BFD_RELOC_ALPHA_GPDISP_HI16:
1829 fixP->fx_no_overflow = 1;
1830 fixP->fx_addsy = section_symbol (now_seg);
1831 fixP->fx_offset = 0;
1833 info = get_alpha_reloc_tag (insn->sequence);
1834 if (++info->n_master > 1)
1835 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn->sequence);
1836 if (info->segment != now_seg)
1837 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1839 fixP->tc_fix_data.info = info;
1842 case BFD_RELOC_ALPHA_GPDISP_LO16:
1843 fixP->fx_no_overflow = 1;
1845 info = get_alpha_reloc_tag (insn->sequence);
1846 if (++info->n_slaves > 1)
1847 as_bad (_("too many lda insns for !gpdisp!%ld"), insn->sequence);
1848 if (info->segment != now_seg)
1849 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1851 fixP->tc_fix_data.info = info;
1852 info->slaves = fixP;
1855 case BFD_RELOC_ALPHA_LITERAL:
1856 case BFD_RELOC_ALPHA_ELF_LITERAL:
1857 fixP->fx_no_overflow = 1;
1859 if (insn->sequence == 0)
1861 info = get_alpha_reloc_tag (insn->sequence);
1862 info->master = fixP;
1864 if (info->segment != now_seg)
1865 info->multi_section_p = 1;
1866 fixP->tc_fix_data.info = info;
1870 case DUMMY_RELOC_LITUSE_ADDR:
1871 fixP->fx_offset = LITUSE_ALPHA_ADDR;
1873 case DUMMY_RELOC_LITUSE_BASE:
1874 fixP->fx_offset = LITUSE_ALPHA_BASE;
1876 case DUMMY_RELOC_LITUSE_BYTOFF:
1877 fixP->fx_offset = LITUSE_ALPHA_BYTOFF;
1879 case DUMMY_RELOC_LITUSE_JSR:
1880 fixP->fx_offset = LITUSE_ALPHA_JSR;
1882 case DUMMY_RELOC_LITUSE_TLSGD:
1883 fixP->fx_offset = LITUSE_ALPHA_TLSGD;
1885 case DUMMY_RELOC_LITUSE_TLSLDM:
1886 fixP->fx_offset = LITUSE_ALPHA_TLSLDM;
1888 case DUMMY_RELOC_LITUSE_JSRDIRECT:
1889 fixP->fx_offset = LITUSE_ALPHA_JSRDIRECT;
1892 fixP->fx_addsy = section_symbol (now_seg);
1893 fixP->fx_r_type = BFD_RELOC_ALPHA_LITUSE;
1895 info = get_alpha_reloc_tag (insn->sequence);
1896 if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSGD)
1897 info->saw_lu_tlsgd = 1;
1898 else if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSLDM)
1899 info->saw_lu_tlsldm = 1;
1900 if (++info->n_slaves > 1)
1902 if (info->saw_lu_tlsgd)
1903 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1905 else if (info->saw_lu_tlsldm)
1906 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1909 fixP->tc_fix_data.info = info;
1910 fixP->tc_fix_data.next_reloc = info->slaves;
1911 info->slaves = fixP;
1912 if (info->segment != now_seg)
1913 info->multi_section_p = 1;
1916 case BFD_RELOC_ALPHA_TLSGD:
1917 fixP->fx_no_overflow = 1;
1919 if (insn->sequence == 0)
1921 info = get_alpha_reloc_tag (insn->sequence);
1922 if (info->saw_tlsgd)
1923 as_bad (_("duplicate !tlsgd!%ld"), insn->sequence);
1924 else if (info->saw_tlsldm)
1925 as_bad (_("sequence number in use for !tlsldm!%ld"),
1928 info->saw_tlsgd = 1;
1929 fixP->tc_fix_data.info = info;
1932 case BFD_RELOC_ALPHA_TLSLDM:
1933 fixP->fx_no_overflow = 1;
1935 if (insn->sequence == 0)
1937 info = get_alpha_reloc_tag (insn->sequence);
1938 if (info->saw_tlsldm)
1939 as_bad (_("duplicate !tlsldm!%ld"), insn->sequence);
1940 else if (info->saw_tlsgd)
1941 as_bad (_("sequence number in use for !tlsgd!%ld"),
1944 info->saw_tlsldm = 1;
1945 fixP->tc_fix_data.info = info;
1949 case BFD_RELOC_ALPHA_NOP:
1950 case BFD_RELOC_ALPHA_LDA:
1951 case BFD_RELOC_ALPHA_BSR:
1952 case BFD_RELOC_ALPHA_BOH:
1953 info = get_alpha_reloc_tag (next_sequence_num--);
1954 fixP->tc_fix_data.info = info;
1955 fixP->tc_fix_data.info->sym = fixup->xtrasym;
1956 fixP->tc_fix_data.info->psym = fixup->procsym;
1961 if ((int) fixup->reloc < 0)
1963 if (operand->flags & AXP_OPERAND_NOOVERFLOW)
1964 fixP->fx_no_overflow = 1;
1971 /* Insert an operand value into an instruction. */
1974 insert_operand (unsigned insn,
1975 const struct alpha_operand *operand,
1980 if (operand->bits != 32 && !(operand->flags & AXP_OPERAND_NOOVERFLOW))
1984 if (operand->flags & AXP_OPERAND_SIGNED)
1986 max = (1 << (operand->bits - 1)) - 1;
1987 min = -(1 << (operand->bits - 1));
1991 max = (1 << operand->bits) - 1;
1995 if (val < min || val > max)
1996 as_bad_value_out_of_range (_("operand"), val, min, max, file, line);
1999 if (operand->insert)
2001 const char *errmsg = NULL;
2003 insn = (*operand->insert) (insn, val, &errmsg);
2005 as_warn ("%s", errmsg);
2008 insn |= ((val & ((1 << operand->bits) - 1)) << operand->shift);
2013 /* Turn an opcode description and a set of arguments into
2014 an instruction and a fixup. */
2017 assemble_insn (const struct alpha_opcode *opcode,
2018 const expressionS *tok,
2020 struct alpha_insn *insn,
2021 extended_bfd_reloc_code_real_type reloc)
2023 const struct alpha_operand *reloc_operand = NULL;
2024 const expressionS *reloc_exp = NULL;
2025 const unsigned char *argidx;
2029 memset (insn, 0, sizeof (*insn));
2030 image = opcode->opcode;
2032 for (argidx = opcode->operands; *argidx; ++argidx)
2034 const struct alpha_operand *operand = &alpha_operands[*argidx];
2035 const expressionS *t = (const expressionS *) 0;
2037 if (operand->flags & AXP_OPERAND_FAKE)
2039 /* Fake operands take no value and generate no fixup. */
2040 image = insert_operand (image, operand, 0, NULL, 0);
2046 switch (operand->flags & AXP_OPERAND_OPTIONAL_MASK)
2048 case AXP_OPERAND_DEFAULT_FIRST:
2051 case AXP_OPERAND_DEFAULT_SECOND:
2054 case AXP_OPERAND_DEFAULT_ZERO:
2056 static expressionS zero_exp;
2058 zero_exp.X_op = O_constant;
2059 zero_exp.X_unsigned = 1;
2074 image = insert_operand (image, operand, regno (t->X_add_number),
2079 image = insert_operand (image, operand, t->X_add_number, NULL, 0);
2080 gas_assert (reloc_operand == NULL);
2081 reloc_operand = operand;
2086 /* This is only 0 for fields that should contain registers,
2087 which means this pattern shouldn't have matched. */
2088 if (operand->default_reloc == 0)
2091 /* There is one special case for which an insn receives two
2092 relocations, and thus the user-supplied reloc does not
2093 override the operand reloc. */
2094 if (operand->default_reloc == BFD_RELOC_ALPHA_HINT)
2096 struct alpha_fixup *fixup;
2098 if (insn->nfixups >= MAX_INSN_FIXUPS)
2099 as_fatal (_("too many fixups"));
2101 fixup = &insn->fixups[insn->nfixups++];
2103 fixup->reloc = BFD_RELOC_ALPHA_HINT;
2107 if (reloc == BFD_RELOC_UNUSED)
2108 reloc = operand->default_reloc;
2110 gas_assert (reloc_operand == NULL);
2111 reloc_operand = operand;
2118 if (reloc != BFD_RELOC_UNUSED)
2120 struct alpha_fixup *fixup;
2122 if (insn->nfixups >= MAX_INSN_FIXUPS)
2123 as_fatal (_("too many fixups"));
2125 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2126 relocation tag for both ldah and lda with gpdisp. Choose the
2127 correct internal relocation based on the opcode. */
2128 if (reloc == BFD_RELOC_ALPHA_GPDISP)
2130 if (strcmp (opcode->name, "ldah") == 0)
2131 reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2132 else if (strcmp (opcode->name, "lda") == 0)
2133 reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
2135 as_bad (_("invalid relocation for instruction"));
2138 /* If this is a real relocation (as opposed to a lituse hint), then
2139 the relocation width should match the operand width.
2140 Take care of -MDISP in operand table. */
2141 else if (reloc < BFD_RELOC_UNUSED && reloc > 0)
2143 reloc_howto_type *reloc_howto
2144 = bfd_reloc_type_lookup (stdoutput,
2145 (bfd_reloc_code_real_type) reloc);
2146 if (reloc_operand == NULL
2147 || reloc_howto->bitsize != reloc_operand->bits)
2149 as_bad (_("invalid relocation for field"));
2154 fixup = &insn->fixups[insn->nfixups++];
2156 fixup->exp = *reloc_exp;
2158 fixup->exp.X_op = O_absent;
2159 fixup->reloc = reloc;
2165 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2166 etc. They differ from the real instructions in that they do simple
2167 expressions like the lda macro. */
2170 emit_ir_load (const expressionS *tok,
2172 const void * opname)
2176 expressionS newtok[3];
2177 struct alpha_insn insn;
2179 = tok[1].X_add_symbol ? S_GET_NAME (tok[1].X_add_symbol): "";
2180 int symlen = strlen (symname);
2183 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2185 basereg = tok[2].X_add_number;
2187 lituse = load_expression (tok[0].X_add_number, &tok[1],
2188 &basereg, &newtok[1], (const char *) opname);
2190 if (basereg == alpha_gp_register &&
2191 (symlen > 4 && strcmp (&symname [symlen - 4], "..lk") == 0))
2195 set_tok_preg (newtok[2], basereg);
2197 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2201 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2202 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2203 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2205 insn.sequence = lituse;
2211 /* Handle fp register loads, and both integer and fp register stores.
2212 Again, we handle simple expressions. */
2215 emit_loadstore (const expressionS *tok,
2217 const void * opname)
2221 expressionS newtok[3];
2222 struct alpha_insn insn;
2225 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2227 basereg = tok[2].X_add_number;
2229 if (tok[1].X_op != O_constant || !range_signed_16 (tok[1].X_add_number))
2232 as_bad (_("macro requires $at register while noat in effect"));
2234 lituse = load_expression (AXP_REG_AT, &tok[1],
2235 &basereg, &newtok[1], (const char *) opname);
2244 set_tok_preg (newtok[2], basereg);
2246 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2250 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2251 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2252 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2254 insn.sequence = lituse;
2260 /* Load a half-word or byte as an unsigned value. */
2263 emit_ldXu (const expressionS *tok,
2265 const void * vlgsize)
2267 if (alpha_target & AXP_OPCODE_BWX)
2268 emit_ir_load (tok, ntok, ldXu_op[(long) vlgsize]);
2271 expressionS newtok[3];
2272 struct alpha_insn insn;
2277 as_bad (_("macro requires $at register while noat in effect"));
2280 basereg = (tok[1].X_op == O_constant
2281 ? AXP_REG_ZERO : alpha_gp_register);
2283 basereg = tok[2].X_add_number;
2285 /* Emit "lda $at, exp". */
2286 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2288 /* Emit "ldq_u targ, 0($at)". */
2290 set_tok_const (newtok[1], 0);
2291 set_tok_preg (newtok[2], basereg);
2292 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2296 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2297 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2298 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2300 insn.sequence = lituse;
2305 /* Emit "extXl targ, $at, targ". */
2306 set_tok_reg (newtok[1], basereg);
2307 newtok[2] = newtok[0];
2308 assemble_tokens_to_insn (extXl_op[(long) vlgsize], newtok, 3, &insn);
2312 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2313 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2314 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2316 insn.sequence = lituse;
2323 /* Load a half-word or byte as a signed value. */
2326 emit_ldX (const expressionS *tok,
2328 const void * vlgsize)
2330 emit_ldXu (tok, ntok, vlgsize);
2331 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2334 /* Load an integral value from an unaligned address as an unsigned
2338 emit_uldXu (const expressionS *tok,
2340 const void * vlgsize)
2342 long lgsize = (long) vlgsize;
2343 expressionS newtok[3];
2346 as_bad (_("macro requires $at register while noat in effect"));
2348 /* Emit "lda $at, exp". */
2349 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2350 newtok[0].X_add_number = AXP_REG_AT;
2351 assemble_tokens ("lda", newtok, ntok, 1);
2353 /* Emit "ldq_u $t9, 0($at)". */
2354 set_tok_reg (newtok[0], AXP_REG_T9);
2355 set_tok_const (newtok[1], 0);
2356 set_tok_preg (newtok[2], AXP_REG_AT);
2357 assemble_tokens ("ldq_u", newtok, 3, 1);
2359 /* Emit "ldq_u $t10, size-1($at)". */
2360 set_tok_reg (newtok[0], AXP_REG_T10);
2361 set_tok_const (newtok[1], (1 << lgsize) - 1);
2362 assemble_tokens ("ldq_u", newtok, 3, 1);
2364 /* Emit "extXl $t9, $at, $t9". */
2365 set_tok_reg (newtok[0], AXP_REG_T9);
2366 set_tok_reg (newtok[1], AXP_REG_AT);
2367 set_tok_reg (newtok[2], AXP_REG_T9);
2368 assemble_tokens (extXl_op[lgsize], newtok, 3, 1);
2370 /* Emit "extXh $t10, $at, $t10". */
2371 set_tok_reg (newtok[0], AXP_REG_T10);
2372 set_tok_reg (newtok[2], AXP_REG_T10);
2373 assemble_tokens (extXh_op[lgsize], newtok, 3, 1);
2375 /* Emit "or $t9, $t10, targ". */
2376 set_tok_reg (newtok[0], AXP_REG_T9);
2377 set_tok_reg (newtok[1], AXP_REG_T10);
2379 assemble_tokens ("or", newtok, 3, 1);
2382 /* Load an integral value from an unaligned address as a signed value.
2383 Note that quads should get funneled to the unsigned load since we
2384 don't have to do the sign extension. */
2387 emit_uldX (const expressionS *tok,
2389 const void * vlgsize)
2391 emit_uldXu (tok, ntok, vlgsize);
2392 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2395 /* Implement the ldil macro. */
2398 emit_ldil (const expressionS *tok,
2400 const void * unused ATTRIBUTE_UNUSED)
2402 expressionS newtok[2];
2404 memcpy (newtok, tok, sizeof (newtok));
2405 newtok[1].X_add_number = sign_extend_32 (tok[1].X_add_number);
2407 assemble_tokens ("lda", newtok, ntok, 1);
2410 /* Store a half-word or byte. */
2413 emit_stX (const expressionS *tok,
2415 const void * vlgsize)
2417 int lgsize = (int) (long) vlgsize;
2419 if (alpha_target & AXP_OPCODE_BWX)
2420 emit_loadstore (tok, ntok, stX_op[lgsize]);
2423 expressionS newtok[3];
2424 struct alpha_insn insn;
2429 as_bad (_("macro requires $at register while noat in effect"));
2432 basereg = (tok[1].X_op == O_constant
2433 ? AXP_REG_ZERO : alpha_gp_register);
2435 basereg = tok[2].X_add_number;
2437 /* Emit "lda $at, exp". */
2438 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2440 /* Emit "ldq_u $t9, 0($at)". */
2441 set_tok_reg (newtok[0], AXP_REG_T9);
2442 set_tok_const (newtok[1], 0);
2443 set_tok_preg (newtok[2], basereg);
2444 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2448 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2449 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2450 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2452 insn.sequence = lituse;
2457 /* Emit "insXl src, $at, $t10". */
2459 set_tok_reg (newtok[1], basereg);
2460 set_tok_reg (newtok[2], AXP_REG_T10);
2461 assemble_tokens_to_insn (insXl_op[lgsize], newtok, 3, &insn);
2465 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2466 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2467 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2469 insn.sequence = lituse;
2474 /* Emit "mskXl $t9, $at, $t9". */
2475 set_tok_reg (newtok[0], AXP_REG_T9);
2476 newtok[2] = newtok[0];
2477 assemble_tokens_to_insn (mskXl_op[lgsize], newtok, 3, &insn);
2481 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2482 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2483 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2485 insn.sequence = lituse;
2490 /* Emit "or $t9, $t10, $t9". */
2491 set_tok_reg (newtok[1], AXP_REG_T10);
2492 assemble_tokens ("or", newtok, 3, 1);
2494 /* Emit "stq_u $t9, 0($at). */
2495 set_tok_const(newtok[1], 0);
2496 set_tok_preg (newtok[2], AXP_REG_AT);
2497 assemble_tokens_to_insn ("stq_u", newtok, 3, &insn);
2501 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2502 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2503 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2505 insn.sequence = lituse;
2512 /* Store an integer to an unaligned address. */
2515 emit_ustX (const expressionS *tok,
2517 const void * vlgsize)
2519 int lgsize = (int) (long) vlgsize;
2520 expressionS newtok[3];
2522 /* Emit "lda $at, exp". */
2523 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2524 newtok[0].X_add_number = AXP_REG_AT;
2525 assemble_tokens ("lda", newtok, ntok, 1);
2527 /* Emit "ldq_u $9, 0($at)". */
2528 set_tok_reg (newtok[0], AXP_REG_T9);
2529 set_tok_const (newtok[1], 0);
2530 set_tok_preg (newtok[2], AXP_REG_AT);
2531 assemble_tokens ("ldq_u", newtok, 3, 1);
2533 /* Emit "ldq_u $10, size-1($at)". */
2534 set_tok_reg (newtok[0], AXP_REG_T10);
2535 set_tok_const (newtok[1], (1 << lgsize) - 1);
2536 assemble_tokens ("ldq_u", newtok, 3, 1);
2538 /* Emit "insXl src, $at, $t11". */
2540 set_tok_reg (newtok[1], AXP_REG_AT);
2541 set_tok_reg (newtok[2], AXP_REG_T11);
2542 assemble_tokens (insXl_op[lgsize], newtok, 3, 1);
2544 /* Emit "insXh src, $at, $t12". */
2545 set_tok_reg (newtok[2], AXP_REG_T12);
2546 assemble_tokens (insXh_op[lgsize], newtok, 3, 1);
2548 /* Emit "mskXl $t9, $at, $t9". */
2549 set_tok_reg (newtok[0], AXP_REG_T9);
2550 newtok[2] = newtok[0];
2551 assemble_tokens (mskXl_op[lgsize], newtok, 3, 1);
2553 /* Emit "mskXh $t10, $at, $t10". */
2554 set_tok_reg (newtok[0], AXP_REG_T10);
2555 newtok[2] = newtok[0];
2556 assemble_tokens (mskXh_op[lgsize], newtok, 3, 1);
2558 /* Emit "or $t9, $t11, $t9". */
2559 set_tok_reg (newtok[0], AXP_REG_T9);
2560 set_tok_reg (newtok[1], AXP_REG_T11);
2561 newtok[2] = newtok[0];
2562 assemble_tokens ("or", newtok, 3, 1);
2564 /* Emit "or $t10, $t12, $t10". */
2565 set_tok_reg (newtok[0], AXP_REG_T10);
2566 set_tok_reg (newtok[1], AXP_REG_T12);
2567 newtok[2] = newtok[0];
2568 assemble_tokens ("or", newtok, 3, 1);
2570 /* Emit "stq_u $t10, size-1($at)". */
2571 set_tok_reg (newtok[0], AXP_REG_T10);
2572 set_tok_const (newtok[1], (1 << lgsize) - 1);
2573 set_tok_preg (newtok[2], AXP_REG_AT);
2574 assemble_tokens ("stq_u", newtok, 3, 1);
2576 /* Emit "stq_u $t9, 0($at)". */
2577 set_tok_reg (newtok[0], AXP_REG_T9);
2578 set_tok_const (newtok[1], 0);
2579 assemble_tokens ("stq_u", newtok, 3, 1);
2582 /* Sign extend a half-word or byte. The 32-bit sign extend is
2583 implemented as "addl $31, $r, $t" in the opcode table. */
2586 emit_sextX (const expressionS *tok,
2588 const void * vlgsize)
2590 long lgsize = (long) vlgsize;
2592 if (alpha_target & AXP_OPCODE_BWX)
2593 assemble_tokens (sextX_op[lgsize], tok, ntok, 0);
2596 int bitshift = 64 - 8 * (1 << lgsize);
2597 expressionS newtok[3];
2599 /* Emit "sll src,bits,dst". */
2601 set_tok_const (newtok[1], bitshift);
2602 newtok[2] = tok[ntok - 1];
2603 assemble_tokens ("sll", newtok, 3, 1);
2605 /* Emit "sra dst,bits,dst". */
2606 newtok[0] = newtok[2];
2607 assemble_tokens ("sra", newtok, 3, 1);
2611 /* Implement the division and modulus macros. */
2615 /* Make register usage like in normal procedure call.
2616 Don't clobber PV and RA. */
2619 emit_division (const expressionS *tok,
2621 const void * symname)
2623 /* DIVISION and MODULUS. Yech.
2628 mov x,R16 # if x != R16
2629 mov y,R17 # if y != R17
2634 with appropriate optimizations if R0,R16,R17 are the registers
2635 specified by the compiler. */
2639 expressionS newtok[3];
2641 xr = regno (tok[0].X_add_number);
2642 yr = regno (tok[1].X_add_number);
2647 rr = regno (tok[2].X_add_number);
2649 /* Move the operands into the right place. */
2650 if (yr == AXP_REG_R16 && xr == AXP_REG_R17)
2652 /* They are in exactly the wrong order -- swap through AT. */
2654 as_bad (_("macro requires $at register while noat in effect"));
2656 set_tok_reg (newtok[0], AXP_REG_R16);
2657 set_tok_reg (newtok[1], AXP_REG_AT);
2658 assemble_tokens ("mov", newtok, 2, 1);
2660 set_tok_reg (newtok[0], AXP_REG_R17);
2661 set_tok_reg (newtok[1], AXP_REG_R16);
2662 assemble_tokens ("mov", newtok, 2, 1);
2664 set_tok_reg (newtok[0], AXP_REG_AT);
2665 set_tok_reg (newtok[1], AXP_REG_R17);
2666 assemble_tokens ("mov", newtok, 2, 1);
2670 if (yr == AXP_REG_R16)
2672 set_tok_reg (newtok[0], AXP_REG_R16);
2673 set_tok_reg (newtok[1], AXP_REG_R17);
2674 assemble_tokens ("mov", newtok, 2, 1);
2677 if (xr != AXP_REG_R16)
2679 set_tok_reg (newtok[0], xr);
2680 set_tok_reg (newtok[1], AXP_REG_R16);
2681 assemble_tokens ("mov", newtok, 2, 1);
2684 if (yr != AXP_REG_R16 && yr != AXP_REG_R17)
2686 set_tok_reg (newtok[0], yr);
2687 set_tok_reg (newtok[1], AXP_REG_R17);
2688 assemble_tokens ("mov", newtok, 2, 1);
2692 sym = symbol_find_or_make ((const char *) symname);
2694 set_tok_reg (newtok[0], AXP_REG_AT);
2695 set_tok_sym (newtok[1], sym, 0);
2696 assemble_tokens ("lda", newtok, 2, 1);
2698 /* Call the division routine. */
2699 set_tok_reg (newtok[0], AXP_REG_AT);
2700 set_tok_cpreg (newtok[1], AXP_REG_AT);
2701 set_tok_const (newtok[2], 0);
2702 assemble_tokens ("jsr", newtok, 3, 1);
2704 /* Move the result to the right place. */
2705 if (rr != AXP_REG_R0)
2707 set_tok_reg (newtok[0], AXP_REG_R0);
2708 set_tok_reg (newtok[1], rr);
2709 assemble_tokens ("mov", newtok, 2, 1);
2713 #else /* !OBJ_EVAX */
2716 emit_division (const expressionS *tok,
2718 const void * symname)
2720 /* DIVISION and MODULUS. Yech.
2730 with appropriate optimizations if t10,t11,t12 are the registers
2731 specified by the compiler. */
2735 expressionS newtok[3];
2737 xr = regno (tok[0].X_add_number);
2738 yr = regno (tok[1].X_add_number);
2743 rr = regno (tok[2].X_add_number);
2745 sym = symbol_find_or_make ((const char *) symname);
2747 /* Move the operands into the right place. */
2748 if (yr == AXP_REG_T10 && xr == AXP_REG_T11)
2750 /* They are in exactly the wrong order -- swap through AT. */
2752 as_bad (_("macro requires $at register while noat in effect"));
2754 set_tok_reg (newtok[0], AXP_REG_T10);
2755 set_tok_reg (newtok[1], AXP_REG_AT);
2756 assemble_tokens ("mov", newtok, 2, 1);
2758 set_tok_reg (newtok[0], AXP_REG_T11);
2759 set_tok_reg (newtok[1], AXP_REG_T10);
2760 assemble_tokens ("mov", newtok, 2, 1);
2762 set_tok_reg (newtok[0], AXP_REG_AT);
2763 set_tok_reg (newtok[1], AXP_REG_T11);
2764 assemble_tokens ("mov", newtok, 2, 1);
2768 if (yr == AXP_REG_T10)
2770 set_tok_reg (newtok[0], AXP_REG_T10);
2771 set_tok_reg (newtok[1], AXP_REG_T11);
2772 assemble_tokens ("mov", newtok, 2, 1);
2775 if (xr != AXP_REG_T10)
2777 set_tok_reg (newtok[0], xr);
2778 set_tok_reg (newtok[1], AXP_REG_T10);
2779 assemble_tokens ("mov", newtok, 2, 1);
2782 if (yr != AXP_REG_T10 && yr != AXP_REG_T11)
2784 set_tok_reg (newtok[0], yr);
2785 set_tok_reg (newtok[1], AXP_REG_T11);
2786 assemble_tokens ("mov", newtok, 2, 1);
2790 /* Call the division routine. */
2791 set_tok_reg (newtok[0], AXP_REG_T9);
2792 set_tok_sym (newtok[1], sym, 0);
2793 assemble_tokens ("jsr", newtok, 2, 1);
2795 /* Reload the GP register. */
2799 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2800 set_tok_reg (newtok[0], alpha_gp_register);
2801 set_tok_const (newtok[1], 0);
2802 set_tok_preg (newtok[2], AXP_REG_T9);
2803 assemble_tokens ("ldgp", newtok, 3, 1);
2806 /* Move the result to the right place. */
2807 if (rr != AXP_REG_T12)
2809 set_tok_reg (newtok[0], AXP_REG_T12);
2810 set_tok_reg (newtok[1], rr);
2811 assemble_tokens ("mov", newtok, 2, 1);
2815 #endif /* !OBJ_EVAX */
2817 /* The jsr and jmp macros differ from their instruction counterparts
2818 in that they can load the target address and default most
2822 emit_jsrjmp (const expressionS *tok,
2824 const void * vopname)
2826 const char *opname = (const char *) vopname;
2827 struct alpha_insn insn;
2828 expressionS newtok[3];
2832 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2833 r = regno (tok[tokidx++].X_add_number);
2835 r = strcmp (opname, "jmp") == 0 ? AXP_REG_ZERO : AXP_REG_RA;
2837 set_tok_reg (newtok[0], r);
2839 if (tokidx < ntok &&
2840 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2841 r = regno (tok[tokidx++].X_add_number);
2843 /* Keep register if jsr $n.<sym>. */
2847 int basereg = alpha_gp_register;
2848 lituse = load_expression (r = AXP_REG_PV, &tok[tokidx],
2849 &basereg, NULL, opname);
2853 set_tok_cpreg (newtok[1], r);
2857 newtok[2] = tok[tokidx];
2860 set_tok_const (newtok[2], 0);
2862 assemble_tokens_to_insn (opname, newtok, 3, &insn);
2866 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2867 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_JSR;
2868 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2870 insn.sequence = lituse;
2874 if (alpha_flag_replace
2876 && tok[tokidx].X_add_symbol
2877 && alpha_linkage_symbol)
2879 /* Create a BOH reloc for 'jsr $27,NAME'. */
2880 const char *symname = S_GET_NAME (tok[tokidx].X_add_symbol);
2881 int symlen = strlen (symname);
2884 /* Build the entry name as 'NAME..en'. */
2885 ensymname = (char *) alloca (symlen + 5);
2886 memcpy (ensymname, symname, symlen);
2887 memcpy (ensymname + symlen, "..en", 5);
2889 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2890 if (insn.nfixups > 0)
2892 memmove (&insn.fixups[1], &insn.fixups[0],
2893 sizeof(struct alpha_fixup) * insn.nfixups);
2896 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2897 case in load_expression. See B.4.5.2 of the OpenVMS
2898 Linker Utility Manual. */
2899 insn.fixups[0].reloc = BFD_RELOC_ALPHA_BOH;
2900 insn.fixups[0].exp.X_op = O_symbol;
2901 insn.fixups[0].exp.X_add_symbol = symbol_find_or_make (ensymname);
2902 insn.fixups[0].exp.X_add_number = 0;
2903 insn.fixups[0].xtrasym = alpha_linkage_symbol;
2904 insn.fixups[0].procsym = alpha_evax_proc->symbol;
2906 alpha_linkage_symbol = 0;
2913 /* The ret and jcr instructions differ from their instruction
2914 counterparts in that everything can be defaulted. */
2917 emit_retjcr (const expressionS *tok,
2919 const void * vopname)
2921 const char *opname = (const char *) vopname;
2922 expressionS newtok[3];
2925 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2926 r = regno (tok[tokidx++].X_add_number);
2930 set_tok_reg (newtok[0], r);
2932 if (tokidx < ntok &&
2933 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2934 r = regno (tok[tokidx++].X_add_number);
2938 set_tok_cpreg (newtok[1], r);
2941 newtok[2] = tok[tokidx];
2943 set_tok_const (newtok[2], strcmp (opname, "ret") == 0);
2945 assemble_tokens (opname, newtok, 3, 0);
2948 /* Implement the ldgp macro. */
2951 emit_ldgp (const expressionS *tok ATTRIBUTE_UNUSED,
2952 int ntok ATTRIBUTE_UNUSED,
2953 const void * unused ATTRIBUTE_UNUSED)
2958 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2959 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2960 with appropriate constants and relocations. */
2961 struct alpha_insn insn;
2962 expressionS newtok[3];
2966 if (regno (tok[2].X_add_number) == AXP_REG_PV)
2967 ecoff_set_gp_prolog_size (0);
2971 set_tok_const (newtok[1], 0);
2974 assemble_tokens_to_insn ("ldah", newtok, 3, &insn);
2979 if (addend.X_op != O_constant)
2980 as_bad (_("can not resolve expression"));
2981 addend.X_op = O_symbol;
2982 addend.X_add_symbol = alpha_gp_symbol;
2986 insn.fixups[0].exp = addend;
2987 insn.fixups[0].reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2988 insn.sequence = next_sequence_num;
2992 set_tok_preg (newtok[2], tok[0].X_add_number);
2994 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
2997 addend.X_add_number += 4;
3001 insn.fixups[0].exp = addend;
3002 insn.fixups[0].reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
3003 insn.sequence = next_sequence_num--;
3006 #endif /* OBJ_ECOFF || OBJ_ELF */
3009 /* The macro table. */
3011 static const struct alpha_macro alpha_macros[] =
3013 /* Load/Store macros. */
3014 { "lda", emit_lda, NULL,
3015 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3016 { "ldah", emit_ldah, NULL,
3017 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3019 { "ldl", emit_ir_load, "ldl",
3020 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3021 { "ldl_l", emit_ir_load, "ldl_l",
3022 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3023 { "ldq", emit_ir_load, "ldq",
3024 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3025 { "ldq_l", emit_ir_load, "ldq_l",
3026 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3027 { "ldq_u", emit_ir_load, "ldq_u",
3028 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3029 { "ldf", emit_loadstore, "ldf",
3030 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3031 { "ldg", emit_loadstore, "ldg",
3032 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3033 { "lds", emit_loadstore, "lds",
3034 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3035 { "ldt", emit_loadstore, "ldt",
3036 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3038 { "ldb", emit_ldX, (void *) 0,
3039 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3040 { "ldbu", emit_ldXu, (void *) 0,
3041 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3042 { "ldw", emit_ldX, (void *) 1,
3043 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3044 { "ldwu", emit_ldXu, (void *) 1,
3045 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3047 { "uldw", emit_uldX, (void *) 1,
3048 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3049 { "uldwu", emit_uldXu, (void *) 1,
3050 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3051 { "uldl", emit_uldX, (void *) 2,
3052 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3053 { "uldlu", emit_uldXu, (void *) 2,
3054 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3055 { "uldq", emit_uldXu, (void *) 3,
3056 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3058 { "ldgp", emit_ldgp, NULL,
3059 { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA } },
3061 { "ldi", emit_lda, NULL,
3062 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3063 { "ldil", emit_ldil, NULL,
3064 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3065 { "ldiq", emit_lda, NULL,
3066 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3068 { "stl", emit_loadstore, "stl",
3069 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3070 { "stl_c", emit_loadstore, "stl_c",
3071 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3072 { "stq", emit_loadstore, "stq",
3073 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3074 { "stq_c", emit_loadstore, "stq_c",
3075 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3076 { "stq_u", emit_loadstore, "stq_u",
3077 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3078 { "stf", emit_loadstore, "stf",
3079 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3080 { "stg", emit_loadstore, "stg",
3081 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3082 { "sts", emit_loadstore, "sts",
3083 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3084 { "stt", emit_loadstore, "stt",
3085 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3087 { "stb", emit_stX, (void *) 0,
3088 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3089 { "stw", emit_stX, (void *) 1,
3090 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3091 { "ustw", emit_ustX, (void *) 1,
3092 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3093 { "ustl", emit_ustX, (void *) 2,
3094 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3095 { "ustq", emit_ustX, (void *) 3,
3096 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3098 /* Arithmetic macros. */
3100 { "sextb", emit_sextX, (void *) 0,
3101 { MACRO_IR, MACRO_IR, MACRO_EOA,
3102 MACRO_IR, MACRO_EOA,
3103 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3104 { "sextw", emit_sextX, (void *) 1,
3105 { MACRO_IR, MACRO_IR, MACRO_EOA,
3106 MACRO_IR, MACRO_EOA,
3107 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3109 { "divl", emit_division, "__divl",
3110 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3111 MACRO_IR, MACRO_IR, MACRO_EOA,
3112 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3113 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3114 { "divlu", emit_division, "__divlu",
3115 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3116 MACRO_IR, MACRO_IR, MACRO_EOA,
3117 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3118 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3119 { "divq", emit_division, "__divq",
3120 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3121 MACRO_IR, MACRO_IR, MACRO_EOA,
3122 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3123 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3124 { "divqu", emit_division, "__divqu",
3125 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3126 MACRO_IR, MACRO_IR, MACRO_EOA,
3127 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3128 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3129 { "reml", emit_division, "__reml",
3130 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3131 MACRO_IR, MACRO_IR, MACRO_EOA,
3132 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3133 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3134 { "remlu", emit_division, "__remlu",
3135 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3136 MACRO_IR, MACRO_IR, MACRO_EOA,
3137 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3138 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3139 { "remq", emit_division, "__remq",
3140 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3141 MACRO_IR, MACRO_IR, MACRO_EOA,
3142 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3143 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3144 { "remqu", emit_division, "__remqu",
3145 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3146 MACRO_IR, MACRO_IR, MACRO_EOA,
3147 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3148 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3150 { "jsr", emit_jsrjmp, "jsr",
3151 { MACRO_PIR, MACRO_EXP, MACRO_EOA,
3152 MACRO_PIR, MACRO_EOA,
3153 MACRO_IR, MACRO_EXP, MACRO_EOA,
3154 MACRO_EXP, MACRO_EOA } },
3155 { "jmp", emit_jsrjmp, "jmp",
3156 { MACRO_PIR, MACRO_EXP, MACRO_EOA,
3157 MACRO_PIR, MACRO_EOA,
3158 MACRO_IR, MACRO_EXP, MACRO_EOA,
3159 MACRO_EXP, MACRO_EOA } },
3160 { "ret", emit_retjcr, "ret",
3161 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3162 MACRO_IR, MACRO_EOA,
3163 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3164 MACRO_PIR, MACRO_EOA,
3165 MACRO_EXP, MACRO_EOA,
3167 { "jcr", emit_retjcr, "jcr",
3168 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3169 MACRO_IR, MACRO_EOA,
3170 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3171 MACRO_PIR, MACRO_EOA,
3172 MACRO_EXP, MACRO_EOA,
3174 { "jsr_coroutine", emit_retjcr, "jcr",
3175 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3176 MACRO_IR, MACRO_EOA,
3177 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3178 MACRO_PIR, MACRO_EOA,
3179 MACRO_EXP, MACRO_EOA,
3183 static const unsigned int alpha_num_macros
3184 = sizeof (alpha_macros) / sizeof (*alpha_macros);
3186 /* Search forward through all variants of a macro looking for a syntax
3189 static const struct alpha_macro *
3190 find_macro_match (const struct alpha_macro *first_macro,
3191 const expressionS *tok,
3195 const struct alpha_macro *macro = first_macro;
3200 const enum alpha_macro_arg *arg = macro->argsets;
3214 /* Index register. */
3216 if (tokidx >= ntok || tok[tokidx].X_op != O_register
3217 || !is_ir_num (tok[tokidx].X_add_number))
3222 /* Parenthesized index register. */
3224 if (tokidx >= ntok || tok[tokidx].X_op != O_pregister
3225 || !is_ir_num (tok[tokidx].X_add_number))
3230 /* Optional parenthesized index register. */
3232 if (tokidx < ntok && tok[tokidx].X_op == O_pregister
3233 && is_ir_num (tok[tokidx].X_add_number))
3237 /* Leading comma with a parenthesized index register. */
3239 if (tokidx >= ntok || tok[tokidx].X_op != O_cpregister
3240 || !is_ir_num (tok[tokidx].X_add_number))
3245 /* Floating point register. */
3247 if (tokidx >= ntok || tok[tokidx].X_op != O_register
3248 || !is_fpr_num (tok[tokidx].X_add_number))
3253 /* Normal expression. */
3257 switch (tok[tokidx].X_op)
3266 case O_lituse_bytoff:
3282 while (*arg != MACRO_EOA)
3290 while (++macro - alpha_macros < (int) alpha_num_macros
3291 && !strcmp (macro->name, first_macro->name));
3296 /* Given an opcode name and a pre-tokenized set of arguments, take the
3297 opcode all the way through emission. */
3300 assemble_tokens (const char *opname,
3301 const expressionS *tok,
3303 int local_macros_on)
3305 int found_something = 0;
3306 const struct alpha_opcode *opcode;
3307 const struct alpha_macro *macro;
3309 extended_bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
3312 /* If a user-specified relocation is present, this is not a macro. */
3313 if (ntok && USER_RELOC_P (tok[ntok - 1].X_op))
3315 reloc = ALPHA_RELOC_TABLE (tok[ntok - 1].X_op)->reloc;
3320 if (local_macros_on)
3322 macro = ((const struct alpha_macro *)
3323 hash_find (alpha_macro_hash, opname));
3326 found_something = 1;
3327 macro = find_macro_match (macro, tok, &ntok);
3330 (*macro->emit) (tok, ntok, macro->arg);
3336 /* Search opcodes. */
3337 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
3340 found_something = 1;
3341 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
3344 struct alpha_insn insn;
3345 assemble_insn (opcode, tok, ntok, &insn, reloc);
3347 /* Copy the sequence number for the reloc from the reloc token. */
3348 if (reloc != BFD_RELOC_UNUSED)
3349 insn.sequence = tok[ntok].X_add_number;
3356 if (found_something)
3359 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
3361 as_bad (_("opcode `%s' not supported for target %s"), opname,
3365 as_bad (_("unknown opcode `%s'"), opname);
3370 /* Add sym+addend to link pool.
3371 Return offset from curent procedure value (pv) to entry in link pool.
3373 Add new fixup only if offset isn't 16bit. */
3376 add_to_link_pool (symbolS *sym, offsetT addend)
3379 segT current_section = now_seg;
3380 int current_subsec = now_subseg;
3382 segment_info_type *seginfo = seg_info (alpha_link_section);
3384 symbolS *linksym, *expsym;
3387 basesym = alpha_evax_proc->symbol;
3389 /* @@ This assumes all entries in a given section will be of the same
3390 size... Probably correct, but unwise to rely on. */
3391 /* This must always be called with the same subsegment. */
3393 if (seginfo->frchainP)
3394 for (fixp = seginfo->frchainP->fix_root;
3395 fixp != (fixS *) NULL;
3396 fixp = fixp->fx_next)
3398 if (fixp->fx_addsy == sym
3399 && fixp->fx_offset == (valueT)addend
3400 && fixp->tc_fix_data.info
3401 && fixp->tc_fix_data.info->sym
3402 && fixp->tc_fix_data.info->sym->sy_value.X_op_symbol == basesym)
3403 return fixp->tc_fix_data.info->sym;
3406 /* Not found, add a new entry. */
3407 subseg_set (alpha_link_section, 0);
3408 linksym = symbol_new
3409 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
3413 /* Create a symbol for 'basesym - linksym' (offset of the added entry). */
3414 e.X_op = O_subtract;
3415 e.X_add_symbol = linksym;
3416 e.X_op_symbol = basesym;
3418 expsym = make_expr_symbol (&e);
3420 /* Create a fixup for the entry. */
3422 (frag_now, p - frag_now->fr_literal, 8, sym, addend, 0, BFD_RELOC_64);
3423 fixp->tc_fix_data.info = get_alpha_reloc_tag (next_sequence_num--);
3424 fixp->tc_fix_data.info->sym = expsym;
3426 subseg_set (current_section, current_subsec);
3428 /* Return the symbol. */
3431 #endif /* OBJ_EVAX */
3433 /* Assembler directives. */
3435 /* Handle the .text pseudo-op. This is like the usual one, but it
3436 clears alpha_insn_label and restores auto alignment. */
3439 s_alpha_text (int i)
3450 symbolP = symbol_find (".text");
3451 if (symbolP == NULL)
3453 symbolP = symbol_make (".text");
3454 S_SET_SEGMENT (symbolP, text_section);
3455 symbol_table_insert (symbolP);
3459 alpha_insn_label = NULL;
3460 alpha_auto_align_on = 1;
3461 alpha_current_align = 0;
3464 /* Handle the .data pseudo-op. This is like the usual one, but it
3465 clears alpha_insn_label and restores auto alignment. */
3468 s_alpha_data (int i)
3475 alpha_insn_label = NULL;
3476 alpha_auto_align_on = 1;
3477 alpha_current_align = 0;
3480 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3482 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3485 s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
3497 name = input_line_pointer;
3498 c = get_symbol_end ();
3500 /* Just after name is now '\0'. */
3501 p = input_line_pointer;
3506 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3507 if (*input_line_pointer == ',')
3509 input_line_pointer++;
3512 if ((size = get_absolute_expression ()) < 0)
3514 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
3515 ignore_rest_of_line ();
3520 symbolP = symbol_find_or_make (name);
3523 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3525 as_bad (_("Ignoring attempt to re-define symbol"));
3526 ignore_rest_of_line ();
3531 if (*input_line_pointer != ',')
3532 temp = 8; /* Default alignment. */
3535 input_line_pointer++;
3537 temp = get_absolute_expression ();
3540 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3541 while ((temp >>= 1) != 0)
3544 if (*input_line_pointer == ',')
3546 /* Extended form of the directive
3548 .comm symbol, size, alignment, section
3550 where the "common" semantics is transferred to the section.
3551 The symbol is effectively an alias for the section name. */
3555 symbolS *sec_symbol;
3556 segT current_seg = now_seg;
3557 subsegT current_subseg = now_subseg;
3560 input_line_pointer++;
3562 sec_name = s_alpha_section_name ();
3563 sec_symbol = symbol_find_or_make (sec_name);
3564 sec = subseg_new (sec_name, 0);
3565 S_SET_SEGMENT (sec_symbol, sec);
3566 symbol_get_bfdsym (sec_symbol)->flags |= BSF_SECTION_SYM;
3567 bfd_vms_set_section_flags (stdoutput, sec, 0,
3568 EGPS__V_OVR | EGPS__V_GBL | EGPS__V_NOMOD);
3569 record_alignment (sec, log_align);
3571 /* Reuse stab_string_size to store the size of the section. */
3572 cur_size = seg_info (sec)->stabu.stab_string_size;
3573 if ((int) size > cur_size)
3576 = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL,
3577 (valueT)size - (valueT)cur_size, NULL);
3579 seg_info (sec)->stabu.stab_string_size = (int)size;
3582 S_SET_SEGMENT (symbolP, sec);
3584 subseg_set (current_seg, current_subseg);
3588 /* Regular form of the directive
3590 .comm symbol, size, alignment
3592 where the "common" semantics in on the symbol.
3593 These symbols are assembled in the .bss section. */
3596 segT current_seg = now_seg;
3597 subsegT current_subseg = now_subseg;
3599 subseg_set (bss_section, 1);
3600 frag_align (log_align, 0, 0);
3601 record_alignment (bss_section, log_align);
3603 symbol_set_frag (symbolP, frag_now);
3604 pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
3608 S_SET_SEGMENT (symbolP, bss_section);
3610 subseg_set (current_seg, current_subseg);
3614 if (S_GET_VALUE (symbolP))
3616 if (S_GET_VALUE (symbolP) != (valueT) size)
3617 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3618 S_GET_NAME (symbolP),
3619 (long) S_GET_VALUE (symbolP),
3625 S_SET_VALUE (symbolP, (valueT) size);
3627 S_SET_EXTERNAL (symbolP);
3631 know (symbolP->sy_frag == &zero_address_frag);
3633 demand_empty_rest_of_line ();
3636 #endif /* ! OBJ_ELF */
3640 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3641 clears alpha_insn_label and restores auto alignment. */
3644 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED)
3646 get_absolute_expression ();
3647 subseg_new (".rdata", 0);
3648 demand_empty_rest_of_line ();
3649 alpha_insn_label = NULL;
3650 alpha_auto_align_on = 1;
3651 alpha_current_align = 0;
3658 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3659 clears alpha_insn_label and restores auto alignment. */
3662 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED)
3664 get_absolute_expression ();
3665 subseg_new (".sdata", 0);
3666 demand_empty_rest_of_line ();
3667 alpha_insn_label = NULL;
3668 alpha_auto_align_on = 1;
3669 alpha_current_align = 0;
3674 struct alpha_elf_frame_data
3677 symbolS *func_end_sym;
3678 symbolS *prologue_sym;
3684 offsetT mask_offset;
3685 offsetT fmask_offset;
3687 struct alpha_elf_frame_data *next;
3690 static struct alpha_elf_frame_data *all_frame_data;
3691 static struct alpha_elf_frame_data **plast_frame_data = &all_frame_data;
3692 static struct alpha_elf_frame_data *cur_frame_data;
3694 extern int all_cfi_sections;
3696 /* Handle the .section pseudo-op. This is like the usual one, but it
3697 clears alpha_insn_label and restores auto alignment. */
3700 s_alpha_section (int ignore ATTRIBUTE_UNUSED)
3702 obj_elf_section (ignore);
3704 alpha_insn_label = NULL;
3705 alpha_auto_align_on = 1;
3706 alpha_current_align = 0;
3710 s_alpha_ent (int dummy ATTRIBUTE_UNUSED)
3712 if (ECOFF_DEBUGGING)
3713 ecoff_directive_ent (0);
3716 char *name, name_end;
3717 name = input_line_pointer;
3718 name_end = get_symbol_end ();
3719 /* CFI_EMIT_eh_frame is the default. */
3720 all_cfi_sections = CFI_EMIT_eh_frame;
3722 if (! is_name_beginner (*name))
3724 as_warn (_(".ent directive has no name"));
3725 *input_line_pointer = name_end;
3732 as_warn (_("nested .ent directives"));
3734 sym = symbol_find_or_make (name);
3735 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
3737 cur_frame_data = (struct alpha_elf_frame_data *)
3738 calloc (1, sizeof (*cur_frame_data));
3739 cur_frame_data->func_sym = sym;
3741 /* Provide sensible defaults. */
3742 cur_frame_data->fp_regno = 30; /* sp */
3743 cur_frame_data->ra_regno = 26; /* ra */
3745 *plast_frame_data = cur_frame_data;
3746 plast_frame_data = &cur_frame_data->next;
3748 /* The .ent directive is sometimes followed by a number. Not sure
3749 what it really means, but ignore it. */
3750 *input_line_pointer = name_end;
3752 if (*input_line_pointer == ',')
3754 input_line_pointer++;
3757 if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
3758 (void) get_absolute_expression ();
3760 demand_empty_rest_of_line ();
3765 s_alpha_end (int dummy ATTRIBUTE_UNUSED)
3767 if (ECOFF_DEBUGGING)
3768 ecoff_directive_end (0);
3771 char *name, name_end;
3772 name = input_line_pointer;
3773 name_end = get_symbol_end ();
3775 if (! is_name_beginner (*name))
3777 as_warn (_(".end directive has no name"));
3778 *input_line_pointer = name_end;
3784 sym = symbol_find (name);
3785 if (!cur_frame_data)
3786 as_warn (_(".end directive without matching .ent"));
3787 else if (sym != cur_frame_data->func_sym)
3788 as_warn (_(".end directive names different symbol than .ent"));
3790 /* Create an expression to calculate the size of the function. */
3791 if (sym && cur_frame_data)
3793 OBJ_SYMFIELD_TYPE *obj = symbol_get_obj (sym);
3794 expressionS *exp = (expressionS *) xmalloc (sizeof (expressionS));
3797 exp->X_op = O_subtract;
3798 exp->X_add_symbol = symbol_temp_new_now ();
3799 exp->X_op_symbol = sym;
3800 exp->X_add_number = 0;
3802 cur_frame_data->func_end_sym = exp->X_add_symbol;
3805 cur_frame_data = NULL;
3807 *input_line_pointer = name_end;
3809 demand_empty_rest_of_line ();
3814 s_alpha_mask (int fp)
3816 if (ECOFF_DEBUGGING)
3819 ecoff_directive_fmask (0);
3821 ecoff_directive_mask (0);
3828 if (!cur_frame_data)
3831 as_warn (_(".fmask outside of .ent"));
3833 as_warn (_(".mask outside of .ent"));
3834 discard_rest_of_line ();
3838 if (get_absolute_expression_and_terminator (&val) != ',')
3841 as_warn (_("bad .fmask directive"));
3843 as_warn (_("bad .mask directive"));
3844 --input_line_pointer;
3845 discard_rest_of_line ();
3849 offset = get_absolute_expression ();
3850 demand_empty_rest_of_line ();
3854 cur_frame_data->fmask = val;
3855 cur_frame_data->fmask_offset = offset;
3859 cur_frame_data->mask = val;
3860 cur_frame_data->mask_offset = offset;
3866 s_alpha_frame (int dummy ATTRIBUTE_UNUSED)
3868 if (ECOFF_DEBUGGING)
3869 ecoff_directive_frame (0);
3874 if (!cur_frame_data)
3876 as_warn (_(".frame outside of .ent"));
3877 discard_rest_of_line ();
3881 cur_frame_data->fp_regno = tc_get_register (1);
3884 if (*input_line_pointer++ != ','
3885 || get_absolute_expression_and_terminator (&val) != ',')
3887 as_warn (_("bad .frame directive"));
3888 --input_line_pointer;
3889 discard_rest_of_line ();
3892 cur_frame_data->frame_size = val;
3894 cur_frame_data->ra_regno = tc_get_register (0);
3896 /* Next comes the "offset of saved $a0 from $sp". In gcc terms
3897 this is current_function_pretend_args_size. There's no place
3898 to put this value, so ignore it. */
3904 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
3909 arg = get_absolute_expression ();
3910 demand_empty_rest_of_line ();
3911 alpha_prologue_label = symbol_new
3912 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
3914 if (ECOFF_DEBUGGING)
3915 sym = ecoff_get_cur_proc_sym ();
3917 sym = cur_frame_data ? cur_frame_data->func_sym : NULL;
3921 as_bad (_(".prologue directive without a preceding .ent directive"));
3927 case 0: /* No PV required. */
3928 S_SET_OTHER (sym, STO_ALPHA_NOPV
3929 | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
3931 case 1: /* Std GP load. */
3932 S_SET_OTHER (sym, STO_ALPHA_STD_GPLOAD
3933 | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
3935 case 2: /* Non-std use of PV. */
3939 as_bad (_("Invalid argument %d to .prologue."), arg);
3944 cur_frame_data->prologue_sym = symbol_temp_new_now ();
3947 static char *first_file_directive;
3950 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
3952 /* Save the first .file directive we see, so that we can change our
3953 minds about whether ecoff debugging should or shouldn't be enabled. */
3954 if (alpha_flag_mdebug < 0 && ! first_file_directive)
3956 char *start = input_line_pointer;
3959 discard_rest_of_line ();
3961 len = input_line_pointer - start;
3962 first_file_directive = (char *) xmalloc (len + 1);
3963 memcpy (first_file_directive, start, len);
3964 first_file_directive[len] = '\0';
3966 input_line_pointer = start;
3969 if (ECOFF_DEBUGGING)
3970 ecoff_directive_file (0);
3972 dwarf2_directive_file (0);
3976 s_alpha_loc (int ignore ATTRIBUTE_UNUSED)
3978 if (ECOFF_DEBUGGING)
3979 ecoff_directive_loc (0);
3981 dwarf2_directive_loc (0);
3985 s_alpha_stab (int n)
3987 /* If we've been undecided about mdebug, make up our minds in favour. */
3988 if (alpha_flag_mdebug < 0)
3990 segT sec = subseg_new (".mdebug", 0);
3991 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
3992 bfd_set_section_alignment (stdoutput, sec, 3);
3994 ecoff_read_begin_hook ();
3996 if (first_file_directive)
3998 char *save_ilp = input_line_pointer;
3999 input_line_pointer = first_file_directive;
4000 ecoff_directive_file (0);
4001 input_line_pointer = save_ilp;
4002 free (first_file_directive);
4005 alpha_flag_mdebug = 1;
4011 s_alpha_coff_wrapper (int which)
4013 static void (* const fns[]) (int) = {
4014 ecoff_directive_begin,
4015 ecoff_directive_bend,
4016 ecoff_directive_def,
4017 ecoff_directive_dim,
4018 ecoff_directive_endef,
4019 ecoff_directive_scl,
4020 ecoff_directive_tag,
4021 ecoff_directive_val,
4024 gas_assert (which >= 0 && which < (int) (sizeof (fns)/sizeof (*fns)));
4026 if (ECOFF_DEBUGGING)
4030 as_bad (_("ECOFF debugging is disabled."));
4031 ignore_rest_of_line ();
4035 /* Called at the end of assembly. Here we emit unwind info for frames
4036 unless the compiler has done it for us. */
4039 alpha_elf_md_end (void)
4041 struct alpha_elf_frame_data *p;
4044 as_warn (_(".ent directive without matching .end"));
4046 /* If someone has generated the unwind info themselves, great. */
4047 if (bfd_get_section_by_name (stdoutput, ".eh_frame") != NULL)
4050 /* ??? In theory we could look for functions for which we have
4051 generated unwind info via CFI directives, and those we have not.
4052 Those we have not could still get their unwind info from here.
4053 For now, do nothing if we've seen any CFI directives. Note that
4054 the above test will not trigger, as we've not emitted data yet. */
4055 if (all_fde_data != NULL)
4058 /* Generate .eh_frame data for the unwind directives specified. */
4059 for (p = all_frame_data; p ; p = p->next)
4060 if (p->prologue_sym)
4062 /* Create a temporary symbol at the same location as our
4063 function symbol. This prevents problems with globals. */
4064 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p->func_sym),
4065 S_GET_VALUE (p->func_sym),
4066 symbol_get_frag (p->func_sym)));
4068 cfi_set_sections ();
4069 cfi_set_return_column (p->ra_regno);
4070 cfi_add_CFA_def_cfa_register (30);
4071 if (p->fp_regno != 30 || p->mask || p->fmask || p->frame_size)
4076 cfi_add_advance_loc (p->prologue_sym);
4078 if (p->fp_regno != 30)
4079 if (p->frame_size != 0)
4080 cfi_add_CFA_def_cfa (p->fp_regno, p->frame_size);
4082 cfi_add_CFA_def_cfa_register (p->fp_regno);
4083 else if (p->frame_size != 0)
4084 cfi_add_CFA_def_cfa_offset (p->frame_size);
4087 offset = p->mask_offset;
4089 /* Recall that $26 is special-cased and stored first. */
4090 if ((mask >> 26) & 1)
4092 cfi_add_CFA_offset (26, offset);
4103 cfi_add_CFA_offset (i, offset);
4108 offset = p->fmask_offset;
4116 cfi_add_CFA_offset (i + 32, offset);
4121 cfi_end_fde (p->func_end_sym);
4126 s_alpha_usepv (int unused ATTRIBUTE_UNUSED)
4128 char *name, name_end;
4129 char *which, which_end;
4133 name = input_line_pointer;
4134 name_end = get_symbol_end ();
4136 if (! is_name_beginner (*name))
4138 as_bad (_(".usepv directive has no name"));
4139 *input_line_pointer = name_end;
4140 ignore_rest_of_line ();
4144 sym = symbol_find_or_make (name);
4145 *input_line_pointer++ = name_end;
4147 if (name_end != ',')
4149 as_bad (_(".usepv directive has no type"));
4150 ignore_rest_of_line ();
4155 which = input_line_pointer;
4156 which_end = get_symbol_end ();
4158 if (strcmp (which, "no") == 0)
4159 other = STO_ALPHA_NOPV;
4160 else if (strcmp (which, "std") == 0)
4161 other = STO_ALPHA_STD_GPLOAD;
4164 as_bad (_("unknown argument for .usepv"));
4168 *input_line_pointer = which_end;
4169 demand_empty_rest_of_line ();
4171 S_SET_OTHER (sym, other | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
4173 #endif /* OBJ_ELF */
4175 /* Standard calling conventions leaves the CFA at $30 on entry. */
4178 alpha_cfi_frame_initial_instructions (void)
4180 cfi_add_CFA_def_cfa_register (30);
4185 /* Get name of section. */
4187 s_alpha_section_name (void)
4192 if (*input_line_pointer == '"')
4196 name = demand_copy_C_string (&dummy);
4199 ignore_rest_of_line ();
4205 char *end = input_line_pointer;
4207 while (0 == strchr ("\n\t,; ", *end))
4209 if (end == input_line_pointer)
4211 as_warn (_("missing name"));
4212 ignore_rest_of_line ();
4216 name = xmalloc (end - input_line_pointer + 1);
4217 memcpy (name, input_line_pointer, end - input_line_pointer);
4218 name[end - input_line_pointer] = '\0';
4219 input_line_pointer = end;
4225 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4226 the MSBs are the flags to be cleared. */
4228 #define EGPS__V_NO_SHIFT 16
4229 #define EGPS__V_MASK 0xffff
4231 /* Parse one VMS section flag. */
4234 s_alpha_section_word (char *str, size_t len)
4239 if (len == 5 && strncmp (str, "NO", 2) == 0)
4248 if (strncmp (str, "PIC", 3) == 0)
4250 else if (strncmp (str, "LIB", 3) == 0)
4252 else if (strncmp (str, "OVR", 3) == 0)
4254 else if (strncmp (str, "REL", 3) == 0)
4256 else if (strncmp (str, "GBL", 3) == 0)
4258 else if (strncmp (str, "SHR", 3) == 0)
4260 else if (strncmp (str, "EXE", 3) == 0)
4262 else if (strncmp (str, "WRT", 3) == 0)
4264 else if (strncmp (str, "VEC", 3) == 0)
4266 else if (strncmp (str, "MOD", 3) == 0)
4268 flag = no ? EGPS__V_NOMOD : EGPS__V_NOMOD << EGPS__V_NO_SHIFT;
4271 else if (strncmp (str, "COM", 3) == 0)
4279 as_warn (_("unknown section attribute %s"), str);
4285 return flag << EGPS__V_NO_SHIFT;
4290 /* Handle the section specific pseudo-op. */
4292 #define EVAX_SECTION_COUNT 5
4294 static char *section_name[EVAX_SECTION_COUNT + 1] =
4295 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4298 s_alpha_section (int secid)
4302 flagword vms_flags = 0;
4307 name = s_alpha_section_name ();
4310 sec = subseg_new (name, 0);
4311 if (*input_line_pointer == ',')
4313 /* Skip the comma. */
4314 ++input_line_pointer;
4322 beg = input_line_pointer;
4323 c = get_symbol_end ();
4324 *input_line_pointer = c;
4326 vms_flags |= s_alpha_section_word (beg, input_line_pointer - beg);
4330 while (*input_line_pointer++ == ',');
4331 --input_line_pointer;
4334 symbol = symbol_find_or_make (name);
4335 S_SET_SEGMENT (symbol, sec);
4336 symbol_get_bfdsym (symbol)->flags |= BSF_SECTION_SYM;
4337 bfd_vms_set_section_flags
4339 (vms_flags >> EGPS__V_NO_SHIFT) & EGPS__V_MASK,
4340 vms_flags & EGPS__V_MASK);
4344 get_absolute_expression ();
4345 subseg_new (section_name[secid], 0);
4348 demand_empty_rest_of_line ();
4349 alpha_insn_label = NULL;
4350 alpha_auto_align_on = 1;
4351 alpha_current_align = 0;
4355 s_alpha_literals (int ignore ATTRIBUTE_UNUSED)
4357 subseg_new (".literals", 0);
4358 demand_empty_rest_of_line ();
4359 alpha_insn_label = NULL;
4360 alpha_auto_align_on = 1;
4361 alpha_current_align = 0;
4364 /* Parse .ent directives. */
4367 s_alpha_ent (int ignore ATTRIBUTE_UNUSED)
4370 expressionS symexpr;
4372 if (alpha_evax_proc != NULL)
4373 as_bad (_("previous .ent not closed by a .end"));
4375 alpha_evax_proc = &alpha_evax_proc_data;
4377 alpha_evax_proc->pdsckind = 0;
4378 alpha_evax_proc->framereg = -1;
4379 alpha_evax_proc->framesize = 0;
4380 alpha_evax_proc->rsa_offset = 0;
4381 alpha_evax_proc->ra_save = AXP_REG_RA;
4382 alpha_evax_proc->fp_save = -1;
4383 alpha_evax_proc->imask = 0;
4384 alpha_evax_proc->fmask = 0;
4385 alpha_evax_proc->prologue = 0;
4386 alpha_evax_proc->type = 0;
4387 alpha_evax_proc->handler = 0;
4388 alpha_evax_proc->handler_data = 0;
4390 expression (&symexpr);
4392 if (symexpr.X_op != O_symbol)
4394 as_fatal (_(".ent directive has no symbol"));
4395 demand_empty_rest_of_line ();
4399 symbol = make_expr_symbol (&symexpr);
4400 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
4401 alpha_evax_proc->symbol = symbol;
4403 demand_empty_rest_of_line ();
4407 s_alpha_handler (int is_data)
4410 alpha_evax_proc->handler_data = get_absolute_expression ();
4413 char *name, name_end;
4414 name = input_line_pointer;
4415 name_end = get_symbol_end ();
4417 if (! is_name_beginner (*name))
4419 as_warn (_(".handler directive has no name"));
4420 *input_line_pointer = name_end;
4426 sym = symbol_find_or_make (name);
4427 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
4428 alpha_evax_proc->handler = sym;
4429 *input_line_pointer = name_end;
4432 demand_empty_rest_of_line ();
4435 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4438 s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
4443 alpha_evax_proc->framereg = tc_get_register (1);
4446 if (*input_line_pointer++ != ','
4447 || get_absolute_expression_and_terminator (&val) != ',')
4449 as_warn (_("Bad .frame directive 1./2. param"));
4450 --input_line_pointer;
4451 demand_empty_rest_of_line ();
4455 alpha_evax_proc->framesize = val;
4457 ra = tc_get_register (1);
4458 if (ra != AXP_REG_RA)
4459 as_warn (_("Bad RA (%d) register for .frame"), ra);
4462 if (*input_line_pointer++ != ',')
4464 as_warn (_("Bad .frame directive 3./4. param"));
4465 --input_line_pointer;
4466 demand_empty_rest_of_line ();
4469 alpha_evax_proc->rsa_offset = get_absolute_expression ();
4472 /* Parse .prologue. */
4475 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
4477 demand_empty_rest_of_line ();
4478 alpha_prologue_label = symbol_new
4479 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4482 /* Parse .pdesc <entry_name>,{null|stack|reg}
4483 Insert a procedure descriptor. */
4486 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
4493 const char *entry_sym_name;
4494 const char *pdesc_sym_name;
4498 if (now_seg != alpha_link_section)
4500 as_bad (_(".pdesc directive not in link (.link) section"));
4505 if (exp.X_op != O_symbol)
4507 as_bad (_(".pdesc directive has no entry symbol"));
4511 entry_sym = make_expr_symbol (&exp);
4512 entry_sym_name = S_GET_NAME (entry_sym);
4515 len = strlen (entry_sym_name);
4516 if (len < 4 || strcmp (entry_sym_name + len - 4, "..en") != 0)
4518 as_bad (_(".pdesc has a bad entry symbol"));
4522 pdesc_sym_name = S_GET_NAME (alpha_evax_proc->symbol);
4524 if (!alpha_evax_proc
4525 || !S_IS_DEFINED (alpha_evax_proc->symbol)
4526 || strlen (pdesc_sym_name) != len
4527 || memcmp (entry_sym_name, pdesc_sym_name, len) != 0)
4529 as_fatal (_(".pdesc doesn't match with last .ent"));
4533 /* Define pdesc symbol. */
4534 symbol_set_value_now (alpha_evax_proc->symbol);
4536 /* Save bfd symbol of proc entry in function symbol. */
4537 ((struct evax_private_udata_struct *)
4538 symbol_get_bfdsym (alpha_evax_proc->symbol)->udata.p)->enbsym
4539 = symbol_get_bfdsym (entry_sym);
4542 if (*input_line_pointer++ != ',')
4544 as_warn (_("No comma after .pdesc <entryname>"));
4545 demand_empty_rest_of_line ();
4550 name = input_line_pointer;
4551 name_end = get_symbol_end ();
4553 if (strncmp (name, "stack", 5) == 0)
4554 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_STACK;
4556 else if (strncmp (name, "reg", 3) == 0)
4557 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_REGISTER;
4559 else if (strncmp (name, "null", 4) == 0)
4560 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_NULL;
4564 as_fatal (_("unknown procedure kind"));
4565 demand_empty_rest_of_line ();
4569 *input_line_pointer = name_end;
4570 demand_empty_rest_of_line ();
4572 #ifdef md_flush_pending_output
4573 md_flush_pending_output ();
4576 frag_align (3, 0, 0);
4578 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4581 *p = alpha_evax_proc->pdsckind
4582 | ((alpha_evax_proc->framereg == 29) ? PDSC_S_M_BASE_REG_IS_FP : 0)
4583 | ((alpha_evax_proc->handler) ? PDSC_S_M_HANDLER_VALID : 0)
4584 | ((alpha_evax_proc->handler_data) ? PDSC_S_M_HANDLER_DATA_VALID : 0);
4585 *(p + 1) = PDSC_S_M_NATIVE | PDSC_S_M_NO_JACKET;
4587 switch (alpha_evax_proc->pdsckind)
4589 case PDSC_S_K_KIND_NULL:
4593 case PDSC_S_K_KIND_FP_REGISTER:
4594 *(p + 2) = alpha_evax_proc->fp_save;
4595 *(p + 3) = alpha_evax_proc->ra_save;
4597 case PDSC_S_K_KIND_FP_STACK:
4598 md_number_to_chars (p + 2, (valueT) alpha_evax_proc->rsa_offset, 2);
4600 default: /* impossible */
4605 *(p + 5) = alpha_evax_proc->type & 0x0f;
4607 /* Signature offset. */
4608 md_number_to_chars (p + 6, (valueT) 0, 2);
4610 fix_new_exp (frag_now, p - frag_now->fr_literal + 8,
4611 8, &exp, 0, BFD_RELOC_64);
4613 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_NULL)
4616 /* pdesc+16: Size. */
4618 md_number_to_chars (p, (valueT) alpha_evax_proc->framesize, 4);
4619 md_number_to_chars (p + 4, (valueT) 0, 2);
4622 exp.X_op = O_subtract;
4623 exp.X_add_symbol = alpha_prologue_label;
4624 exp.X_op_symbol = entry_sym;
4625 emit_expr (&exp, 2);
4627 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_FP_REGISTER)
4630 /* pdesc+24: register masks. */
4632 md_number_to_chars (p, alpha_evax_proc->imask, 4);
4633 md_number_to_chars (p + 4, alpha_evax_proc->fmask, 4);
4635 if (alpha_evax_proc->handler)
4638 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8,
4639 alpha_evax_proc->handler, 0, 0, BFD_RELOC_64);
4642 if (alpha_evax_proc->handler_data)
4645 md_number_to_chars (p, alpha_evax_proc->handler_data, 8);
4649 /* Support for crash debug on vms. */
4652 s_alpha_name (int ignore ATTRIBUTE_UNUSED)
4657 if (now_seg != alpha_link_section)
4659 as_bad (_(".name directive not in link (.link) section"));
4660 demand_empty_rest_of_line ();
4665 if (exp.X_op != O_symbol)
4667 as_warn (_(".name directive has no symbol"));
4668 demand_empty_rest_of_line ();
4672 demand_empty_rest_of_line ();
4674 #ifdef md_flush_pending_output
4675 md_flush_pending_output ();
4678 frag_align (3, 0, 0);
4681 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0, BFD_RELOC_64);
4684 /* Parse .linkage <symbol>.
4685 Create a linkage pair relocation. */
4688 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED)
4694 #ifdef md_flush_pending_output
4695 md_flush_pending_output ();
4699 if (exp.X_op != O_symbol)
4701 as_fatal (_("No symbol after .linkage"));
4705 struct alpha_linkage_fixups *linkage_fixup;
4707 p = frag_more (LKP_S_K_SIZE);
4708 memset (p, 0, LKP_S_K_SIZE);
4710 (frag_now, p - frag_now->fr_literal, LKP_S_K_SIZE, &exp, 0,
4711 BFD_RELOC_ALPHA_LINKAGE);
4713 if (alpha_insn_label == NULL)
4714 alpha_insn_label = symbol_new
4715 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4717 /* Create a linkage element. */
4718 linkage_fixup = (struct alpha_linkage_fixups *)
4719 xmalloc (sizeof (struct alpha_linkage_fixups));
4720 linkage_fixup->fixp = fixp;
4721 linkage_fixup->next = NULL;
4722 linkage_fixup->label = alpha_insn_label;
4724 /* Append it to the list. */
4725 if (alpha_linkage_fixup_root == NULL)
4726 alpha_linkage_fixup_root = linkage_fixup;
4728 alpha_linkage_fixup_tail->next = linkage_fixup;
4729 alpha_linkage_fixup_tail = linkage_fixup;
4731 demand_empty_rest_of_line ();
4734 /* Parse .code_address <symbol>.
4735 Create a code address relocation. */
4738 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED)
4743 #ifdef md_flush_pending_output
4744 md_flush_pending_output ();
4748 if (exp.X_op != O_symbol)
4749 as_fatal (_("No symbol after .code_address"));
4754 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0,\
4755 BFD_RELOC_ALPHA_CODEADDR);
4757 demand_empty_rest_of_line ();
4761 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED)
4763 alpha_evax_proc->fp_save = tc_get_register (1);
4765 demand_empty_rest_of_line ();
4769 s_alpha_mask (int ignore ATTRIBUTE_UNUSED)
4773 if (get_absolute_expression_and_terminator (&val) != ',')
4775 as_warn (_("Bad .mask directive"));
4776 --input_line_pointer;
4780 alpha_evax_proc->imask = val;
4781 (void) get_absolute_expression ();
4783 demand_empty_rest_of_line ();
4787 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED)
4791 if (get_absolute_expression_and_terminator (&val) != ',')
4793 as_warn (_("Bad .fmask directive"));
4794 --input_line_pointer;
4798 alpha_evax_proc->fmask = val;
4799 (void) get_absolute_expression ();
4801 demand_empty_rest_of_line ();
4805 s_alpha_end (int ignore ATTRIBUTE_UNUSED)
4809 c = get_symbol_end ();
4810 *input_line_pointer = c;
4811 demand_empty_rest_of_line ();
4812 alpha_evax_proc = NULL;
4816 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
4820 static char case_hack[32];
4822 sprintf (case_hack, "<CASE:%01d%01d>",
4823 alpha_flag_hash_long_names, alpha_flag_show_after_trunc);
4825 s = symbol_find_or_make (case_hack);
4826 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4828 get_absolute_expression ();
4829 s = symbol_find_or_make (demand_copy_string (&length));
4830 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4831 demand_empty_rest_of_line ();
4833 #endif /* OBJ_EVAX */
4835 /* Handle the .gprel32 pseudo op. */
4838 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED)
4850 e.X_add_symbol = section_symbol (absolute_section);
4863 e.X_add_symbol = section_symbol (absolute_section);
4866 e.X_op = O_subtract;
4867 e.X_op_symbol = alpha_gp_symbol;
4875 if (alpha_auto_align_on && alpha_current_align < 2)
4876 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
4877 if (alpha_current_align > 2)
4878 alpha_current_align = 2;
4879 alpha_insn_label = NULL;
4883 fix_new_exp (frag_now, p - frag_now->fr_literal, 4,
4884 &e, 0, BFD_RELOC_GPREL32);
4887 /* Handle floating point allocation pseudo-ops. This is like the
4888 generic vresion, but it makes sure the current label, if any, is
4889 correctly aligned. */
4892 s_alpha_float_cons (int type)
4918 if (alpha_auto_align_on && alpha_current_align < log_size)
4919 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
4920 if (alpha_current_align > log_size)
4921 alpha_current_align = log_size;
4922 alpha_insn_label = NULL;
4927 /* Handle the .proc pseudo op. We don't really do much with it except
4931 s_alpha_proc (int is_static ATTRIBUTE_UNUSED)
4939 /* Takes ".proc name,nargs". */
4941 name = input_line_pointer;
4942 c = get_symbol_end ();
4943 p = input_line_pointer;
4944 symbolP = symbol_find_or_make (name);
4947 if (*input_line_pointer != ',')
4950 as_warn (_("Expected comma after name \"%s\""), name);
4953 ignore_rest_of_line ();
4957 input_line_pointer++;
4958 temp = get_absolute_expression ();
4960 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4962 as_warn (_("unhandled: .proc %s,%d"), name, temp);
4963 demand_empty_rest_of_line ();
4966 /* Handle the .set pseudo op. This is used to turn on and off most of
4967 the assembler features. */
4970 s_alpha_set (int x ATTRIBUTE_UNUSED)
4976 name = input_line_pointer;
4977 ch = get_symbol_end ();
4980 if (s[0] == 'n' && s[1] == 'o')
4985 if (!strcmp ("reorder", s))
4987 else if (!strcmp ("at", s))
4988 alpha_noat_on = !yesno;
4989 else if (!strcmp ("macro", s))
4990 alpha_macros_on = yesno;
4991 else if (!strcmp ("move", s))
4993 else if (!strcmp ("volatile", s))
4996 as_warn (_("Tried to .set unrecognized mode `%s'"), name);
4998 *input_line_pointer = ch;
4999 demand_empty_rest_of_line ();
5002 /* Handle the .base pseudo op. This changes the assembler's notion of
5003 the $gp register. */
5006 s_alpha_base (int ignore ATTRIBUTE_UNUSED)
5010 if (*input_line_pointer == '$')
5013 input_line_pointer++;
5014 if (*input_line_pointer == 'r')
5015 input_line_pointer++;
5018 alpha_gp_register = get_absolute_expression ();
5019 if (alpha_gp_register < 0 || alpha_gp_register > 31)
5021 alpha_gp_register = AXP_REG_GP;
5022 as_warn (_("Bad base register, using $%d."), alpha_gp_register);
5025 demand_empty_rest_of_line ();
5028 /* Handle the .align pseudo-op. This aligns to a power of two. It
5029 also adjusts any current instruction label. We treat this the same
5030 way the MIPS port does: .align 0 turns off auto alignment. */
5033 s_alpha_align (int ignore ATTRIBUTE_UNUSED)
5037 long max_alignment = 16;
5039 align = get_absolute_expression ();
5040 if (align > max_alignment)
5042 align = max_alignment;
5043 as_bad (_("Alignment too large: %d. assumed"), align);
5047 as_warn (_("Alignment negative: 0 assumed"));
5051 if (*input_line_pointer == ',')
5053 input_line_pointer++;
5054 fill = get_absolute_expression ();
5062 alpha_auto_align_on = 1;
5063 alpha_align (align, pfill, NULL, 1);
5067 alpha_auto_align_on = 0;
5069 alpha_insn_label = NULL;
5071 demand_empty_rest_of_line ();
5074 /* Hook the normal string processor to reset known alignment. */
5077 s_alpha_stringer (int terminate)
5079 alpha_current_align = 0;
5080 alpha_insn_label = NULL;
5081 stringer (8 + terminate);
5084 /* Hook the normal space processing to reset known alignment. */
5087 s_alpha_space (int ignore)
5089 alpha_current_align = 0;
5090 alpha_insn_label = NULL;
5094 /* Hook into cons for auto-alignment. */
5097 alpha_cons_align (int size)
5102 while ((size >>= 1) != 0)
5105 if (alpha_auto_align_on && alpha_current_align < log_size)
5106 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
5107 if (alpha_current_align > log_size)
5108 alpha_current_align = log_size;
5109 alpha_insn_label = NULL;
5112 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5113 pseudos. We just turn off auto-alignment and call down to cons. */
5116 s_alpha_ucons (int bytes)
5118 int hold = alpha_auto_align_on;
5119 alpha_auto_align_on = 0;
5121 alpha_auto_align_on = hold;
5124 /* Switch the working cpu type. */
5127 s_alpha_arch (int ignored ATTRIBUTE_UNUSED)
5130 const struct cpu_type *p;
5133 name = input_line_pointer;
5134 ch = get_symbol_end ();
5136 for (p = cpu_types; p->name; ++p)
5137 if (strcmp (name, p->name) == 0)
5139 alpha_target_name = p->name, alpha_target = p->flags;
5142 as_warn (_("Unknown CPU identifier `%s'"), name);
5145 *input_line_pointer = ch;
5146 demand_empty_rest_of_line ();
5150 /* print token expression with alpha specific extension. */
5153 alpha_print_token (FILE *f, const expressionS *exp)
5163 expressionS nexp = *exp;
5164 nexp.X_op = O_register;
5165 print_expr_1 (f, &nexp);
5170 print_expr_1 (f, exp);
5176 /* The target specific pseudo-ops which we support. */
5178 const pseudo_typeS md_pseudo_table[] =
5181 {"comm", s_alpha_comm, 0}, /* OSF1 compiler does this. */
5182 {"rdata", s_alpha_rdata, 0},
5184 {"text", s_alpha_text, 0},
5185 {"data", s_alpha_data, 0},
5187 {"sdata", s_alpha_sdata, 0},
5190 {"section", s_alpha_section, 0},
5191 {"section.s", s_alpha_section, 0},
5192 {"sect", s_alpha_section, 0},
5193 {"sect.s", s_alpha_section, 0},
5196 {"section", s_alpha_section, 0},
5197 {"literals", s_alpha_literals, 0},
5198 {"pdesc", s_alpha_pdesc, 0},
5199 {"name", s_alpha_name, 0},
5200 {"linkage", s_alpha_linkage, 0},
5201 {"code_address", s_alpha_code_address, 0},
5202 {"ent", s_alpha_ent, 0},
5203 {"frame", s_alpha_frame, 0},
5204 {"fp_save", s_alpha_fp_save, 0},
5205 {"mask", s_alpha_mask, 0},
5206 {"fmask", s_alpha_fmask, 0},
5207 {"end", s_alpha_end, 0},
5208 {"file", s_alpha_file, 0},
5209 {"rdata", s_alpha_section, 1},
5210 {"comm", s_alpha_comm, 0},
5211 {"link", s_alpha_section, 3},
5212 {"ctors", s_alpha_section, 4},
5213 {"dtors", s_alpha_section, 5},
5214 {"handler", s_alpha_handler, 0},
5215 {"handler_data", s_alpha_handler, 1},
5218 /* Frame related pseudos. */
5219 {"ent", s_alpha_ent, 0},
5220 {"end", s_alpha_end, 0},
5221 {"mask", s_alpha_mask, 0},
5222 {"fmask", s_alpha_mask, 1},
5223 {"frame", s_alpha_frame, 0},
5224 {"prologue", s_alpha_prologue, 0},
5225 {"file", s_alpha_file, 5},
5226 {"loc", s_alpha_loc, 9},
5227 {"stabs", s_alpha_stab, 's'},
5228 {"stabn", s_alpha_stab, 'n'},
5229 {"usepv", s_alpha_usepv, 0},
5230 /* COFF debugging related pseudos. */
5231 {"begin", s_alpha_coff_wrapper, 0},
5232 {"bend", s_alpha_coff_wrapper, 1},
5233 {"def", s_alpha_coff_wrapper, 2},
5234 {"dim", s_alpha_coff_wrapper, 3},
5235 {"endef", s_alpha_coff_wrapper, 4},
5236 {"scl", s_alpha_coff_wrapper, 5},
5237 {"tag", s_alpha_coff_wrapper, 6},
5238 {"val", s_alpha_coff_wrapper, 7},
5241 {"prologue", s_alpha_prologue, 0},
5243 {"prologue", s_ignore, 0},
5246 {"gprel32", s_alpha_gprel32, 0},
5247 {"t_floating", s_alpha_float_cons, 'd'},
5248 {"s_floating", s_alpha_float_cons, 'f'},
5249 {"f_floating", s_alpha_float_cons, 'F'},
5250 {"g_floating", s_alpha_float_cons, 'G'},
5251 {"d_floating", s_alpha_float_cons, 'D'},
5253 {"proc", s_alpha_proc, 0},
5254 {"aproc", s_alpha_proc, 1},
5255 {"set", s_alpha_set, 0},
5256 {"reguse", s_ignore, 0},
5257 {"livereg", s_ignore, 0},
5258 {"base", s_alpha_base, 0}, /*??*/
5259 {"option", s_ignore, 0},
5260 {"aent", s_ignore, 0},
5261 {"ugen", s_ignore, 0},
5262 {"eflag", s_ignore, 0},
5264 {"align", s_alpha_align, 0},
5265 {"double", s_alpha_float_cons, 'd'},
5266 {"float", s_alpha_float_cons, 'f'},
5267 {"single", s_alpha_float_cons, 'f'},
5268 {"ascii", s_alpha_stringer, 0},
5269 {"asciz", s_alpha_stringer, 1},
5270 {"string", s_alpha_stringer, 1},
5271 {"space", s_alpha_space, 0},
5272 {"skip", s_alpha_space, 0},
5273 {"zero", s_alpha_space, 0},
5275 /* Unaligned data pseudos. */
5276 {"uword", s_alpha_ucons, 2},
5277 {"ulong", s_alpha_ucons, 4},
5278 {"uquad", s_alpha_ucons, 8},
5281 /* Dwarf wants these versions of unaligned. */
5282 {"2byte", s_alpha_ucons, 2},
5283 {"4byte", s_alpha_ucons, 4},
5284 {"8byte", s_alpha_ucons, 8},
5287 /* We don't do any optimizing, so we can safely ignore these. */
5288 {"noalias", s_ignore, 0},
5289 {"alias", s_ignore, 0},
5291 {"arch", s_alpha_arch, 0},
5298 /* @@@ GP selection voodoo. All of this seems overly complicated and
5299 unnecessary; which is the primary reason it's for ECOFF only. */
5302 maybe_set_gp (asection *sec)
5308 vma = bfd_get_section_vma (sec->owner, sec);
5309 if (vma && vma < alpha_gp_value)
5310 alpha_gp_value = vma;
5314 select_gp_value (void)
5316 gas_assert (alpha_gp_value == 0);
5318 /* Get minus-one in whatever width... */
5322 /* Select the smallest VMA of these existing sections. */
5323 maybe_set_gp (alpha_lita_section);
5325 /* @@ Will a simple 0x8000 work here? If not, why not? */
5326 #define GP_ADJUSTMENT (0x8000 - 0x10)
5328 alpha_gp_value += GP_ADJUSTMENT;
5330 S_SET_VALUE (alpha_gp_symbol, alpha_gp_value);
5333 printf (_("Chose GP value of %lx\n"), alpha_gp_value);
5336 #endif /* OBJ_ECOFF */
5339 /* Map 's' to SHF_ALPHA_GPREL. */
5342 alpha_elf_section_letter (int letter, char **ptr_msg)
5345 return SHF_ALPHA_GPREL;
5347 *ptr_msg = _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5351 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5354 alpha_elf_section_flags (flagword flags, bfd_vma attr, int type ATTRIBUTE_UNUSED)
5356 if (attr & SHF_ALPHA_GPREL)
5357 flags |= SEC_SMALL_DATA;
5360 #endif /* OBJ_ELF */
5362 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5363 of an rs_align_code fragment. */
5366 alpha_handle_align (fragS *fragp)
5368 static char const unop[4] = { 0x00, 0x00, 0xfe, 0x2f };
5369 static char const nopunop[8] =
5371 0x1f, 0x04, 0xff, 0x47,
5372 0x00, 0x00, 0xfe, 0x2f
5378 if (fragp->fr_type != rs_align_code)
5381 bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
5382 p = fragp->fr_literal + fragp->fr_fix;
5395 memcpy (p, unop, 4);
5401 memcpy (p, nopunop, 8);
5403 fragp->fr_fix += fix;
5407 /* Public interface functions. */
5409 /* This function is called once, at assembler startup time. It sets
5410 up all the tables, etc. that the MD part of the assembler will
5411 need, that can be determined before arguments are parsed. */
5418 /* Verify that X_op field is wide enough. */
5423 gas_assert (e.X_op == O_max);
5426 /* Create the opcode hash table. */
5427 alpha_opcode_hash = hash_new ();
5429 for (i = 0; i < alpha_num_opcodes;)
5431 const char *name, *retval, *slash;
5433 name = alpha_opcodes[i].name;
5434 retval = hash_insert (alpha_opcode_hash, name, (void *) &alpha_opcodes[i]);
5436 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5439 /* Some opcodes include modifiers of various sorts with a "/mod"
5440 syntax, like the architecture manual suggests. However, for
5441 use with gcc at least, we also need access to those same opcodes
5444 if ((slash = strchr (name, '/')) != NULL)
5446 char *p = (char *) xmalloc (strlen (name));
5448 memcpy (p, name, slash - name);
5449 strcpy (p + (slash - name), slash + 1);
5451 (void) hash_insert (alpha_opcode_hash, p, (void *) &alpha_opcodes[i]);
5452 /* Ignore failures -- the opcode table does duplicate some
5453 variants in different forms, like "hw_stq" and "hw_st/q". */
5456 while (++i < alpha_num_opcodes
5457 && (alpha_opcodes[i].name == name
5458 || !strcmp (alpha_opcodes[i].name, name)))
5462 /* Create the macro hash table. */
5463 alpha_macro_hash = hash_new ();
5465 for (i = 0; i < alpha_num_macros;)
5467 const char *name, *retval;
5469 name = alpha_macros[i].name;
5470 retval = hash_insert (alpha_macro_hash, name, (void *) &alpha_macros[i]);
5472 as_fatal (_("internal error: can't hash macro `%s': %s"),
5475 while (++i < alpha_num_macros
5476 && (alpha_macros[i].name == name
5477 || !strcmp (alpha_macros[i].name, name)))
5481 /* Construct symbols for each of the registers. */
5482 for (i = 0; i < 32; ++i)
5486 sprintf (name, "$%d", i);
5487 alpha_register_table[i] = symbol_create (name, reg_section, i,
5488 &zero_address_frag);
5495 sprintf (name, "$f%d", i - 32);
5496 alpha_register_table[i] = symbol_create (name, reg_section, i,
5497 &zero_address_frag);
5500 /* Create the special symbols and sections we'll be using. */
5502 /* So .sbss will get used for tiny objects. */
5503 bfd_set_gp_size (stdoutput, g_switch_value);
5506 create_literal_section (".lita", &alpha_lita_section, &alpha_lita_symbol);
5508 /* For handling the GP, create a symbol that won't be output in the
5509 symbol table. We'll edit it out of relocs later. */
5510 alpha_gp_symbol = symbol_create ("<GP value>", alpha_lita_section, 0x8000,
5511 &zero_address_frag);
5515 create_literal_section (".link", &alpha_link_section, &alpha_link_symbol);
5519 if (ECOFF_DEBUGGING)
5521 segT sec = subseg_new (".mdebug", (subsegT) 0);
5522 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
5523 bfd_set_section_alignment (stdoutput, sec, 3);
5527 /* Create literal lookup hash table. */
5528 alpha_literal_hash = hash_new ();
5530 subseg_set (text_section, 0);
5533 /* The public interface to the instruction assembler. */
5536 md_assemble (char *str)
5538 /* Current maximum is 13. */
5540 expressionS tok[MAX_INSN_ARGS];
5544 /* Split off the opcode. */
5545 opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/46819");
5546 trunclen = (opnamelen < sizeof (opname) - 1
5548 : sizeof (opname) - 1);
5549 memcpy (opname, str, trunclen);
5550 opname[trunclen] = '\0';
5552 /* Tokenize the rest of the line. */
5553 if ((ntok = tokenize_arguments (str + opnamelen, tok, MAX_INSN_ARGS)) < 0)
5555 if (ntok != TOKENIZE_ERROR_REPORT)
5556 as_bad (_("syntax error"));
5561 /* Finish it off. */
5562 assemble_tokens (opname, tok, ntok, alpha_macros_on);
5565 /* Round up a section's size to the appropriate boundary. */
5568 md_section_align (segT seg, valueT size)
5570 int align = bfd_get_section_alignment (stdoutput, seg);
5571 valueT mask = ((valueT) 1 << align) - 1;
5573 return (size + mask) & ~mask;
5576 /* Turn a string in input_line_pointer into a floating point constant
5577 of type TYPE, and store the appropriate bytes in *LITP. The number
5578 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5579 returned, or NULL on OK. */
5582 md_atof (int type, char *litP, int *sizeP)
5584 extern char *vax_md_atof (int, char *, int *);
5590 /* vax_md_atof() doesn't like "G" for some reason. */
5594 return vax_md_atof (type, litP, sizeP);
5597 return ieee_md_atof (type, litP, sizeP, FALSE);
5601 /* Take care of the target-specific command-line options. */
5604 md_parse_option (int c, char *arg)
5609 alpha_nofloats_on = 1;
5613 alpha_addr32_on = 1;
5621 g_switch_value = atoi (arg);
5626 const struct cpu_type *p;
5628 for (p = cpu_types; p->name; ++p)
5629 if (strcmp (arg, p->name) == 0)
5631 alpha_target_name = p->name, alpha_target = p->flags;
5634 as_warn (_("Unknown CPU identifier `%s'"), arg);
5640 case '+': /* For g++. Hash any name > 63 chars long. */
5641 alpha_flag_hash_long_names = 1;
5644 case 'H': /* Show new symbol after hash truncation. */
5645 alpha_flag_show_after_trunc = 1;
5648 case 'h': /* For gnu-c/vax compatibility. */
5651 case OPTION_REPLACE:
5652 alpha_flag_replace = 1;
5655 case OPTION_NOREPLACE:
5656 alpha_flag_replace = 0;
5661 alpha_flag_relax = 1;
5666 alpha_flag_mdebug = 1;
5668 case OPTION_NO_MDEBUG:
5669 alpha_flag_mdebug = 0;
5680 /* Print a description of the command-line options that we accept. */
5683 md_show_usage (FILE *stream)
5687 -32addr treat addresses as 32-bit values\n\
5688 -F lack floating point instructions support\n\
5689 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5690 specify variant of Alpha architecture\n\
5691 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5692 these variants include PALcode opcodes\n"),
5697 -+ encode (don't truncate) names longer than 64 characters\n\
5698 -H show new symbol after hash truncation\n\
5699 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5704 /* Decide from what point a pc-relative relocation is relative to,
5705 relative to the pc-relative fixup. Er, relatively speaking. */
5708 md_pcrel_from (fixS *fixP)
5710 valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5712 switch (fixP->fx_r_type)
5714 case BFD_RELOC_23_PCREL_S2:
5715 case BFD_RELOC_ALPHA_HINT:
5716 case BFD_RELOC_ALPHA_BRSGP:
5723 /* Attempt to simplify or even eliminate a fixup. The return value is
5724 ignored; perhaps it was once meaningful, but now it is historical.
5725 To indicate that a fixup has been eliminated, set fixP->fx_done.
5727 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5728 internally into the GPDISP reloc used externally. We had to do
5729 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5730 the distance to the "lda" instruction for setting the addend to
5734 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
5736 char * const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5737 valueT value = * valP;
5738 unsigned image, size;
5740 switch (fixP->fx_r_type)
5742 /* The GPDISP relocations are processed internally with a symbol
5743 referring to the current function's section; we need to drop
5744 in a value which, when added to the address of the start of
5745 the function, gives the desired GP. */
5746 case BFD_RELOC_ALPHA_GPDISP_HI16:
5748 fixS *next = fixP->fx_next;
5750 /* With user-specified !gpdisp relocations, we can be missing
5751 the matching LO16 reloc. We will have already issued an
5754 fixP->fx_offset = (next->fx_frag->fr_address + next->fx_where
5755 - fixP->fx_frag->fr_address - fixP->fx_where);
5757 value = (value - sign_extend_16 (value)) >> 16;
5760 fixP->fx_r_type = BFD_RELOC_ALPHA_GPDISP;
5764 case BFD_RELOC_ALPHA_GPDISP_LO16:
5765 value = sign_extend_16 (value);
5766 fixP->fx_offset = 0;
5772 fixP->fx_addsy = section_symbol (seg);
5773 md_number_to_chars (fixpos, value, 2);
5778 fixP->fx_r_type = BFD_RELOC_16_PCREL;
5784 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5790 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5794 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5796 md_number_to_chars (fixpos, value, size);
5802 case BFD_RELOC_GPREL32:
5803 gas_assert (fixP->fx_subsy == alpha_gp_symbol);
5805 /* FIXME: inherited this obliviousness of `value' -- why? */
5806 md_number_to_chars (fixpos, -alpha_gp_value, 4);
5809 case BFD_RELOC_GPREL32:
5811 case BFD_RELOC_GPREL16:
5812 case BFD_RELOC_ALPHA_GPREL_HI16:
5813 case BFD_RELOC_ALPHA_GPREL_LO16:
5816 case BFD_RELOC_23_PCREL_S2:
5817 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5819 image = bfd_getl32 (fixpos);
5820 image = (image & ~0x1FFFFF) | ((value >> 2) & 0x1FFFFF);
5825 case BFD_RELOC_ALPHA_HINT:
5826 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5828 image = bfd_getl32 (fixpos);
5829 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5835 case BFD_RELOC_ALPHA_BRSGP:
5838 case BFD_RELOC_ALPHA_TLSGD:
5839 case BFD_RELOC_ALPHA_TLSLDM:
5840 case BFD_RELOC_ALPHA_GOTDTPREL16:
5841 case BFD_RELOC_ALPHA_DTPREL_HI16:
5842 case BFD_RELOC_ALPHA_DTPREL_LO16:
5843 case BFD_RELOC_ALPHA_DTPREL16:
5844 case BFD_RELOC_ALPHA_GOTTPREL16:
5845 case BFD_RELOC_ALPHA_TPREL_HI16:
5846 case BFD_RELOC_ALPHA_TPREL_LO16:
5847 case BFD_RELOC_ALPHA_TPREL16:
5849 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5854 case BFD_RELOC_ALPHA_LITERAL:
5855 md_number_to_chars (fixpos, value, 2);
5858 case BFD_RELOC_ALPHA_ELF_LITERAL:
5859 case BFD_RELOC_ALPHA_LITUSE:
5860 case BFD_RELOC_ALPHA_LINKAGE:
5861 case BFD_RELOC_ALPHA_CODEADDR:
5865 case BFD_RELOC_ALPHA_NOP:
5866 value -= (8 + 4); /* PC-relative, base is jsr+4. */
5868 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5869 "Finally, the ETIR$C_STC_BSR command passes the same address
5870 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5871 and the same test is done again." */
5872 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5874 fixP->fx_addnumber = -value;
5878 if ((abs (value) >> 2) & ~0xfffff)
5882 /* Change to a nop. */
5887 case BFD_RELOC_ALPHA_LDA:
5888 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5889 the value for an O_subtract. */
5891 && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5893 fixP->fx_addnumber = symbol_get_bfdsym (fixP->fx_subsy)->value;
5897 if ((abs (value)) & ~0x7fff)
5901 /* Change to an lda. */
5902 image = 0x237B0000 | (value & 0xFFFF);
5906 case BFD_RELOC_ALPHA_BSR:
5907 case BFD_RELOC_ALPHA_BOH:
5908 value -= 4; /* PC-relative, base is jsr+4. */
5910 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5911 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5913 fixP->fx_addnumber = -value;
5917 if ((abs (value) >> 2) & ~0xfffff)
5920 if (fixP->fx_r_type == BFD_RELOC_ALPHA_BOH)
5923 image = bfd_getl32(fixpos);
5924 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5931 /* Change to a branch. */
5932 image = 0xD3400000 | ((value >> 2) & 0x1FFFFF);
5937 case BFD_RELOC_VTABLE_INHERIT:
5938 case BFD_RELOC_VTABLE_ENTRY:
5943 const struct alpha_operand *operand;
5945 if ((int) fixP->fx_r_type >= 0)
5946 as_fatal (_("unhandled relocation type %s"),
5947 bfd_get_reloc_code_name (fixP->fx_r_type));
5949 gas_assert (-(int) fixP->fx_r_type < (int) alpha_num_operands);
5950 operand = &alpha_operands[-(int) fixP->fx_r_type];
5952 /* The rest of these fixups only exist internally during symbol
5953 resolution and have no representation in the object file.
5954 Therefore they must be completely resolved as constants. */
5956 if (fixP->fx_addsy != 0
5957 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
5958 as_bad_where (fixP->fx_file, fixP->fx_line,
5959 _("non-absolute expression in constant field"));
5961 image = bfd_getl32 (fixpos);
5962 image = insert_operand (image, operand, (offsetT) value,
5963 fixP->fx_file, fixP->fx_line);
5968 if (fixP->fx_addsy != 0 || fixP->fx_pcrel != 0)
5972 as_warn_where (fixP->fx_file, fixP->fx_line,
5973 _("type %d reloc done?\n"), (int) fixP->fx_r_type);
5978 md_number_to_chars (fixpos, image, 4);
5984 /* Look for a register name in the given symbol. */
5987 md_undefined_symbol (char *name)
5991 int is_float = 0, num;
5996 if (name[1] == 'p' && name[2] == '\0')
5997 return alpha_register_table[AXP_REG_FP];
6002 if (!ISDIGIT (*++name))
6006 case '0': case '1': case '2': case '3': case '4':
6007 case '5': case '6': case '7': case '8': case '9':
6008 if (name[1] == '\0')
6009 num = name[0] - '0';
6010 else if (name[0] != '0' && ISDIGIT (name[1]) && name[2] == '\0')
6012 num = (name[0] - '0') * 10 + name[1] - '0';
6019 if (!alpha_noat_on && (num + is_float) == AXP_REG_AT)
6020 as_warn (_("Used $at without \".set noat\""));
6021 return alpha_register_table[num + is_float];
6024 if (name[1] == 't' && name[2] == '\0')
6027 as_warn (_("Used $at without \".set noat\""));
6028 return alpha_register_table[AXP_REG_AT];
6033 if (name[1] == 'p' && name[2] == '\0')
6034 return alpha_register_table[alpha_gp_register];
6038 if (name[1] == 'p' && name[2] == '\0')
6039 return alpha_register_table[AXP_REG_SP];
6047 /* @@@ Magic ECOFF bits. */
6050 alpha_frob_ecoff_data (void)
6053 /* $zero and $f31 are read-only. */
6054 alpha_gprmask &= ~1;
6055 alpha_fprmask &= ~1;
6059 /* Hook to remember a recently defined label so that the auto-align
6060 code can adjust the symbol after we know what alignment will be
6064 alpha_define_label (symbolS *sym)
6066 alpha_insn_label = sym;
6068 dwarf2_emit_label (sym);
6072 /* Return true if we must always emit a reloc for a type and false if
6073 there is some hope of resolving it at assembly time. */
6076 alpha_force_relocation (fixS *f)
6078 if (alpha_flag_relax)
6081 switch (f->fx_r_type)
6083 case BFD_RELOC_ALPHA_GPDISP_HI16:
6084 case BFD_RELOC_ALPHA_GPDISP_LO16:
6085 case BFD_RELOC_ALPHA_GPDISP:
6086 case BFD_RELOC_ALPHA_LITERAL:
6087 case BFD_RELOC_ALPHA_ELF_LITERAL:
6088 case BFD_RELOC_ALPHA_LITUSE:
6089 case BFD_RELOC_GPREL16:
6090 case BFD_RELOC_GPREL32:
6091 case BFD_RELOC_ALPHA_GPREL_HI16:
6092 case BFD_RELOC_ALPHA_GPREL_LO16:
6093 case BFD_RELOC_ALPHA_LINKAGE:
6094 case BFD_RELOC_ALPHA_CODEADDR:
6095 case BFD_RELOC_ALPHA_BRSGP:
6096 case BFD_RELOC_ALPHA_TLSGD:
6097 case BFD_RELOC_ALPHA_TLSLDM:
6098 case BFD_RELOC_ALPHA_GOTDTPREL16:
6099 case BFD_RELOC_ALPHA_DTPREL_HI16:
6100 case BFD_RELOC_ALPHA_DTPREL_LO16:
6101 case BFD_RELOC_ALPHA_DTPREL16:
6102 case BFD_RELOC_ALPHA_GOTTPREL16:
6103 case BFD_RELOC_ALPHA_TPREL_HI16:
6104 case BFD_RELOC_ALPHA_TPREL_LO16:
6105 case BFD_RELOC_ALPHA_TPREL16:
6107 case BFD_RELOC_ALPHA_NOP:
6108 case BFD_RELOC_ALPHA_BSR:
6109 case BFD_RELOC_ALPHA_LDA:
6110 case BFD_RELOC_ALPHA_BOH:
6118 return generic_force_reloc (f);
6121 /* Return true if we can partially resolve a relocation now. */
6124 alpha_fix_adjustable (fixS *f)
6126 /* Are there any relocation types for which we must generate a
6127 reloc but we can adjust the values contained within it? */
6128 switch (f->fx_r_type)
6130 case BFD_RELOC_ALPHA_GPDISP_HI16:
6131 case BFD_RELOC_ALPHA_GPDISP_LO16:
6132 case BFD_RELOC_ALPHA_GPDISP:
6135 case BFD_RELOC_ALPHA_LITERAL:
6136 case BFD_RELOC_ALPHA_ELF_LITERAL:
6137 case BFD_RELOC_ALPHA_LITUSE:
6138 case BFD_RELOC_ALPHA_LINKAGE:
6139 case BFD_RELOC_ALPHA_CODEADDR:
6142 case BFD_RELOC_VTABLE_ENTRY:
6143 case BFD_RELOC_VTABLE_INHERIT:
6146 case BFD_RELOC_GPREL16:
6147 case BFD_RELOC_GPREL32:
6148 case BFD_RELOC_ALPHA_GPREL_HI16:
6149 case BFD_RELOC_ALPHA_GPREL_LO16:
6150 case BFD_RELOC_23_PCREL_S2:
6154 case BFD_RELOC_ALPHA_HINT:
6157 case BFD_RELOC_ALPHA_TLSGD:
6158 case BFD_RELOC_ALPHA_TLSLDM:
6159 case BFD_RELOC_ALPHA_GOTDTPREL16:
6160 case BFD_RELOC_ALPHA_DTPREL_HI16:
6161 case BFD_RELOC_ALPHA_DTPREL_LO16:
6162 case BFD_RELOC_ALPHA_DTPREL16:
6163 case BFD_RELOC_ALPHA_GOTTPREL16:
6164 case BFD_RELOC_ALPHA_TPREL_HI16:
6165 case BFD_RELOC_ALPHA_TPREL_LO16:
6166 case BFD_RELOC_ALPHA_TPREL16:
6167 /* ??? No idea why we can't return a reference to .tbss+10, but
6168 we're preventing this in the other assemblers. Follow for now. */
6172 case BFD_RELOC_ALPHA_BRSGP:
6173 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6174 let it get resolved at assembly time. */
6176 symbolS *sym = f->fx_addsy;
6180 if (generic_force_reloc (f))
6183 switch (S_GET_OTHER (sym) & STO_ALPHA_STD_GPLOAD)
6185 case STO_ALPHA_NOPV:
6187 case STO_ALPHA_STD_GPLOAD:
6191 if (S_IS_LOCAL (sym))
6194 name = S_GET_NAME (sym);
6195 as_bad_where (f->fx_file, f->fx_line,
6196 _("!samegp reloc against symbol without .prologue: %s"),
6200 f->fx_r_type = BFD_RELOC_23_PCREL_S2;
6201 f->fx_offset += offset;
6206 case BFD_RELOC_ALPHA_NOP:
6207 case BFD_RELOC_ALPHA_BSR:
6208 case BFD_RELOC_ALPHA_LDA:
6209 case BFD_RELOC_ALPHA_BOH:
6218 /* Generate the BFD reloc to be stuck in the object file from the
6219 fixup used internally in the assembler. */
6222 tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED,
6227 reloc = (arelent *) xmalloc (sizeof (* reloc));
6228 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6229 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6230 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6232 /* Make sure none of our internal relocations make it this far.
6233 They'd better have been fully resolved by this point. */
6234 gas_assert ((int) fixp->fx_r_type > 0);
6236 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6237 if (reloc->howto == NULL)
6239 as_bad_where (fixp->fx_file, fixp->fx_line,
6240 _("cannot represent `%s' relocation in object file"),
6241 bfd_get_reloc_code_name (fixp->fx_r_type));
6245 if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
6246 as_fatal (_("internal error? cannot generate `%s' relocation"),
6247 bfd_get_reloc_code_name (fixp->fx_r_type));
6249 gas_assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
6251 reloc->addend = fixp->fx_offset;
6254 /* Fake out bfd_perform_relocation. sigh. */
6255 /* ??? Better would be to use the special_function hook. */
6256 if (fixp->fx_r_type == BFD_RELOC_ALPHA_LITERAL)
6257 reloc->addend = -alpha_gp_value;
6261 switch (fixp->fx_r_type)
6263 struct evax_private_udata_struct *udata;
6267 case BFD_RELOC_ALPHA_LINKAGE:
6268 /* Copy the linkage index. */
6269 reloc->addend = fixp->fx_addnumber;
6272 case BFD_RELOC_ALPHA_NOP:
6273 case BFD_RELOC_ALPHA_BSR:
6274 case BFD_RELOC_ALPHA_LDA:
6275 case BFD_RELOC_ALPHA_BOH:
6276 pname = symbol_get_bfdsym (fixp->fx_addsy)->name;
6278 /* We need the non-suffixed name of the procedure. Beware that
6279 the main symbol might be equated so look it up and take its name. */
6280 pname_len = strlen (pname);
6281 if (pname_len > 4 && strcmp (pname + pname_len - 4, "..en") == 0)
6284 char *my_pname = (char *) alloca (pname_len - 4 + 1);
6286 memcpy (my_pname, pname, pname_len - 4);
6287 my_pname [pname_len - 4] = 0;
6288 sym = symbol_find (my_pname);
6292 while (symbol_equated_reloc_p (sym))
6294 symbolS *n = symbol_get_value_expression (sym)->X_add_symbol;
6296 /* We must avoid looping, as that can occur with a badly
6302 pname = symbol_get_bfdsym (sym)->name;
6305 udata = (struct evax_private_udata_struct *)
6306 xmalloc (sizeof (struct evax_private_udata_struct));
6307 udata->enbsym = symbol_get_bfdsym (fixp->fx_addsy);
6308 udata->bsym = symbol_get_bfdsym (fixp->tc_fix_data.info->psym);
6309 udata->origname = (char *)pname;
6310 udata->lkindex = ((struct evax_private_udata_struct *)
6311 symbol_get_bfdsym (fixp->tc_fix_data.info->sym)->udata.p)->lkindex;
6312 reloc->sym_ptr_ptr = (void *)udata;
6313 reloc->addend = fixp->fx_addnumber;
6323 /* Parse a register name off of the input_line and return a register
6324 number. Gets md_undefined_symbol above to do the register name
6327 Only called as a part of processing the ECOFF .frame directive. */
6330 tc_get_register (int frame ATTRIBUTE_UNUSED)
6332 int framereg = AXP_REG_SP;
6335 if (*input_line_pointer == '$')
6337 char *s = input_line_pointer;
6338 char c = get_symbol_end ();
6339 symbolS *sym = md_undefined_symbol (s);
6341 *strchr (s, '\0') = c;
6342 if (sym && (framereg = S_GET_VALUE (sym)) <= 31)
6345 as_warn (_("frame reg expected, using $%d."), framereg);
6348 note_gpreg (framereg);
6352 /* This is called before the symbol table is processed. In order to
6353 work with gcc when using mips-tfile, we must keep all local labels.
6354 However, in other cases, we want to discard them. If we were
6355 called with -g, but we didn't see any debugging information, it may
6356 mean that gcc is smuggling debugging information through to
6357 mips-tfile, in which case we must generate all local labels. */
6362 alpha_frob_file_before_adjust (void)
6364 if (alpha_debug != 0
6365 && ! ecoff_debugging_seen)
6366 flag_keep_locals = 1;
6369 #endif /* OBJ_ECOFF */
6371 /* The Alpha has support for some VAX floating point types, as well as for
6372 IEEE floating point. We consider IEEE to be the primary floating point
6373 format, and sneak in the VAX floating point support here. */
6374 #include "config/atof-vax.c"