1 /* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
2 Copyright (C) 1989-2016 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 const 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 c = get_symbol_name (&p);
926 /* Parse !relocation_type. */
927 len = input_line_pointer - p;
930 as_bad (_("No relocation operand"));
934 r = &alpha_reloc_op[0];
935 for (i = alpha_num_reloc_op - 1; i >= 0; i--, r++)
936 if (len == r->length && memcmp (p, r->name, len) == 0)
940 as_bad (_("Unknown relocation operand: !%s"), p);
944 *input_line_pointer = c;
945 SKIP_WHITESPACE_AFTER_NAME ();
946 if (*input_line_pointer != '!')
950 as_bad (_("no sequence number after !%s"), p);
954 tok->X_add_number = 0;
960 as_bad (_("!%s does not use a sequence number"), p);
964 input_line_pointer++;
966 /* Parse !sequence_number. */
968 if (tok->X_op != O_constant || tok->X_add_number <= 0)
970 as_bad (_("Bad sequence number: !%s!%s"),
971 r->name, input_line_pointer);
980 #endif /* RELOC_OP_P */
983 ++input_line_pointer;
984 if (saw_comma || !saw_arg)
991 char *hold = input_line_pointer++;
993 /* First try for parenthesized register ... */
995 if (*input_line_pointer == ')' && tok->X_op == O_register)
997 tok->X_op = (saw_comma ? O_cpregister : O_pregister);
1000 ++input_line_pointer;
1005 /* ... then fall through to plain expression. */
1006 input_line_pointer = hold;
1010 if (saw_arg && !saw_comma)
1014 if (tok->X_op == O_illegal || tok->X_op == O_absent)
1027 input_line_pointer = old_input_line_pointer;
1030 debug_exp (orig_tok, ntok - (end_tok - tok));
1033 is_end_of_line[(unsigned char) '!'] = 0;
1036 return ntok - (end_tok - tok);
1040 is_end_of_line[(unsigned char) '!'] = 0;
1042 input_line_pointer = old_input_line_pointer;
1043 return TOKENIZE_ERROR;
1047 is_end_of_line[(unsigned char) '!'] = 0;
1049 input_line_pointer = old_input_line_pointer;
1050 return TOKENIZE_ERROR_REPORT;
1053 /* Search forward through all variants of an opcode looking for a
1056 static const struct alpha_opcode *
1057 find_opcode_match (const struct alpha_opcode *first_opcode,
1058 const expressionS *tok,
1062 const struct alpha_opcode *opcode = first_opcode;
1064 int got_cpu_match = 0;
1068 const unsigned char *opidx;
1071 /* Don't match opcodes that don't exist on this architecture. */
1072 if (!(opcode->flags & alpha_target))
1077 for (opidx = opcode->operands; *opidx; ++opidx)
1079 const struct alpha_operand *operand = &alpha_operands[*opidx];
1081 /* Only take input from real operands. */
1082 if (operand->flags & AXP_OPERAND_FAKE)
1085 /* When we expect input, make sure we have it. */
1088 if ((operand->flags & AXP_OPERAND_OPTIONAL_MASK) == 0)
1093 /* Match operand type with expression type. */
1094 switch (operand->flags & AXP_OPERAND_TYPECHECK_MASK)
1096 case AXP_OPERAND_IR:
1097 if (tok[tokidx].X_op != O_register
1098 || !is_ir_num (tok[tokidx].X_add_number))
1101 case AXP_OPERAND_FPR:
1102 if (tok[tokidx].X_op != O_register
1103 || !is_fpr_num (tok[tokidx].X_add_number))
1106 case AXP_OPERAND_IR | AXP_OPERAND_PARENS:
1107 if (tok[tokidx].X_op != O_pregister
1108 || !is_ir_num (tok[tokidx].X_add_number))
1111 case AXP_OPERAND_IR | AXP_OPERAND_PARENS | AXP_OPERAND_COMMA:
1112 if (tok[tokidx].X_op != O_cpregister
1113 || !is_ir_num (tok[tokidx].X_add_number))
1117 case AXP_OPERAND_RELATIVE:
1118 case AXP_OPERAND_SIGNED:
1119 case AXP_OPERAND_UNSIGNED:
1120 switch (tok[tokidx].X_op)
1135 /* Everything else should have been fake. */
1141 /* Possible match -- did we use all of our input? */
1150 while (++opcode - alpha_opcodes < (int) alpha_num_opcodes
1151 && !strcmp (opcode->name, first_opcode->name));
1154 *pcpumatch = got_cpu_match;
1159 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1160 the insn, but do not emit it.
1162 Note that this implies no macros allowed, since we can't store more
1163 than one insn in an insn structure. */
1166 assemble_tokens_to_insn (const char *opname,
1167 const expressionS *tok,
1169 struct alpha_insn *insn)
1171 const struct alpha_opcode *opcode;
1173 /* Search opcodes. */
1174 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
1178 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
1181 assemble_insn (opcode, tok, ntok, insn, BFD_RELOC_UNUSED);
1185 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
1187 as_bad (_("opcode `%s' not supported for target %s"), opname,
1191 as_bad (_("unknown opcode `%s'"), opname);
1194 /* Build a BFD section with its flags set appropriately for the .lita,
1195 .lit8, or .lit4 sections. */
1198 create_literal_section (const char *name,
1202 segT current_section = now_seg;
1203 int current_subsec = now_subseg;
1206 *secp = new_sec = subseg_new (name, 0);
1207 subseg_set (current_section, current_subsec);
1208 bfd_set_section_alignment (stdoutput, new_sec, 4);
1209 bfd_set_section_flags (stdoutput, new_sec,
1210 SEC_RELOC | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1213 S_CLEAR_EXTERNAL (*symp = section_symbol (new_sec));
1216 /* Load a (partial) expression into a target register.
1218 If poffset is not null, after the call it will either contain
1219 O_constant 0, or a 16-bit offset appropriate for any MEM format
1220 instruction. In addition, pbasereg will be modified to point to
1221 the base register to use in that MEM format instruction.
1223 In any case, *pbasereg should contain a base register to add to the
1224 expression. This will normally be either AXP_REG_ZERO or
1225 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1226 so "foo($0)" is interpreted as adding the address of foo to $0;
1227 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1228 but this is what OSF/1 does.
1230 If explicit relocations of the form !literal!<number> are allowed,
1231 and used, then explicit_reloc with be an expression pointer.
1233 Finally, the return value is nonzero if the calling macro may emit
1234 a LITUSE reloc if otherwise appropriate; the return value is the
1235 sequence number to use. */
1238 load_expression (int targreg,
1239 const expressionS *exp,
1241 expressionS *poffset,
1244 long emit_lituse = 0;
1245 offsetT addend = exp->X_add_number;
1246 int basereg = *pbasereg;
1247 struct alpha_insn insn;
1248 expressionS newtok[3];
1257 /* Attempt to reduce .lit load by splitting the offset from
1258 its symbol when possible, but don't create a situation in
1260 if (!range_signed_32 (addend) &&
1261 (alpha_noat_on || targreg == AXP_REG_AT))
1263 lit = add_to_literal_pool (exp->X_add_symbol, addend,
1264 alpha_lita_section, 8);
1268 lit = add_to_literal_pool (exp->X_add_symbol, 0,
1269 alpha_lita_section, 8);
1272 as_fatal (_("overflow in literal (.lita) table"));
1274 /* Emit "ldq r, lit(gp)". */
1276 if (basereg != alpha_gp_register && targreg == basereg)
1279 as_bad (_("macro requires $at register while noat in effect"));
1280 if (targreg == AXP_REG_AT)
1281 as_bad (_("macro requires $at while $at in use"));
1283 set_tok_reg (newtok[0], AXP_REG_AT);
1286 set_tok_reg (newtok[0], targreg);
1288 set_tok_sym (newtok[1], alpha_lita_symbol, lit);
1289 set_tok_preg (newtok[2], alpha_gp_register);
1291 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1293 gas_assert (insn.nfixups == 1);
1294 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1295 insn.sequence = emit_lituse = next_sequence_num--;
1296 #endif /* OBJ_ECOFF */
1298 /* Emit "ldq r, gotoff(gp)". */
1300 if (basereg != alpha_gp_register && targreg == basereg)
1303 as_bad (_("macro requires $at register while noat in effect"));
1304 if (targreg == AXP_REG_AT)
1305 as_bad (_("macro requires $at while $at in use"));
1307 set_tok_reg (newtok[0], AXP_REG_AT);
1310 set_tok_reg (newtok[0], targreg);
1312 /* XXX: Disable this .got minimizing optimization so that we can get
1313 better instruction offset knowledge in the compiler. This happens
1314 very infrequently anyway. */
1316 || (!range_signed_32 (addend)
1317 && (alpha_noat_on || targreg == AXP_REG_AT)))
1323 set_tok_sym (newtok[1], exp->X_add_symbol, 0);
1325 set_tok_preg (newtok[2], alpha_gp_register);
1327 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1329 gas_assert (insn.nfixups == 1);
1330 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1331 insn.sequence = emit_lituse = next_sequence_num--;
1332 #endif /* OBJ_ELF */
1334 /* Find symbol or symbol pointer in link section. */
1336 if (exp->X_add_symbol == alpha_evax_proc->symbol)
1338 /* Linkage-relative expression. */
1339 set_tok_reg (newtok[0], targreg);
1341 if (range_signed_16 (addend))
1343 set_tok_const (newtok[1], addend);
1348 set_tok_const (newtok[1], 0);
1350 set_tok_preg (newtok[2], basereg);
1351 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
1355 const char *symname = S_GET_NAME (exp->X_add_symbol);
1356 const char *ptr1, *ptr2;
1357 int symlen = strlen (symname);
1360 strcmp (ptr2 = &symname [symlen - 4], "..lk") == 0))
1362 /* Access to an item whose address is stored in the linkage
1363 section. Just read the address. */
1364 set_tok_reg (newtok[0], targreg);
1367 newtok[1].X_op = O_subtract;
1368 newtok[1].X_op_symbol = alpha_evax_proc->symbol;
1370 set_tok_preg (newtok[2], basereg);
1371 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1372 alpha_linkage_symbol = exp->X_add_symbol;
1375 set_tok_const (*poffset, 0);
1377 if (alpha_flag_replace && targreg == 26)
1379 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1383 /* Build the entry name as 'NAME..en'. */
1384 ptr1 = strstr (symname, "..") + 2;
1387 ensymname = (char *) xmalloc (ptr2 - ptr1 + 5);
1388 memcpy (ensymname, ptr1, ptr2 - ptr1);
1389 memcpy (ensymname + (ptr2 - ptr1), "..en", 5);
1391 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1392 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_NOP;
1393 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 *) xmalloc (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);
1428 symbol_mark_used (psym);
1429 insn.fixups[insn.nfixups].exp.X_op = O_subtract;
1430 insn.fixups[insn.nfixups].exp.X_add_symbol = psym;
1431 insn.fixups[insn.nfixups].exp.X_op_symbol = alpha_evax_proc->symbol;
1432 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1433 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1434 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1443 /* Not in the linkage section. Put the value into the linkage
1447 if (!range_signed_32 (addend))
1448 addend = sign_extend_32 (addend);
1449 linkexp = add_to_link_pool (exp->X_add_symbol, 0);
1450 set_tok_reg (newtok[0], targreg);
1451 set_tok_sym (newtok[1], linkexp, 0);
1452 set_tok_preg (newtok[2], basereg);
1453 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1456 #endif /* OBJ_EVAX */
1461 if (basereg != alpha_gp_register && basereg != AXP_REG_ZERO)
1463 /* Emit "addq r, base, r". */
1465 set_tok_reg (newtok[1], basereg);
1466 set_tok_reg (newtok[2], targreg);
1467 assemble_tokens ("addq", newtok, 3, 0);
1478 /* Assume that this difference expression will be resolved to an
1479 absolute value and that that value will fit in 16 bits. */
1481 set_tok_reg (newtok[0], targreg);
1483 set_tok_preg (newtok[2], basereg);
1484 assemble_tokens (opname, newtok, 3, 0);
1487 set_tok_const (*poffset, 0);
1491 if (exp->X_add_number > 0)
1492 as_bad (_("bignum invalid; zero assumed"));
1494 as_bad (_("floating point number invalid; zero assumed"));
1499 as_bad (_("can't handle expression"));
1504 if (!range_signed_32 (addend))
1510 long seq_num = next_sequence_num--;
1513 /* For 64-bit addends, just put it in the literal pool. */
1515 /* Emit "ldq targreg, lit(basereg)". */
1516 litexp = add_to_link_pool (section_symbol (absolute_section), addend);
1517 set_tok_reg (newtok[0], targreg);
1518 set_tok_sym (newtok[1], litexp, 0);
1519 set_tok_preg (newtok[2], alpha_gp_register);
1520 assemble_tokens ("ldq", newtok, 3, 0);
1523 if (alpha_lit8_section == NULL)
1525 create_literal_section (".lit8",
1526 &alpha_lit8_section,
1527 &alpha_lit8_symbol);
1530 alpha_lit8_literal = add_to_literal_pool (alpha_lit8_symbol, 0x8000,
1531 alpha_lita_section, 8);
1532 if (alpha_lit8_literal >= 0x8000)
1533 as_fatal (_("overflow in literal (.lita) table"));
1537 lit = add_to_literal_pool (NULL, addend, alpha_lit8_section, 8) - 0x8000;
1539 as_fatal (_("overflow in literal (.lit8) table"));
1541 /* Emit "lda litreg, .lit8+0x8000". */
1543 if (targreg == basereg)
1546 as_bad (_("macro requires $at register while noat in effect"));
1547 if (targreg == AXP_REG_AT)
1548 as_bad (_("macro requires $at while $at in use"));
1550 set_tok_reg (newtok[0], AXP_REG_AT);
1553 set_tok_reg (newtok[0], targreg);
1555 set_tok_sym (newtok[1], alpha_lita_symbol, alpha_lit8_literal);
1558 set_tok_sym (newtok[1], alpha_lit8_symbol, 0x8000);
1560 set_tok_preg (newtok[2], alpha_gp_register);
1562 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1564 gas_assert (insn.nfixups == 1);
1566 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1569 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1571 insn.sequence = seq_num;
1575 /* Emit "ldq litreg, lit(litreg)". */
1577 set_tok_const (newtok[1], lit);
1578 set_tok_preg (newtok[2], newtok[0].X_add_number);
1580 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1582 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
1583 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
1584 insn.fixups[insn.nfixups].exp.X_op = O_absent;
1586 insn.sequence = seq_num;
1591 /* Emit "addq litreg, base, target". */
1593 if (basereg != AXP_REG_ZERO)
1595 set_tok_reg (newtok[1], basereg);
1596 set_tok_reg (newtok[2], targreg);
1597 assemble_tokens ("addq", newtok, 3, 0);
1599 #endif /* !OBJ_EVAX */
1602 set_tok_const (*poffset, 0);
1603 *pbasereg = targreg;
1607 offsetT low, high, extra, tmp;
1609 /* For 32-bit operands, break up the addend. */
1611 low = sign_extend_16 (addend);
1613 high = sign_extend_16 (tmp >> 16);
1615 if (tmp - (high << 16))
1619 high = sign_extend_16 (tmp >> 16);
1624 set_tok_reg (newtok[0], targreg);
1625 set_tok_preg (newtok[2], basereg);
1629 /* Emit "ldah r, extra(r). */
1630 set_tok_const (newtok[1], extra);
1631 assemble_tokens ("ldah", newtok, 3, 0);
1632 set_tok_preg (newtok[2], basereg = targreg);
1637 /* Emit "ldah r, high(r). */
1638 set_tok_const (newtok[1], high);
1639 assemble_tokens ("ldah", newtok, 3, 0);
1641 set_tok_preg (newtok[2], basereg);
1644 if ((low && !poffset) || (!poffset && basereg != targreg))
1646 /* Emit "lda r, low(base)". */
1647 set_tok_const (newtok[1], low);
1648 assemble_tokens ("lda", newtok, 3, 0);
1654 set_tok_const (*poffset, low);
1655 *pbasereg = basereg;
1661 /* The lda macro differs from the lda instruction in that it handles
1662 most simple expressions, particularly symbol address loads and
1666 emit_lda (const expressionS *tok,
1668 const void * unused ATTRIBUTE_UNUSED)
1673 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
1675 basereg = tok[2].X_add_number;
1677 (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL, "lda");
1680 /* The ldah macro differs from the ldah instruction in that it has $31
1681 as an implied base register. */
1684 emit_ldah (const expressionS *tok,
1685 int ntok ATTRIBUTE_UNUSED,
1686 const void * unused ATTRIBUTE_UNUSED)
1688 expressionS newtok[3];
1692 set_tok_preg (newtok[2], AXP_REG_ZERO);
1694 assemble_tokens ("ldah", newtok, 3, 0);
1697 /* Called internally to handle all alignment needs. This takes care
1698 of eliding calls to frag_align if'n the cached current alignment
1699 says we've already got it, as well as taking care of the auto-align
1700 feature wrt labels. */
1706 int force ATTRIBUTE_UNUSED)
1708 if (alpha_current_align >= n)
1713 if (subseg_text_p (now_seg))
1714 frag_align_code (n, 0);
1716 frag_align (n, 0, 0);
1719 frag_align (n, *pfill, 0);
1721 alpha_current_align = n;
1723 if (label != NULL && S_GET_SEGMENT (label) == now_seg)
1725 symbol_set_frag (label, frag_now);
1726 S_SET_VALUE (label, (valueT) frag_now_fix ());
1729 record_alignment (now_seg, n);
1731 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1732 in a reloc for the linker to see. */
1735 /* Actually output an instruction with its fixup. */
1738 emit_insn (struct alpha_insn *insn)
1743 /* Take care of alignment duties. */
1744 if (alpha_auto_align_on && alpha_current_align < 2)
1745 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
1746 if (alpha_current_align > 2)
1747 alpha_current_align = 2;
1748 alpha_insn_label = NULL;
1750 /* Write out the instruction. */
1752 md_number_to_chars (f, insn->insn, 4);
1755 dwarf2_emit_insn (4);
1758 /* Apply the fixups in order. */
1759 for (i = 0; i < insn->nfixups; ++i)
1761 const struct alpha_operand *operand = (const struct alpha_operand *) 0;
1762 struct alpha_fixup *fixup = &insn->fixups[i];
1763 struct alpha_reloc_tag *info = NULL;
1767 /* Some fixups are only used internally and so have no howto. */
1768 if ((int) fixup->reloc < 0)
1770 operand = &alpha_operands[-(int) fixup->reloc];
1772 pcrel = ((operand->flags & AXP_OPERAND_RELATIVE) != 0);
1774 else if (fixup->reloc > BFD_RELOC_UNUSED
1775 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_HI16
1776 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_LO16)
1783 reloc_howto_type *reloc_howto =
1784 bfd_reloc_type_lookup (stdoutput,
1785 (bfd_reloc_code_real_type) fixup->reloc);
1786 gas_assert (reloc_howto);
1788 size = bfd_get_reloc_size (reloc_howto);
1790 switch (fixup->reloc)
1793 case BFD_RELOC_ALPHA_NOP:
1794 case BFD_RELOC_ALPHA_BSR:
1795 case BFD_RELOC_ALPHA_LDA:
1796 case BFD_RELOC_ALPHA_BOH:
1800 gas_assert (size >= 1 && size <= 4);
1803 pcrel = reloc_howto->pc_relative;
1806 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
1807 &fixup->exp, pcrel, (bfd_reloc_code_real_type) fixup->reloc);
1809 /* Turn off complaints that the addend is too large for some fixups,
1810 and copy in the sequence number for the explicit relocations. */
1811 switch (fixup->reloc)
1813 case BFD_RELOC_ALPHA_HINT:
1814 case BFD_RELOC_GPREL32:
1815 case BFD_RELOC_GPREL16:
1816 case BFD_RELOC_ALPHA_GPREL_HI16:
1817 case BFD_RELOC_ALPHA_GPREL_LO16:
1818 case BFD_RELOC_ALPHA_GOTDTPREL16:
1819 case BFD_RELOC_ALPHA_DTPREL_HI16:
1820 case BFD_RELOC_ALPHA_DTPREL_LO16:
1821 case BFD_RELOC_ALPHA_DTPREL16:
1822 case BFD_RELOC_ALPHA_GOTTPREL16:
1823 case BFD_RELOC_ALPHA_TPREL_HI16:
1824 case BFD_RELOC_ALPHA_TPREL_LO16:
1825 case BFD_RELOC_ALPHA_TPREL16:
1826 fixP->fx_no_overflow = 1;
1829 case BFD_RELOC_ALPHA_GPDISP_HI16:
1830 fixP->fx_no_overflow = 1;
1831 fixP->fx_addsy = section_symbol (now_seg);
1832 fixP->fx_offset = 0;
1834 info = get_alpha_reloc_tag (insn->sequence);
1835 if (++info->n_master > 1)
1836 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn->sequence);
1837 if (info->segment != now_seg)
1838 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1840 fixP->tc_fix_data.info = info;
1843 case BFD_RELOC_ALPHA_GPDISP_LO16:
1844 fixP->fx_no_overflow = 1;
1846 info = get_alpha_reloc_tag (insn->sequence);
1847 if (++info->n_slaves > 1)
1848 as_bad (_("too many lda insns for !gpdisp!%ld"), insn->sequence);
1849 if (info->segment != now_seg)
1850 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1852 fixP->tc_fix_data.info = info;
1853 info->slaves = fixP;
1856 case BFD_RELOC_ALPHA_LITERAL:
1857 case BFD_RELOC_ALPHA_ELF_LITERAL:
1858 fixP->fx_no_overflow = 1;
1860 if (insn->sequence == 0)
1862 info = get_alpha_reloc_tag (insn->sequence);
1863 info->master = fixP;
1865 if (info->segment != now_seg)
1866 info->multi_section_p = 1;
1867 fixP->tc_fix_data.info = info;
1871 case DUMMY_RELOC_LITUSE_ADDR:
1872 fixP->fx_offset = LITUSE_ALPHA_ADDR;
1874 case DUMMY_RELOC_LITUSE_BASE:
1875 fixP->fx_offset = LITUSE_ALPHA_BASE;
1877 case DUMMY_RELOC_LITUSE_BYTOFF:
1878 fixP->fx_offset = LITUSE_ALPHA_BYTOFF;
1880 case DUMMY_RELOC_LITUSE_JSR:
1881 fixP->fx_offset = LITUSE_ALPHA_JSR;
1883 case DUMMY_RELOC_LITUSE_TLSGD:
1884 fixP->fx_offset = LITUSE_ALPHA_TLSGD;
1886 case DUMMY_RELOC_LITUSE_TLSLDM:
1887 fixP->fx_offset = LITUSE_ALPHA_TLSLDM;
1889 case DUMMY_RELOC_LITUSE_JSRDIRECT:
1890 fixP->fx_offset = LITUSE_ALPHA_JSRDIRECT;
1893 fixP->fx_addsy = section_symbol (now_seg);
1894 fixP->fx_r_type = BFD_RELOC_ALPHA_LITUSE;
1896 info = get_alpha_reloc_tag (insn->sequence);
1897 if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSGD)
1898 info->saw_lu_tlsgd = 1;
1899 else if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSLDM)
1900 info->saw_lu_tlsldm = 1;
1901 if (++info->n_slaves > 1)
1903 if (info->saw_lu_tlsgd)
1904 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1906 else if (info->saw_lu_tlsldm)
1907 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1910 fixP->tc_fix_data.info = info;
1911 fixP->tc_fix_data.next_reloc = info->slaves;
1912 info->slaves = fixP;
1913 if (info->segment != now_seg)
1914 info->multi_section_p = 1;
1917 case BFD_RELOC_ALPHA_TLSGD:
1918 fixP->fx_no_overflow = 1;
1920 if (insn->sequence == 0)
1922 info = get_alpha_reloc_tag (insn->sequence);
1923 if (info->saw_tlsgd)
1924 as_bad (_("duplicate !tlsgd!%ld"), insn->sequence);
1925 else if (info->saw_tlsldm)
1926 as_bad (_("sequence number in use for !tlsldm!%ld"),
1929 info->saw_tlsgd = 1;
1930 fixP->tc_fix_data.info = info;
1933 case BFD_RELOC_ALPHA_TLSLDM:
1934 fixP->fx_no_overflow = 1;
1936 if (insn->sequence == 0)
1938 info = get_alpha_reloc_tag (insn->sequence);
1939 if (info->saw_tlsldm)
1940 as_bad (_("duplicate !tlsldm!%ld"), insn->sequence);
1941 else if (info->saw_tlsgd)
1942 as_bad (_("sequence number in use for !tlsgd!%ld"),
1945 info->saw_tlsldm = 1;
1946 fixP->tc_fix_data.info = info;
1950 case BFD_RELOC_ALPHA_NOP:
1951 case BFD_RELOC_ALPHA_LDA:
1952 case BFD_RELOC_ALPHA_BSR:
1953 case BFD_RELOC_ALPHA_BOH:
1954 info = get_alpha_reloc_tag (next_sequence_num--);
1955 fixP->tc_fix_data.info = info;
1956 fixP->tc_fix_data.info->sym = fixup->xtrasym;
1957 fixP->tc_fix_data.info->psym = fixup->procsym;
1962 if ((int) fixup->reloc < 0)
1964 if (operand->flags & AXP_OPERAND_NOOVERFLOW)
1965 fixP->fx_no_overflow = 1;
1972 /* Insert an operand value into an instruction. */
1975 insert_operand (unsigned insn,
1976 const struct alpha_operand *operand,
1981 if (operand->bits != 32 && !(operand->flags & AXP_OPERAND_NOOVERFLOW))
1985 if (operand->flags & AXP_OPERAND_SIGNED)
1987 max = (1 << (operand->bits - 1)) - 1;
1988 min = -(1 << (operand->bits - 1));
1992 max = (1 << operand->bits) - 1;
1996 if (val < min || val > max)
1997 as_bad_value_out_of_range (_("operand"), val, min, max, file, line);
2000 if (operand->insert)
2002 const char *errmsg = NULL;
2004 insn = (*operand->insert) (insn, val, &errmsg);
2006 as_warn ("%s", errmsg);
2009 insn |= ((val & ((1 << operand->bits) - 1)) << operand->shift);
2014 /* Turn an opcode description and a set of arguments into
2015 an instruction and a fixup. */
2018 assemble_insn (const struct alpha_opcode *opcode,
2019 const expressionS *tok,
2021 struct alpha_insn *insn,
2022 extended_bfd_reloc_code_real_type reloc)
2024 const struct alpha_operand *reloc_operand = NULL;
2025 const expressionS *reloc_exp = NULL;
2026 const unsigned char *argidx;
2030 memset (insn, 0, sizeof (*insn));
2031 image = opcode->opcode;
2033 for (argidx = opcode->operands; *argidx; ++argidx)
2035 const struct alpha_operand *operand = &alpha_operands[*argidx];
2036 const expressionS *t = (const expressionS *) 0;
2038 if (operand->flags & AXP_OPERAND_FAKE)
2040 /* Fake operands take no value and generate no fixup. */
2041 image = insert_operand (image, operand, 0, NULL, 0);
2047 switch (operand->flags & AXP_OPERAND_OPTIONAL_MASK)
2049 case AXP_OPERAND_DEFAULT_FIRST:
2052 case AXP_OPERAND_DEFAULT_SECOND:
2055 case AXP_OPERAND_DEFAULT_ZERO:
2057 static expressionS zero_exp;
2059 zero_exp.X_op = O_constant;
2060 zero_exp.X_unsigned = 1;
2075 image = insert_operand (image, operand, regno (t->X_add_number),
2080 image = insert_operand (image, operand, t->X_add_number, NULL, 0);
2081 gas_assert (reloc_operand == NULL);
2082 reloc_operand = operand;
2087 /* This is only 0 for fields that should contain registers,
2088 which means this pattern shouldn't have matched. */
2089 if (operand->default_reloc == 0)
2092 /* There is one special case for which an insn receives two
2093 relocations, and thus the user-supplied reloc does not
2094 override the operand reloc. */
2095 if (operand->default_reloc == BFD_RELOC_ALPHA_HINT)
2097 struct alpha_fixup *fixup;
2099 if (insn->nfixups >= MAX_INSN_FIXUPS)
2100 as_fatal (_("too many fixups"));
2102 fixup = &insn->fixups[insn->nfixups++];
2104 fixup->reloc = BFD_RELOC_ALPHA_HINT;
2108 if (reloc == BFD_RELOC_UNUSED)
2109 reloc = operand->default_reloc;
2111 gas_assert (reloc_operand == NULL);
2112 reloc_operand = operand;
2119 if (reloc != BFD_RELOC_UNUSED)
2121 struct alpha_fixup *fixup;
2123 if (insn->nfixups >= MAX_INSN_FIXUPS)
2124 as_fatal (_("too many fixups"));
2126 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2127 relocation tag for both ldah and lda with gpdisp. Choose the
2128 correct internal relocation based on the opcode. */
2129 if (reloc == BFD_RELOC_ALPHA_GPDISP)
2131 if (strcmp (opcode->name, "ldah") == 0)
2132 reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2133 else if (strcmp (opcode->name, "lda") == 0)
2134 reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
2136 as_bad (_("invalid relocation for instruction"));
2139 /* If this is a real relocation (as opposed to a lituse hint), then
2140 the relocation width should match the operand width.
2141 Take care of -MDISP in operand table. */
2142 else if (reloc < BFD_RELOC_UNUSED && reloc > 0)
2144 reloc_howto_type *reloc_howto
2145 = bfd_reloc_type_lookup (stdoutput,
2146 (bfd_reloc_code_real_type) reloc);
2147 if (reloc_operand == NULL
2148 || reloc_howto->bitsize != reloc_operand->bits)
2150 as_bad (_("invalid relocation for field"));
2155 fixup = &insn->fixups[insn->nfixups++];
2157 fixup->exp = *reloc_exp;
2159 fixup->exp.X_op = O_absent;
2160 fixup->reloc = reloc;
2166 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2167 etc. They differ from the real instructions in that they do simple
2168 expressions like the lda macro. */
2171 emit_ir_load (const expressionS *tok,
2173 const void * opname)
2177 expressionS newtok[3];
2178 struct alpha_insn insn;
2180 = tok[1].X_add_symbol ? S_GET_NAME (tok[1].X_add_symbol): "";
2181 int symlen = strlen (symname);
2184 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2186 basereg = tok[2].X_add_number;
2188 lituse = load_expression (tok[0].X_add_number, &tok[1],
2189 &basereg, &newtok[1], (const char *) opname);
2191 if (basereg == alpha_gp_register &&
2192 (symlen > 4 && strcmp (&symname [symlen - 4], "..lk") == 0))
2196 set_tok_preg (newtok[2], basereg);
2198 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2202 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2203 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2204 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2206 insn.sequence = lituse;
2212 /* Handle fp register loads, and both integer and fp register stores.
2213 Again, we handle simple expressions. */
2216 emit_loadstore (const expressionS *tok,
2218 const void * opname)
2222 expressionS newtok[3];
2223 struct alpha_insn insn;
2226 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2228 basereg = tok[2].X_add_number;
2230 if (tok[1].X_op != O_constant || !range_signed_16 (tok[1].X_add_number))
2233 as_bad (_("macro requires $at register while noat in effect"));
2235 lituse = load_expression (AXP_REG_AT, &tok[1],
2236 &basereg, &newtok[1], (const char *) opname);
2245 set_tok_preg (newtok[2], basereg);
2247 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2251 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2252 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2253 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2255 insn.sequence = lituse;
2261 /* Load a half-word or byte as an unsigned value. */
2264 emit_ldXu (const expressionS *tok,
2266 const void * vlgsize)
2268 if (alpha_target & AXP_OPCODE_BWX)
2269 emit_ir_load (tok, ntok, ldXu_op[(long) vlgsize]);
2272 expressionS newtok[3];
2273 struct alpha_insn insn;
2278 as_bad (_("macro requires $at register while noat in effect"));
2281 basereg = (tok[1].X_op == O_constant
2282 ? AXP_REG_ZERO : alpha_gp_register);
2284 basereg = tok[2].X_add_number;
2286 /* Emit "lda $at, exp". */
2287 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2289 /* Emit "ldq_u targ, 0($at)". */
2291 set_tok_const (newtok[1], 0);
2292 set_tok_preg (newtok[2], basereg);
2293 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2297 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2298 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2299 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2301 insn.sequence = lituse;
2306 /* Emit "extXl targ, $at, targ". */
2307 set_tok_reg (newtok[1], basereg);
2308 newtok[2] = newtok[0];
2309 assemble_tokens_to_insn (extXl_op[(long) vlgsize], newtok, 3, &insn);
2313 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2314 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2315 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2317 insn.sequence = lituse;
2324 /* Load a half-word or byte as a signed value. */
2327 emit_ldX (const expressionS *tok,
2329 const void * vlgsize)
2331 emit_ldXu (tok, ntok, vlgsize);
2332 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2335 /* Load an integral value from an unaligned address as an unsigned
2339 emit_uldXu (const expressionS *tok,
2341 const void * vlgsize)
2343 long lgsize = (long) vlgsize;
2344 expressionS newtok[3];
2347 as_bad (_("macro requires $at register while noat in effect"));
2349 /* Emit "lda $at, exp". */
2350 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2351 newtok[0].X_add_number = AXP_REG_AT;
2352 assemble_tokens ("lda", newtok, ntok, 1);
2354 /* Emit "ldq_u $t9, 0($at)". */
2355 set_tok_reg (newtok[0], AXP_REG_T9);
2356 set_tok_const (newtok[1], 0);
2357 set_tok_preg (newtok[2], AXP_REG_AT);
2358 assemble_tokens ("ldq_u", newtok, 3, 1);
2360 /* Emit "ldq_u $t10, size-1($at)". */
2361 set_tok_reg (newtok[0], AXP_REG_T10);
2362 set_tok_const (newtok[1], (1 << lgsize) - 1);
2363 assemble_tokens ("ldq_u", newtok, 3, 1);
2365 /* Emit "extXl $t9, $at, $t9". */
2366 set_tok_reg (newtok[0], AXP_REG_T9);
2367 set_tok_reg (newtok[1], AXP_REG_AT);
2368 set_tok_reg (newtok[2], AXP_REG_T9);
2369 assemble_tokens (extXl_op[lgsize], newtok, 3, 1);
2371 /* Emit "extXh $t10, $at, $t10". */
2372 set_tok_reg (newtok[0], AXP_REG_T10);
2373 set_tok_reg (newtok[2], AXP_REG_T10);
2374 assemble_tokens (extXh_op[lgsize], newtok, 3, 1);
2376 /* Emit "or $t9, $t10, targ". */
2377 set_tok_reg (newtok[0], AXP_REG_T9);
2378 set_tok_reg (newtok[1], AXP_REG_T10);
2380 assemble_tokens ("or", newtok, 3, 1);
2383 /* Load an integral value from an unaligned address as a signed value.
2384 Note that quads should get funneled to the unsigned load since we
2385 don't have to do the sign extension. */
2388 emit_uldX (const expressionS *tok,
2390 const void * vlgsize)
2392 emit_uldXu (tok, ntok, vlgsize);
2393 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2396 /* Implement the ldil macro. */
2399 emit_ldil (const expressionS *tok,
2401 const void * unused ATTRIBUTE_UNUSED)
2403 expressionS newtok[2];
2405 memcpy (newtok, tok, sizeof (newtok));
2406 newtok[1].X_add_number = sign_extend_32 (tok[1].X_add_number);
2408 assemble_tokens ("lda", newtok, ntok, 1);
2411 /* Store a half-word or byte. */
2414 emit_stX (const expressionS *tok,
2416 const void * vlgsize)
2418 int lgsize = (int) (long) vlgsize;
2420 if (alpha_target & AXP_OPCODE_BWX)
2421 emit_loadstore (tok, ntok, stX_op[lgsize]);
2424 expressionS newtok[3];
2425 struct alpha_insn insn;
2430 as_bad (_("macro requires $at register while noat in effect"));
2433 basereg = (tok[1].X_op == O_constant
2434 ? AXP_REG_ZERO : alpha_gp_register);
2436 basereg = tok[2].X_add_number;
2438 /* Emit "lda $at, exp". */
2439 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2441 /* Emit "ldq_u $t9, 0($at)". */
2442 set_tok_reg (newtok[0], AXP_REG_T9);
2443 set_tok_const (newtok[1], 0);
2444 set_tok_preg (newtok[2], basereg);
2445 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2449 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2450 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2451 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2453 insn.sequence = lituse;
2458 /* Emit "insXl src, $at, $t10". */
2460 set_tok_reg (newtok[1], basereg);
2461 set_tok_reg (newtok[2], AXP_REG_T10);
2462 assemble_tokens_to_insn (insXl_op[lgsize], newtok, 3, &insn);
2466 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2467 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2468 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2470 insn.sequence = lituse;
2475 /* Emit "mskXl $t9, $at, $t9". */
2476 set_tok_reg (newtok[0], AXP_REG_T9);
2477 newtok[2] = newtok[0];
2478 assemble_tokens_to_insn (mskXl_op[lgsize], newtok, 3, &insn);
2482 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2483 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2484 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2486 insn.sequence = lituse;
2491 /* Emit "or $t9, $t10, $t9". */
2492 set_tok_reg (newtok[1], AXP_REG_T10);
2493 assemble_tokens ("or", newtok, 3, 1);
2495 /* Emit "stq_u $t9, 0($at). */
2496 set_tok_const(newtok[1], 0);
2497 set_tok_preg (newtok[2], AXP_REG_AT);
2498 assemble_tokens_to_insn ("stq_u", newtok, 3, &insn);
2502 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2503 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2504 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2506 insn.sequence = lituse;
2513 /* Store an integer to an unaligned address. */
2516 emit_ustX (const expressionS *tok,
2518 const void * vlgsize)
2520 int lgsize = (int) (long) vlgsize;
2521 expressionS newtok[3];
2523 /* Emit "lda $at, exp". */
2524 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2525 newtok[0].X_add_number = AXP_REG_AT;
2526 assemble_tokens ("lda", newtok, ntok, 1);
2528 /* Emit "ldq_u $9, 0($at)". */
2529 set_tok_reg (newtok[0], AXP_REG_T9);
2530 set_tok_const (newtok[1], 0);
2531 set_tok_preg (newtok[2], AXP_REG_AT);
2532 assemble_tokens ("ldq_u", newtok, 3, 1);
2534 /* Emit "ldq_u $10, size-1($at)". */
2535 set_tok_reg (newtok[0], AXP_REG_T10);
2536 set_tok_const (newtok[1], (1 << lgsize) - 1);
2537 assemble_tokens ("ldq_u", newtok, 3, 1);
2539 /* Emit "insXl src, $at, $t11". */
2541 set_tok_reg (newtok[1], AXP_REG_AT);
2542 set_tok_reg (newtok[2], AXP_REG_T11);
2543 assemble_tokens (insXl_op[lgsize], newtok, 3, 1);
2545 /* Emit "insXh src, $at, $t12". */
2546 set_tok_reg (newtok[2], AXP_REG_T12);
2547 assemble_tokens (insXh_op[lgsize], newtok, 3, 1);
2549 /* Emit "mskXl $t9, $at, $t9". */
2550 set_tok_reg (newtok[0], AXP_REG_T9);
2551 newtok[2] = newtok[0];
2552 assemble_tokens (mskXl_op[lgsize], newtok, 3, 1);
2554 /* Emit "mskXh $t10, $at, $t10". */
2555 set_tok_reg (newtok[0], AXP_REG_T10);
2556 newtok[2] = newtok[0];
2557 assemble_tokens (mskXh_op[lgsize], newtok, 3, 1);
2559 /* Emit "or $t9, $t11, $t9". */
2560 set_tok_reg (newtok[0], AXP_REG_T9);
2561 set_tok_reg (newtok[1], AXP_REG_T11);
2562 newtok[2] = newtok[0];
2563 assemble_tokens ("or", newtok, 3, 1);
2565 /* Emit "or $t10, $t12, $t10". */
2566 set_tok_reg (newtok[0], AXP_REG_T10);
2567 set_tok_reg (newtok[1], AXP_REG_T12);
2568 newtok[2] = newtok[0];
2569 assemble_tokens ("or", newtok, 3, 1);
2571 /* Emit "stq_u $t10, size-1($at)". */
2572 set_tok_reg (newtok[0], AXP_REG_T10);
2573 set_tok_const (newtok[1], (1 << lgsize) - 1);
2574 set_tok_preg (newtok[2], AXP_REG_AT);
2575 assemble_tokens ("stq_u", newtok, 3, 1);
2577 /* Emit "stq_u $t9, 0($at)". */
2578 set_tok_reg (newtok[0], AXP_REG_T9);
2579 set_tok_const (newtok[1], 0);
2580 assemble_tokens ("stq_u", newtok, 3, 1);
2583 /* Sign extend a half-word or byte. The 32-bit sign extend is
2584 implemented as "addl $31, $r, $t" in the opcode table. */
2587 emit_sextX (const expressionS *tok,
2589 const void * vlgsize)
2591 long lgsize = (long) vlgsize;
2593 if (alpha_target & AXP_OPCODE_BWX)
2594 assemble_tokens (sextX_op[lgsize], tok, ntok, 0);
2597 int bitshift = 64 - 8 * (1 << lgsize);
2598 expressionS newtok[3];
2600 /* Emit "sll src,bits,dst". */
2602 set_tok_const (newtok[1], bitshift);
2603 newtok[2] = tok[ntok - 1];
2604 assemble_tokens ("sll", newtok, 3, 1);
2606 /* Emit "sra dst,bits,dst". */
2607 newtok[0] = newtok[2];
2608 assemble_tokens ("sra", newtok, 3, 1);
2612 /* Implement the division and modulus macros. */
2616 /* Make register usage like in normal procedure call.
2617 Don't clobber PV and RA. */
2620 emit_division (const expressionS *tok,
2622 const void * symname)
2624 /* DIVISION and MODULUS. Yech.
2629 mov x,R16 # if x != R16
2630 mov y,R17 # if y != R17
2635 with appropriate optimizations if R0,R16,R17 are the registers
2636 specified by the compiler. */
2640 expressionS newtok[3];
2642 xr = regno (tok[0].X_add_number);
2643 yr = regno (tok[1].X_add_number);
2648 rr = regno (tok[2].X_add_number);
2650 /* Move the operands into the right place. */
2651 if (yr == AXP_REG_R16 && xr == AXP_REG_R17)
2653 /* They are in exactly the wrong order -- swap through AT. */
2655 as_bad (_("macro requires $at register while noat in effect"));
2657 set_tok_reg (newtok[0], AXP_REG_R16);
2658 set_tok_reg (newtok[1], AXP_REG_AT);
2659 assemble_tokens ("mov", newtok, 2, 1);
2661 set_tok_reg (newtok[0], AXP_REG_R17);
2662 set_tok_reg (newtok[1], AXP_REG_R16);
2663 assemble_tokens ("mov", newtok, 2, 1);
2665 set_tok_reg (newtok[0], AXP_REG_AT);
2666 set_tok_reg (newtok[1], AXP_REG_R17);
2667 assemble_tokens ("mov", newtok, 2, 1);
2671 if (yr == AXP_REG_R16)
2673 set_tok_reg (newtok[0], AXP_REG_R16);
2674 set_tok_reg (newtok[1], AXP_REG_R17);
2675 assemble_tokens ("mov", newtok, 2, 1);
2678 if (xr != AXP_REG_R16)
2680 set_tok_reg (newtok[0], xr);
2681 set_tok_reg (newtok[1], AXP_REG_R16);
2682 assemble_tokens ("mov", newtok, 2, 1);
2685 if (yr != AXP_REG_R16 && yr != AXP_REG_R17)
2687 set_tok_reg (newtok[0], yr);
2688 set_tok_reg (newtok[1], AXP_REG_R17);
2689 assemble_tokens ("mov", newtok, 2, 1);
2693 sym = symbol_find_or_make ((const char *) symname);
2695 set_tok_reg (newtok[0], AXP_REG_AT);
2696 set_tok_sym (newtok[1], sym, 0);
2697 assemble_tokens ("lda", newtok, 2, 1);
2699 /* Call the division routine. */
2700 set_tok_reg (newtok[0], AXP_REG_AT);
2701 set_tok_cpreg (newtok[1], AXP_REG_AT);
2702 set_tok_const (newtok[2], 0);
2703 assemble_tokens ("jsr", newtok, 3, 1);
2705 /* Move the result to the right place. */
2706 if (rr != AXP_REG_R0)
2708 set_tok_reg (newtok[0], AXP_REG_R0);
2709 set_tok_reg (newtok[1], rr);
2710 assemble_tokens ("mov", newtok, 2, 1);
2714 #else /* !OBJ_EVAX */
2717 emit_division (const expressionS *tok,
2719 const void * symname)
2721 /* DIVISION and MODULUS. Yech.
2731 with appropriate optimizations if t10,t11,t12 are the registers
2732 specified by the compiler. */
2736 expressionS newtok[3];
2738 xr = regno (tok[0].X_add_number);
2739 yr = regno (tok[1].X_add_number);
2744 rr = regno (tok[2].X_add_number);
2746 sym = symbol_find_or_make ((const char *) symname);
2748 /* Move the operands into the right place. */
2749 if (yr == AXP_REG_T10 && xr == AXP_REG_T11)
2751 /* They are in exactly the wrong order -- swap through AT. */
2753 as_bad (_("macro requires $at register while noat in effect"));
2755 set_tok_reg (newtok[0], AXP_REG_T10);
2756 set_tok_reg (newtok[1], AXP_REG_AT);
2757 assemble_tokens ("mov", newtok, 2, 1);
2759 set_tok_reg (newtok[0], AXP_REG_T11);
2760 set_tok_reg (newtok[1], AXP_REG_T10);
2761 assemble_tokens ("mov", newtok, 2, 1);
2763 set_tok_reg (newtok[0], AXP_REG_AT);
2764 set_tok_reg (newtok[1], AXP_REG_T11);
2765 assemble_tokens ("mov", newtok, 2, 1);
2769 if (yr == AXP_REG_T10)
2771 set_tok_reg (newtok[0], AXP_REG_T10);
2772 set_tok_reg (newtok[1], AXP_REG_T11);
2773 assemble_tokens ("mov", newtok, 2, 1);
2776 if (xr != AXP_REG_T10)
2778 set_tok_reg (newtok[0], xr);
2779 set_tok_reg (newtok[1], AXP_REG_T10);
2780 assemble_tokens ("mov", newtok, 2, 1);
2783 if (yr != AXP_REG_T10 && yr != AXP_REG_T11)
2785 set_tok_reg (newtok[0], yr);
2786 set_tok_reg (newtok[1], AXP_REG_T11);
2787 assemble_tokens ("mov", newtok, 2, 1);
2791 /* Call the division routine. */
2792 set_tok_reg (newtok[0], AXP_REG_T9);
2793 set_tok_sym (newtok[1], sym, 0);
2794 assemble_tokens ("jsr", newtok, 2, 1);
2796 /* Reload the GP register. */
2800 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2801 set_tok_reg (newtok[0], alpha_gp_register);
2802 set_tok_const (newtok[1], 0);
2803 set_tok_preg (newtok[2], AXP_REG_T9);
2804 assemble_tokens ("ldgp", newtok, 3, 1);
2807 /* Move the result to the right place. */
2808 if (rr != AXP_REG_T12)
2810 set_tok_reg (newtok[0], AXP_REG_T12);
2811 set_tok_reg (newtok[1], rr);
2812 assemble_tokens ("mov", newtok, 2, 1);
2816 #endif /* !OBJ_EVAX */
2818 /* The jsr and jmp macros differ from their instruction counterparts
2819 in that they can load the target address and default most
2823 emit_jsrjmp (const expressionS *tok,
2825 const void * vopname)
2827 const char *opname = (const char *) vopname;
2828 struct alpha_insn insn;
2829 expressionS newtok[3];
2833 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2834 r = regno (tok[tokidx++].X_add_number);
2836 r = strcmp (opname, "jmp") == 0 ? AXP_REG_ZERO : AXP_REG_RA;
2838 set_tok_reg (newtok[0], r);
2840 if (tokidx < ntok &&
2841 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2842 r = regno (tok[tokidx++].X_add_number);
2844 /* Keep register if jsr $n.<sym>. */
2848 int basereg = alpha_gp_register;
2849 lituse = load_expression (r = AXP_REG_PV, &tok[tokidx],
2850 &basereg, NULL, opname);
2854 set_tok_cpreg (newtok[1], r);
2858 newtok[2] = tok[tokidx];
2861 set_tok_const (newtok[2], 0);
2863 assemble_tokens_to_insn (opname, newtok, 3, &insn);
2867 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2868 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_JSR;
2869 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2871 insn.sequence = lituse;
2875 if (alpha_flag_replace
2877 && tok[tokidx].X_add_symbol
2878 && alpha_linkage_symbol)
2880 /* Create a BOH reloc for 'jsr $27,NAME'. */
2881 const char *symname = S_GET_NAME (tok[tokidx].X_add_symbol);
2882 int symlen = strlen (symname);
2885 /* Build the entry name as 'NAME..en'. */
2886 ensymname = (char *) xmalloc (symlen + 5);
2887 memcpy (ensymname, symname, symlen);
2888 memcpy (ensymname + symlen, "..en", 5);
2890 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2891 if (insn.nfixups > 0)
2893 memmove (&insn.fixups[1], &insn.fixups[0],
2894 sizeof(struct alpha_fixup) * insn.nfixups);
2897 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2898 case in load_expression. See B.4.5.2 of the OpenVMS
2899 Linker Utility Manual. */
2900 insn.fixups[0].reloc = BFD_RELOC_ALPHA_BOH;
2901 insn.fixups[0].exp.X_op = O_symbol;
2902 insn.fixups[0].exp.X_add_symbol = symbol_find_or_make (ensymname);
2903 insn.fixups[0].exp.X_add_number = 0;
2904 insn.fixups[0].xtrasym = alpha_linkage_symbol;
2905 insn.fixups[0].procsym = alpha_evax_proc->symbol;
2907 alpha_linkage_symbol = 0;
2915 /* The ret and jcr instructions differ from their instruction
2916 counterparts in that everything can be defaulted. */
2919 emit_retjcr (const expressionS *tok,
2921 const void * vopname)
2923 const char *opname = (const char *) vopname;
2924 expressionS newtok[3];
2927 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2928 r = regno (tok[tokidx++].X_add_number);
2932 set_tok_reg (newtok[0], r);
2934 if (tokidx < ntok &&
2935 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2936 r = regno (tok[tokidx++].X_add_number);
2940 set_tok_cpreg (newtok[1], r);
2943 newtok[2] = tok[tokidx];
2945 set_tok_const (newtok[2], strcmp (opname, "ret") == 0);
2947 assemble_tokens (opname, newtok, 3, 0);
2950 /* Implement the ldgp macro. */
2953 emit_ldgp (const expressionS *tok ATTRIBUTE_UNUSED,
2954 int ntok ATTRIBUTE_UNUSED,
2955 const void * unused ATTRIBUTE_UNUSED)
2960 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2961 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2962 with appropriate constants and relocations. */
2963 struct alpha_insn insn;
2964 expressionS newtok[3];
2968 if (regno (tok[2].X_add_number) == AXP_REG_PV)
2969 ecoff_set_gp_prolog_size (0);
2973 set_tok_const (newtok[1], 0);
2976 assemble_tokens_to_insn ("ldah", newtok, 3, &insn);
2981 if (addend.X_op != O_constant)
2982 as_bad (_("can not resolve expression"));
2983 addend.X_op = O_symbol;
2984 addend.X_add_symbol = alpha_gp_symbol;
2988 insn.fixups[0].exp = addend;
2989 insn.fixups[0].reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2990 insn.sequence = next_sequence_num;
2994 set_tok_preg (newtok[2], tok[0].X_add_number);
2996 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
2999 addend.X_add_number += 4;
3003 insn.fixups[0].exp = addend;
3004 insn.fixups[0].reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
3005 insn.sequence = next_sequence_num--;
3008 #endif /* OBJ_ECOFF || OBJ_ELF */
3011 /* The macro table. */
3013 static const struct alpha_macro alpha_macros[] =
3015 /* Load/Store macros. */
3016 { "lda", emit_lda, NULL,
3017 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3018 { "ldah", emit_ldah, NULL,
3019 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3021 { "ldl", emit_ir_load, "ldl",
3022 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3023 { "ldl_l", emit_ir_load, "ldl_l",
3024 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3025 { "ldq", emit_ir_load, "ldq",
3026 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3027 { "ldq_l", emit_ir_load, "ldq_l",
3028 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3029 { "ldq_u", emit_ir_load, "ldq_u",
3030 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3031 { "ldf", emit_loadstore, "ldf",
3032 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3033 { "ldg", emit_loadstore, "ldg",
3034 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3035 { "lds", emit_loadstore, "lds",
3036 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3037 { "ldt", emit_loadstore, "ldt",
3038 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3040 { "ldb", emit_ldX, (void *) 0,
3041 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3042 { "ldbu", emit_ldXu, (void *) 0,
3043 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3044 { "ldw", emit_ldX, (void *) 1,
3045 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3046 { "ldwu", emit_ldXu, (void *) 1,
3047 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3049 { "uldw", emit_uldX, (void *) 1,
3050 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3051 { "uldwu", emit_uldXu, (void *) 1,
3052 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3053 { "uldl", emit_uldX, (void *) 2,
3054 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3055 { "uldlu", emit_uldXu, (void *) 2,
3056 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3057 { "uldq", emit_uldXu, (void *) 3,
3058 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3060 { "ldgp", emit_ldgp, NULL,
3061 { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA } },
3063 { "ldi", emit_lda, NULL,
3064 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3065 { "ldil", emit_ldil, NULL,
3066 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3067 { "ldiq", emit_lda, NULL,
3068 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3070 { "stl", emit_loadstore, "stl",
3071 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3072 { "stl_c", emit_loadstore, "stl_c",
3073 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3074 { "stq", emit_loadstore, "stq",
3075 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3076 { "stq_c", emit_loadstore, "stq_c",
3077 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3078 { "stq_u", emit_loadstore, "stq_u",
3079 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3080 { "stf", emit_loadstore, "stf",
3081 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3082 { "stg", emit_loadstore, "stg",
3083 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3084 { "sts", emit_loadstore, "sts",
3085 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3086 { "stt", emit_loadstore, "stt",
3087 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3089 { "stb", emit_stX, (void *) 0,
3090 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3091 { "stw", emit_stX, (void *) 1,
3092 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3093 { "ustw", emit_ustX, (void *) 1,
3094 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3095 { "ustl", emit_ustX, (void *) 2,
3096 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3097 { "ustq", emit_ustX, (void *) 3,
3098 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3100 /* Arithmetic macros. */
3102 { "sextb", emit_sextX, (void *) 0,
3103 { MACRO_IR, MACRO_IR, MACRO_EOA,
3104 MACRO_IR, MACRO_EOA,
3105 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3106 { "sextw", emit_sextX, (void *) 1,
3107 { MACRO_IR, MACRO_IR, MACRO_EOA,
3108 MACRO_IR, MACRO_EOA,
3109 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3111 { "divl", emit_division, "__divl",
3112 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3113 MACRO_IR, MACRO_IR, MACRO_EOA,
3114 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3115 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3116 { "divlu", emit_division, "__divlu",
3117 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3118 MACRO_IR, MACRO_IR, MACRO_EOA,
3119 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3120 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3121 { "divq", emit_division, "__divq",
3122 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3123 MACRO_IR, MACRO_IR, MACRO_EOA,
3124 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3125 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3126 { "divqu", emit_division, "__divqu",
3127 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3128 MACRO_IR, MACRO_IR, MACRO_EOA,
3129 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3130 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3131 { "reml", emit_division, "__reml",
3132 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3133 MACRO_IR, MACRO_IR, MACRO_EOA,
3134 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3135 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3136 { "remlu", emit_division, "__remlu",
3137 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3138 MACRO_IR, MACRO_IR, MACRO_EOA,
3139 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3140 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3141 { "remq", emit_division, "__remq",
3142 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3143 MACRO_IR, MACRO_IR, MACRO_EOA,
3144 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3145 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3146 { "remqu", emit_division, "__remqu",
3147 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3148 MACRO_IR, MACRO_IR, MACRO_EOA,
3149 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3150 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3152 { "jsr", emit_jsrjmp, "jsr",
3153 { MACRO_PIR, MACRO_EXP, MACRO_EOA,
3154 MACRO_PIR, MACRO_EOA,
3155 MACRO_IR, MACRO_EXP, MACRO_EOA,
3156 MACRO_EXP, MACRO_EOA } },
3157 { "jmp", emit_jsrjmp, "jmp",
3158 { MACRO_PIR, MACRO_EXP, MACRO_EOA,
3159 MACRO_PIR, MACRO_EOA,
3160 MACRO_IR, MACRO_EXP, MACRO_EOA,
3161 MACRO_EXP, MACRO_EOA } },
3162 { "ret", emit_retjcr, "ret",
3163 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3164 MACRO_IR, MACRO_EOA,
3165 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3166 MACRO_PIR, MACRO_EOA,
3167 MACRO_EXP, MACRO_EOA,
3169 { "jcr", emit_retjcr, "jcr",
3170 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3171 MACRO_IR, MACRO_EOA,
3172 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3173 MACRO_PIR, MACRO_EOA,
3174 MACRO_EXP, MACRO_EOA,
3176 { "jsr_coroutine", emit_retjcr, "jcr",
3177 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3178 MACRO_IR, MACRO_EOA,
3179 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3180 MACRO_PIR, MACRO_EOA,
3181 MACRO_EXP, MACRO_EOA,
3185 static const unsigned int alpha_num_macros
3186 = sizeof (alpha_macros) / sizeof (*alpha_macros);
3188 /* Search forward through all variants of a macro looking for a syntax
3191 static const struct alpha_macro *
3192 find_macro_match (const struct alpha_macro *first_macro,
3193 const expressionS *tok,
3197 const struct alpha_macro *macro = first_macro;
3202 const enum alpha_macro_arg *arg = macro->argsets;
3216 /* Index register. */
3218 if (tokidx >= ntok || tok[tokidx].X_op != O_register
3219 || !is_ir_num (tok[tokidx].X_add_number))
3224 /* Parenthesized index register. */
3226 if (tokidx >= ntok || tok[tokidx].X_op != O_pregister
3227 || !is_ir_num (tok[tokidx].X_add_number))
3232 /* Optional parenthesized index register. */
3234 if (tokidx < ntok && tok[tokidx].X_op == O_pregister
3235 && is_ir_num (tok[tokidx].X_add_number))
3239 /* Leading comma with a parenthesized index register. */
3241 if (tokidx >= ntok || tok[tokidx].X_op != O_cpregister
3242 || !is_ir_num (tok[tokidx].X_add_number))
3247 /* Floating point register. */
3249 if (tokidx >= ntok || tok[tokidx].X_op != O_register
3250 || !is_fpr_num (tok[tokidx].X_add_number))
3255 /* Normal expression. */
3259 switch (tok[tokidx].X_op)
3268 case O_lituse_bytoff:
3284 while (*arg != MACRO_EOA)
3292 while (++macro - alpha_macros < (int) alpha_num_macros
3293 && !strcmp (macro->name, first_macro->name));
3298 /* Given an opcode name and a pre-tokenized set of arguments, take the
3299 opcode all the way through emission. */
3302 assemble_tokens (const char *opname,
3303 const expressionS *tok,
3305 int local_macros_on)
3307 int found_something = 0;
3308 const struct alpha_opcode *opcode;
3309 const struct alpha_macro *macro;
3311 extended_bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
3314 /* If a user-specified relocation is present, this is not a macro. */
3315 if (ntok && USER_RELOC_P (tok[ntok - 1].X_op))
3317 reloc = ALPHA_RELOC_TABLE (tok[ntok - 1].X_op)->reloc;
3322 if (local_macros_on)
3324 macro = ((const struct alpha_macro *)
3325 hash_find (alpha_macro_hash, opname));
3328 found_something = 1;
3329 macro = find_macro_match (macro, tok, &ntok);
3332 (*macro->emit) (tok, ntok, macro->arg);
3338 /* Search opcodes. */
3339 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
3342 found_something = 1;
3343 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
3346 struct alpha_insn insn;
3347 assemble_insn (opcode, tok, ntok, &insn, reloc);
3349 /* Copy the sequence number for the reloc from the reloc token. */
3350 if (reloc != BFD_RELOC_UNUSED)
3351 insn.sequence = tok[ntok].X_add_number;
3358 if (found_something)
3361 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
3363 as_bad (_("opcode `%s' not supported for target %s"), opname,
3367 as_bad (_("unknown opcode `%s'"), opname);
3372 /* Add sym+addend to link pool.
3373 Return offset from curent procedure value (pv) to entry in link pool.
3375 Add new fixup only if offset isn't 16bit. */
3378 add_to_link_pool (symbolS *sym, offsetT addend)
3381 segT current_section = now_seg;
3382 int current_subsec = now_subseg;
3384 segment_info_type *seginfo = seg_info (alpha_link_section);
3386 symbolS *linksym, *expsym;
3389 basesym = alpha_evax_proc->symbol;
3391 /* @@ This assumes all entries in a given section will be of the same
3392 size... Probably correct, but unwise to rely on. */
3393 /* This must always be called with the same subsegment. */
3395 if (seginfo->frchainP)
3396 for (fixp = seginfo->frchainP->fix_root;
3397 fixp != (fixS *) NULL;
3398 fixp = fixp->fx_next)
3400 if (fixp->fx_addsy == sym
3401 && fixp->fx_offset == (valueT)addend
3402 && fixp->tc_fix_data.info
3403 && fixp->tc_fix_data.info->sym
3404 && fixp->tc_fix_data.info->sym->sy_value.X_op_symbol == basesym)
3405 return fixp->tc_fix_data.info->sym;
3408 /* Not found, add a new entry. */
3409 subseg_set (alpha_link_section, 0);
3410 linksym = symbol_new
3411 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
3415 /* Create a symbol for 'basesym - linksym' (offset of the added entry). */
3416 e.X_op = O_subtract;
3417 e.X_add_symbol = linksym;
3418 e.X_op_symbol = basesym;
3420 expsym = make_expr_symbol (&e);
3422 /* Create a fixup for the entry. */
3424 (frag_now, p - frag_now->fr_literal, 8, sym, addend, 0, BFD_RELOC_64);
3425 fixp->tc_fix_data.info = get_alpha_reloc_tag (next_sequence_num--);
3426 fixp->tc_fix_data.info->sym = expsym;
3428 subseg_set (current_section, current_subsec);
3430 /* Return the symbol. */
3433 #endif /* OBJ_EVAX */
3435 /* Assembler directives. */
3437 /* Handle the .text pseudo-op. This is like the usual one, but it
3438 clears alpha_insn_label and restores auto alignment. */
3441 s_alpha_text (int i)
3452 symbolP = symbol_find (".text");
3453 if (symbolP == NULL)
3455 symbolP = symbol_make (".text");
3456 S_SET_SEGMENT (symbolP, text_section);
3457 symbol_table_insert (symbolP);
3461 alpha_insn_label = NULL;
3462 alpha_auto_align_on = 1;
3463 alpha_current_align = 0;
3466 /* Handle the .data pseudo-op. This is like the usual one, but it
3467 clears alpha_insn_label and restores auto alignment. */
3470 s_alpha_data (int i)
3477 alpha_insn_label = NULL;
3478 alpha_auto_align_on = 1;
3479 alpha_current_align = 0;
3482 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3484 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3487 s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
3499 c = get_symbol_name (&name);
3501 /* Just after name is now '\0'. */
3502 p = input_line_pointer;
3505 SKIP_WHITESPACE_AFTER_NAME ();
3507 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3508 if (*input_line_pointer == ',')
3510 input_line_pointer++;
3513 if ((size = get_absolute_expression ()) < 0)
3515 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
3516 ignore_rest_of_line ();
3521 symbolP = symbol_find_or_make (name);
3524 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3526 as_bad (_("Ignoring attempt to re-define symbol"));
3527 ignore_rest_of_line ();
3532 if (*input_line_pointer != ',')
3533 temp = 8; /* Default alignment. */
3536 input_line_pointer++;
3538 temp = get_absolute_expression ();
3541 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3542 while ((temp >>= 1) != 0)
3545 if (*input_line_pointer == ',')
3547 /* Extended form of the directive
3549 .comm symbol, size, alignment, section
3551 where the "common" semantics is transferred to the section.
3552 The symbol is effectively an alias for the section name. */
3555 const char *sec_name;
3556 symbolS *sec_symbol;
3557 segT current_seg = now_seg;
3558 subsegT current_subseg = now_subseg;
3561 input_line_pointer++;
3563 sec_name = s_alpha_section_name ();
3564 sec_symbol = symbol_find_or_make (sec_name);
3565 sec = subseg_new (sec_name, 0);
3566 S_SET_SEGMENT (sec_symbol, sec);
3567 symbol_get_bfdsym (sec_symbol)->flags |= BSF_SECTION_SYM;
3568 bfd_vms_set_section_flags (stdoutput, sec, 0,
3569 EGPS__V_OVR | EGPS__V_GBL | EGPS__V_NOMOD);
3570 record_alignment (sec, log_align);
3572 /* Reuse stab_string_size to store the size of the section. */
3573 cur_size = seg_info (sec)->stabu.stab_string_size;
3574 if ((int) size > cur_size)
3577 = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL,
3578 (valueT)size - (valueT)cur_size, NULL);
3580 seg_info (sec)->stabu.stab_string_size = (int)size;
3583 S_SET_SEGMENT (symbolP, sec);
3585 subseg_set (current_seg, current_subseg);
3589 /* Regular form of the directive
3591 .comm symbol, size, alignment
3593 where the "common" semantics in on the symbol.
3594 These symbols are assembled in the .bss section. */
3597 segT current_seg = now_seg;
3598 subsegT current_subseg = now_subseg;
3600 subseg_set (bss_section, 1);
3601 frag_align (log_align, 0, 0);
3602 record_alignment (bss_section, log_align);
3604 symbol_set_frag (symbolP, frag_now);
3605 pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
3609 S_SET_SEGMENT (symbolP, bss_section);
3611 subseg_set (current_seg, current_subseg);
3615 if (S_GET_VALUE (symbolP))
3617 if (S_GET_VALUE (symbolP) != (valueT) size)
3618 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3619 S_GET_NAME (symbolP),
3620 (long) S_GET_VALUE (symbolP),
3626 S_SET_VALUE (symbolP, (valueT) size);
3628 S_SET_EXTERNAL (symbolP);
3632 know (symbolP->sy_frag == &zero_address_frag);
3634 demand_empty_rest_of_line ();
3637 #endif /* ! OBJ_ELF */
3641 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3642 clears alpha_insn_label and restores auto alignment. */
3645 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED)
3647 get_absolute_expression ();
3648 subseg_new (".rdata", 0);
3649 demand_empty_rest_of_line ();
3650 alpha_insn_label = NULL;
3651 alpha_auto_align_on = 1;
3652 alpha_current_align = 0;
3659 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3660 clears alpha_insn_label and restores auto alignment. */
3663 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED)
3665 get_absolute_expression ();
3666 subseg_new (".sdata", 0);
3667 demand_empty_rest_of_line ();
3668 alpha_insn_label = NULL;
3669 alpha_auto_align_on = 1;
3670 alpha_current_align = 0;
3675 struct alpha_elf_frame_data
3678 symbolS *func_end_sym;
3679 symbolS *prologue_sym;
3685 offsetT mask_offset;
3686 offsetT fmask_offset;
3688 struct alpha_elf_frame_data *next;
3691 static struct alpha_elf_frame_data *all_frame_data;
3692 static struct alpha_elf_frame_data **plast_frame_data = &all_frame_data;
3693 static struct alpha_elf_frame_data *cur_frame_data;
3695 extern int all_cfi_sections;
3697 /* Handle the .section pseudo-op. This is like the usual one, but it
3698 clears alpha_insn_label and restores auto alignment. */
3701 s_alpha_section (int ignore ATTRIBUTE_UNUSED)
3703 obj_elf_section (ignore);
3705 alpha_insn_label = NULL;
3706 alpha_auto_align_on = 1;
3707 alpha_current_align = 0;
3711 s_alpha_ent (int dummy ATTRIBUTE_UNUSED)
3713 if (ECOFF_DEBUGGING)
3714 ecoff_directive_ent (0);
3717 char *name, name_end;
3719 name_end = get_symbol_name (&name);
3720 /* CFI_EMIT_eh_frame is the default. */
3721 all_cfi_sections = CFI_EMIT_eh_frame;
3723 if (! is_name_beginner (*name))
3725 as_warn (_(".ent directive has no name"));
3726 (void) restore_line_pointer (name_end);
3733 as_warn (_("nested .ent directives"));
3735 sym = symbol_find_or_make (name);
3736 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
3738 cur_frame_data = (struct alpha_elf_frame_data *)
3739 calloc (1, sizeof (*cur_frame_data));
3740 cur_frame_data->func_sym = sym;
3742 /* Provide sensible defaults. */
3743 cur_frame_data->fp_regno = 30; /* sp */
3744 cur_frame_data->ra_regno = 26; /* ra */
3746 *plast_frame_data = cur_frame_data;
3747 plast_frame_data = &cur_frame_data->next;
3749 /* The .ent directive is sometimes followed by a number. Not sure
3750 what it really means, but ignore it. */
3751 *input_line_pointer = name_end;
3752 SKIP_WHITESPACE_AFTER_NAME ();
3753 if (*input_line_pointer == ',')
3755 input_line_pointer++;
3758 if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
3759 (void) get_absolute_expression ();
3761 demand_empty_rest_of_line ();
3766 s_alpha_end (int dummy ATTRIBUTE_UNUSED)
3768 if (ECOFF_DEBUGGING)
3769 ecoff_directive_end (0);
3772 char *name, name_end;
3774 name_end = get_symbol_name (&name);
3776 if (! is_name_beginner (*name))
3778 as_warn (_(".end directive has no name"));
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;
3808 (void) restore_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_end = get_symbol_name (&name);
4135 if (! is_name_beginner (*name))
4137 as_bad (_(".usepv directive has no name"));
4138 (void) restore_line_pointer (name_end);
4139 ignore_rest_of_line ();
4143 sym = symbol_find_or_make (name);
4144 name_end = restore_line_pointer (name_end);
4145 if (! is_end_of_line[(unsigned char) name_end])
4146 input_line_pointer++;
4148 if (name_end != ',')
4150 as_bad (_(".usepv directive has no type"));
4151 ignore_rest_of_line ();
4157 which_end = get_symbol_name (&which);
4159 if (strcmp (which, "no") == 0)
4160 other = STO_ALPHA_NOPV;
4161 else if (strcmp (which, "std") == 0)
4162 other = STO_ALPHA_STD_GPLOAD;
4165 as_bad (_("unknown argument for .usepv"));
4169 (void) restore_line_pointer (which_end);
4170 demand_empty_rest_of_line ();
4172 S_SET_OTHER (sym, other | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
4174 #endif /* OBJ_ELF */
4176 /* Standard calling conventions leaves the CFA at $30 on entry. */
4179 alpha_cfi_frame_initial_instructions (void)
4181 cfi_add_CFA_def_cfa_register (30);
4186 /* Get name of section. */
4188 s_alpha_section_name (void)
4193 if (*input_line_pointer == '"')
4197 name = demand_copy_C_string (&dummy);
4200 ignore_rest_of_line ();
4206 char *end = input_line_pointer;
4208 while (0 == strchr ("\n\t,; ", *end))
4210 if (end == input_line_pointer)
4212 as_warn (_("missing name"));
4213 ignore_rest_of_line ();
4217 name = xmalloc (end - input_line_pointer + 1);
4218 memcpy (name, input_line_pointer, end - input_line_pointer);
4219 name[end - input_line_pointer] = '\0';
4220 input_line_pointer = end;
4226 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4227 the MSBs are the flags to be cleared. */
4229 #define EGPS__V_NO_SHIFT 16
4230 #define EGPS__V_MASK 0xffff
4232 /* Parse one VMS section flag. */
4235 s_alpha_section_word (char *str, size_t len)
4240 if (len == 5 && strncmp (str, "NO", 2) == 0)
4249 if (strncmp (str, "PIC", 3) == 0)
4251 else if (strncmp (str, "LIB", 3) == 0)
4253 else if (strncmp (str, "OVR", 3) == 0)
4255 else if (strncmp (str, "REL", 3) == 0)
4257 else if (strncmp (str, "GBL", 3) == 0)
4259 else if (strncmp (str, "SHR", 3) == 0)
4261 else if (strncmp (str, "EXE", 3) == 0)
4263 else if (strncmp (str, "WRT", 3) == 0)
4265 else if (strncmp (str, "VEC", 3) == 0)
4267 else if (strncmp (str, "MOD", 3) == 0)
4269 flag = no ? EGPS__V_NOMOD : EGPS__V_NOMOD << EGPS__V_NO_SHIFT;
4272 else if (strncmp (str, "COM", 3) == 0)
4280 as_warn (_("unknown section attribute %s"), str);
4286 return flag << EGPS__V_NO_SHIFT;
4291 /* Handle the section specific pseudo-op. */
4293 #define EVAX_SECTION_COUNT 5
4295 static const char *section_name[EVAX_SECTION_COUNT + 1] =
4296 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4299 s_alpha_section (int secid)
4304 flagword vms_flags = 0;
4309 name = s_alpha_section_name ();
4312 sec = subseg_new (name, 0);
4313 if (*input_line_pointer == ',')
4315 /* Skip the comma. */
4316 ++input_line_pointer;
4324 c = get_symbol_name (&beg);
4325 *input_line_pointer = c;
4327 vms_flags |= s_alpha_section_word (beg, input_line_pointer - beg);
4329 SKIP_WHITESPACE_AFTER_NAME ();
4331 while (*input_line_pointer++ == ',');
4333 --input_line_pointer;
4336 symbol = symbol_find_or_make (name);
4337 S_SET_SEGMENT (symbol, sec);
4338 symbol_get_bfdsym (symbol)->flags |= BSF_SECTION_SYM;
4339 bfd_vms_set_section_flags
4341 (vms_flags >> EGPS__V_NO_SHIFT) & EGPS__V_MASK,
4342 vms_flags & EGPS__V_MASK);
4346 get_absolute_expression ();
4347 subseg_new (section_name[secid], 0);
4350 demand_empty_rest_of_line ();
4351 alpha_insn_label = NULL;
4352 alpha_auto_align_on = 1;
4353 alpha_current_align = 0;
4357 s_alpha_literals (int ignore ATTRIBUTE_UNUSED)
4359 subseg_new (".literals", 0);
4360 demand_empty_rest_of_line ();
4361 alpha_insn_label = NULL;
4362 alpha_auto_align_on = 1;
4363 alpha_current_align = 0;
4366 /* Parse .ent directives. */
4369 s_alpha_ent (int ignore ATTRIBUTE_UNUSED)
4372 expressionS symexpr;
4374 if (alpha_evax_proc != NULL)
4375 as_bad (_("previous .ent not closed by a .end"));
4377 alpha_evax_proc = &alpha_evax_proc_data;
4379 alpha_evax_proc->pdsckind = 0;
4380 alpha_evax_proc->framereg = -1;
4381 alpha_evax_proc->framesize = 0;
4382 alpha_evax_proc->rsa_offset = 0;
4383 alpha_evax_proc->ra_save = AXP_REG_RA;
4384 alpha_evax_proc->fp_save = -1;
4385 alpha_evax_proc->imask = 0;
4386 alpha_evax_proc->fmask = 0;
4387 alpha_evax_proc->prologue = 0;
4388 alpha_evax_proc->type = 0;
4389 alpha_evax_proc->handler = 0;
4390 alpha_evax_proc->handler_data = 0;
4392 expression (&symexpr);
4394 if (symexpr.X_op != O_symbol)
4396 as_fatal (_(".ent directive has no symbol"));
4397 demand_empty_rest_of_line ();
4401 symbol = make_expr_symbol (&symexpr);
4402 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
4403 alpha_evax_proc->symbol = symbol;
4405 demand_empty_rest_of_line ();
4409 s_alpha_handler (int is_data)
4412 alpha_evax_proc->handler_data = get_absolute_expression ();
4415 char *name, name_end;
4417 name_end = get_symbol_name (&name);
4419 if (! is_name_beginner (*name))
4421 as_warn (_(".handler directive has no name"));
4427 sym = symbol_find_or_make (name);
4428 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
4429 alpha_evax_proc->handler = sym;
4432 (void) restore_line_pointer (name_end);
4435 demand_empty_rest_of_line ();
4438 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4441 s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
4446 alpha_evax_proc->framereg = tc_get_register (1);
4449 if (*input_line_pointer++ != ','
4450 || get_absolute_expression_and_terminator (&val) != ',')
4452 as_warn (_("Bad .frame directive 1./2. param"));
4453 --input_line_pointer;
4454 demand_empty_rest_of_line ();
4458 alpha_evax_proc->framesize = val;
4460 ra = tc_get_register (1);
4461 if (ra != AXP_REG_RA)
4462 as_warn (_("Bad RA (%d) register for .frame"), ra);
4465 if (*input_line_pointer++ != ',')
4467 as_warn (_("Bad .frame directive 3./4. param"));
4468 --input_line_pointer;
4469 demand_empty_rest_of_line ();
4472 alpha_evax_proc->rsa_offset = get_absolute_expression ();
4475 /* Parse .prologue. */
4478 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
4480 demand_empty_rest_of_line ();
4481 alpha_prologue_label = symbol_new
4482 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4485 /* Parse .pdesc <entry_name>,{null|stack|reg}
4486 Insert a procedure descriptor. */
4489 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
4496 const char *entry_sym_name;
4497 const char *pdesc_sym_name;
4501 if (now_seg != alpha_link_section)
4503 as_bad (_(".pdesc directive not in link (.link) section"));
4508 if (exp.X_op != O_symbol)
4510 as_bad (_(".pdesc directive has no entry symbol"));
4514 entry_sym = make_expr_symbol (&exp);
4515 entry_sym_name = S_GET_NAME (entry_sym);
4518 len = strlen (entry_sym_name);
4519 if (len < 4 || strcmp (entry_sym_name + len - 4, "..en") != 0)
4521 as_bad (_(".pdesc has a bad entry symbol"));
4525 pdesc_sym_name = S_GET_NAME (alpha_evax_proc->symbol);
4527 if (!alpha_evax_proc
4528 || !S_IS_DEFINED (alpha_evax_proc->symbol)
4529 || strlen (pdesc_sym_name) != len
4530 || memcmp (entry_sym_name, pdesc_sym_name, len) != 0)
4532 as_fatal (_(".pdesc doesn't match with last .ent"));
4536 /* Define pdesc symbol. */
4537 symbol_set_value_now (alpha_evax_proc->symbol);
4539 /* Save bfd symbol of proc entry in function symbol. */
4540 ((struct evax_private_udata_struct *)
4541 symbol_get_bfdsym (alpha_evax_proc->symbol)->udata.p)->enbsym
4542 = symbol_get_bfdsym (entry_sym);
4545 if (*input_line_pointer++ != ',')
4547 as_warn (_("No comma after .pdesc <entryname>"));
4548 demand_empty_rest_of_line ();
4553 name_end = get_symbol_name (&name);
4555 if (strncmp (name, "stack", 5) == 0)
4556 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_STACK;
4558 else if (strncmp (name, "reg", 3) == 0)
4559 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_REGISTER;
4561 else if (strncmp (name, "null", 4) == 0)
4562 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_NULL;
4566 (void) restore_line_pointer (name_end);
4567 as_fatal (_("unknown procedure kind"));
4568 demand_empty_rest_of_line ();
4572 (void) restore_line_pointer (name_end);
4573 demand_empty_rest_of_line ();
4575 #ifdef md_flush_pending_output
4576 md_flush_pending_output ();
4579 frag_align (3, 0, 0);
4581 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4584 *p = alpha_evax_proc->pdsckind
4585 | ((alpha_evax_proc->framereg == 29) ? PDSC_S_M_BASE_REG_IS_FP : 0)
4586 | ((alpha_evax_proc->handler) ? PDSC_S_M_HANDLER_VALID : 0)
4587 | ((alpha_evax_proc->handler_data) ? PDSC_S_M_HANDLER_DATA_VALID : 0);
4588 *(p + 1) = PDSC_S_M_NATIVE | PDSC_S_M_NO_JACKET;
4590 switch (alpha_evax_proc->pdsckind)
4592 case PDSC_S_K_KIND_NULL:
4596 case PDSC_S_K_KIND_FP_REGISTER:
4597 *(p + 2) = alpha_evax_proc->fp_save;
4598 *(p + 3) = alpha_evax_proc->ra_save;
4600 case PDSC_S_K_KIND_FP_STACK:
4601 md_number_to_chars (p + 2, (valueT) alpha_evax_proc->rsa_offset, 2);
4603 default: /* impossible */
4608 *(p + 5) = alpha_evax_proc->type & 0x0f;
4610 /* Signature offset. */
4611 md_number_to_chars (p + 6, (valueT) 0, 2);
4613 fix_new_exp (frag_now, p - frag_now->fr_literal + 8,
4614 8, &exp, 0, BFD_RELOC_64);
4616 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_NULL)
4619 /* pdesc+16: Size. */
4621 md_number_to_chars (p, (valueT) alpha_evax_proc->framesize, 4);
4622 md_number_to_chars (p + 4, (valueT) 0, 2);
4625 exp.X_op = O_subtract;
4626 exp.X_add_symbol = alpha_prologue_label;
4627 exp.X_op_symbol = entry_sym;
4628 emit_expr (&exp, 2);
4630 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_FP_REGISTER)
4633 /* pdesc+24: register masks. */
4635 md_number_to_chars (p, alpha_evax_proc->imask, 4);
4636 md_number_to_chars (p + 4, alpha_evax_proc->fmask, 4);
4638 if (alpha_evax_proc->handler)
4641 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8,
4642 alpha_evax_proc->handler, 0, 0, BFD_RELOC_64);
4645 if (alpha_evax_proc->handler_data)
4648 md_number_to_chars (p, alpha_evax_proc->handler_data, 8);
4652 /* Support for crash debug on vms. */
4655 s_alpha_name (int ignore ATTRIBUTE_UNUSED)
4660 if (now_seg != alpha_link_section)
4662 as_bad (_(".name directive not in link (.link) section"));
4663 demand_empty_rest_of_line ();
4668 if (exp.X_op != O_symbol)
4670 as_warn (_(".name directive has no symbol"));
4671 demand_empty_rest_of_line ();
4675 demand_empty_rest_of_line ();
4677 #ifdef md_flush_pending_output
4678 md_flush_pending_output ();
4681 frag_align (3, 0, 0);
4684 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0, BFD_RELOC_64);
4687 /* Parse .linkage <symbol>.
4688 Create a linkage pair relocation. */
4691 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED)
4697 #ifdef md_flush_pending_output
4698 md_flush_pending_output ();
4702 if (exp.X_op != O_symbol)
4704 as_fatal (_("No symbol after .linkage"));
4708 struct alpha_linkage_fixups *linkage_fixup;
4710 p = frag_more (LKP_S_K_SIZE);
4711 memset (p, 0, LKP_S_K_SIZE);
4713 (frag_now, p - frag_now->fr_literal, LKP_S_K_SIZE, &exp, 0,
4714 BFD_RELOC_ALPHA_LINKAGE);
4716 if (alpha_insn_label == NULL)
4717 alpha_insn_label = symbol_new
4718 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4720 /* Create a linkage element. */
4721 linkage_fixup = (struct alpha_linkage_fixups *)
4722 xmalloc (sizeof (struct alpha_linkage_fixups));
4723 linkage_fixup->fixp = fixp;
4724 linkage_fixup->next = NULL;
4725 linkage_fixup->label = alpha_insn_label;
4727 /* Append it to the list. */
4728 if (alpha_linkage_fixup_root == NULL)
4729 alpha_linkage_fixup_root = linkage_fixup;
4731 alpha_linkage_fixup_tail->next = linkage_fixup;
4732 alpha_linkage_fixup_tail = linkage_fixup;
4734 demand_empty_rest_of_line ();
4737 /* Parse .code_address <symbol>.
4738 Create a code address relocation. */
4741 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED)
4746 #ifdef md_flush_pending_output
4747 md_flush_pending_output ();
4751 if (exp.X_op != O_symbol)
4752 as_fatal (_("No symbol after .code_address"));
4757 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0,\
4758 BFD_RELOC_ALPHA_CODEADDR);
4760 demand_empty_rest_of_line ();
4764 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED)
4766 alpha_evax_proc->fp_save = tc_get_register (1);
4768 demand_empty_rest_of_line ();
4772 s_alpha_mask (int ignore ATTRIBUTE_UNUSED)
4776 if (get_absolute_expression_and_terminator (&val) != ',')
4778 as_warn (_("Bad .mask directive"));
4779 --input_line_pointer;
4783 alpha_evax_proc->imask = val;
4784 (void) get_absolute_expression ();
4786 demand_empty_rest_of_line ();
4790 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED)
4794 if (get_absolute_expression_and_terminator (&val) != ',')
4796 as_warn (_("Bad .fmask directive"));
4797 --input_line_pointer;
4801 alpha_evax_proc->fmask = val;
4802 (void) get_absolute_expression ();
4804 demand_empty_rest_of_line ();
4808 s_alpha_end (int ignore ATTRIBUTE_UNUSED)
4813 c = get_symbol_name (&name);
4814 (void) restore_line_pointer (c);
4815 demand_empty_rest_of_line ();
4816 alpha_evax_proc = NULL;
4820 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
4824 static char case_hack[32];
4826 sprintf (case_hack, "<CASE:%01d%01d>",
4827 alpha_flag_hash_long_names, alpha_flag_show_after_trunc);
4829 s = symbol_find_or_make (case_hack);
4830 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4832 get_absolute_expression ();
4833 s = symbol_find_or_make (demand_copy_string (&length));
4834 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4835 demand_empty_rest_of_line ();
4837 #endif /* OBJ_EVAX */
4839 /* Handle the .gprel32 pseudo op. */
4842 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED)
4854 e.X_add_symbol = section_symbol (absolute_section);
4867 e.X_add_symbol = section_symbol (absolute_section);
4870 e.X_op = O_subtract;
4871 e.X_op_symbol = alpha_gp_symbol;
4879 if (alpha_auto_align_on && alpha_current_align < 2)
4880 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
4881 if (alpha_current_align > 2)
4882 alpha_current_align = 2;
4883 alpha_insn_label = NULL;
4887 fix_new_exp (frag_now, p - frag_now->fr_literal, 4,
4888 &e, 0, BFD_RELOC_GPREL32);
4891 /* Handle floating point allocation pseudo-ops. This is like the
4892 generic vresion, but it makes sure the current label, if any, is
4893 correctly aligned. */
4896 s_alpha_float_cons (int type)
4922 if (alpha_auto_align_on && alpha_current_align < log_size)
4923 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
4924 if (alpha_current_align > log_size)
4925 alpha_current_align = log_size;
4926 alpha_insn_label = NULL;
4931 /* Handle the .proc pseudo op. We don't really do much with it except
4935 s_alpha_proc (int is_static ATTRIBUTE_UNUSED)
4943 /* Takes ".proc name,nargs". */
4945 c = get_symbol_name (&name);
4946 p = input_line_pointer;
4947 symbolP = symbol_find_or_make (name);
4949 SKIP_WHITESPACE_AFTER_NAME ();
4950 if (*input_line_pointer != ',')
4953 as_warn (_("Expected comma after name \"%s\""), name);
4956 ignore_rest_of_line ();
4960 input_line_pointer++;
4961 temp = get_absolute_expression ();
4963 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4965 as_warn (_("unhandled: .proc %s,%d"), name, temp);
4966 demand_empty_rest_of_line ();
4969 /* Handle the .set pseudo op. This is used to turn on and off most of
4970 the assembler features. */
4973 s_alpha_set (int x ATTRIBUTE_UNUSED)
4980 ch = get_symbol_name (&name);
4982 if (s[0] == 'n' && s[1] == 'o')
4987 if (!strcmp ("reorder", s))
4989 else if (!strcmp ("at", s))
4990 alpha_noat_on = !yesno;
4991 else if (!strcmp ("macro", s))
4992 alpha_macros_on = yesno;
4993 else if (!strcmp ("move", s))
4995 else if (!strcmp ("volatile", s))
4998 as_warn (_("Tried to .set unrecognized mode `%s'"), name);
5000 (void) restore_line_pointer (ch);
5001 demand_empty_rest_of_line ();
5004 /* Handle the .base pseudo op. This changes the assembler's notion of
5005 the $gp register. */
5008 s_alpha_base (int ignore ATTRIBUTE_UNUSED)
5012 if (*input_line_pointer == '$')
5015 input_line_pointer++;
5016 if (*input_line_pointer == 'r')
5017 input_line_pointer++;
5020 alpha_gp_register = get_absolute_expression ();
5021 if (alpha_gp_register < 0 || alpha_gp_register > 31)
5023 alpha_gp_register = AXP_REG_GP;
5024 as_warn (_("Bad base register, using $%d."), alpha_gp_register);
5027 demand_empty_rest_of_line ();
5030 /* Handle the .align pseudo-op. This aligns to a power of two. It
5031 also adjusts any current instruction label. We treat this the same
5032 way the MIPS port does: .align 0 turns off auto alignment. */
5035 s_alpha_align (int ignore ATTRIBUTE_UNUSED)
5039 long max_alignment = 16;
5041 align = get_absolute_expression ();
5042 if (align > max_alignment)
5044 align = max_alignment;
5045 as_bad (_("Alignment too large: %d. assumed"), align);
5049 as_warn (_("Alignment negative: 0 assumed"));
5053 if (*input_line_pointer == ',')
5055 input_line_pointer++;
5056 fill = get_absolute_expression ();
5064 alpha_auto_align_on = 1;
5065 alpha_align (align, pfill, NULL, 1);
5069 alpha_auto_align_on = 0;
5071 alpha_insn_label = NULL;
5073 demand_empty_rest_of_line ();
5076 /* Hook the normal string processor to reset known alignment. */
5079 s_alpha_stringer (int terminate)
5081 alpha_current_align = 0;
5082 alpha_insn_label = NULL;
5083 stringer (8 + terminate);
5086 /* Hook the normal space processing to reset known alignment. */
5089 s_alpha_space (int ignore)
5091 alpha_current_align = 0;
5092 alpha_insn_label = NULL;
5096 /* Hook into cons for auto-alignment. */
5099 alpha_cons_align (int size)
5104 while ((size >>= 1) != 0)
5107 if (alpha_auto_align_on && alpha_current_align < log_size)
5108 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
5109 if (alpha_current_align > log_size)
5110 alpha_current_align = log_size;
5111 alpha_insn_label = NULL;
5114 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5115 pseudos. We just turn off auto-alignment and call down to cons. */
5118 s_alpha_ucons (int bytes)
5120 int hold = alpha_auto_align_on;
5121 alpha_auto_align_on = 0;
5123 alpha_auto_align_on = hold;
5126 /* Switch the working cpu type. */
5129 s_alpha_arch (int ignored ATTRIBUTE_UNUSED)
5132 const struct cpu_type *p;
5136 ch = get_symbol_name (&name);
5138 for (p = cpu_types; p->name; ++p)
5139 if (strcmp (name, p->name) == 0)
5141 alpha_target_name = p->name, alpha_target = p->flags;
5144 as_warn (_("Unknown CPU identifier `%s'"), name);
5147 (void) restore_line_pointer (ch);
5148 demand_empty_rest_of_line ();
5152 /* print token expression with alpha specific extension. */
5155 alpha_print_token (FILE *f, const expressionS *exp)
5165 expressionS nexp = *exp;
5166 nexp.X_op = O_register;
5167 print_expr_1 (f, &nexp);
5172 print_expr_1 (f, exp);
5178 /* The target specific pseudo-ops which we support. */
5180 const pseudo_typeS md_pseudo_table[] =
5183 {"comm", s_alpha_comm, 0}, /* OSF1 compiler does this. */
5184 {"rdata", s_alpha_rdata, 0},
5186 {"text", s_alpha_text, 0},
5187 {"data", s_alpha_data, 0},
5189 {"sdata", s_alpha_sdata, 0},
5192 {"section", s_alpha_section, 0},
5193 {"section.s", s_alpha_section, 0},
5194 {"sect", s_alpha_section, 0},
5195 {"sect.s", s_alpha_section, 0},
5198 {"section", s_alpha_section, 0},
5199 {"literals", s_alpha_literals, 0},
5200 {"pdesc", s_alpha_pdesc, 0},
5201 {"name", s_alpha_name, 0},
5202 {"linkage", s_alpha_linkage, 0},
5203 {"code_address", s_alpha_code_address, 0},
5204 {"ent", s_alpha_ent, 0},
5205 {"frame", s_alpha_frame, 0},
5206 {"fp_save", s_alpha_fp_save, 0},
5207 {"mask", s_alpha_mask, 0},
5208 {"fmask", s_alpha_fmask, 0},
5209 {"end", s_alpha_end, 0},
5210 {"file", s_alpha_file, 0},
5211 {"rdata", s_alpha_section, 1},
5212 {"comm", s_alpha_comm, 0},
5213 {"link", s_alpha_section, 3},
5214 {"ctors", s_alpha_section, 4},
5215 {"dtors", s_alpha_section, 5},
5216 {"handler", s_alpha_handler, 0},
5217 {"handler_data", s_alpha_handler, 1},
5220 /* Frame related pseudos. */
5221 {"ent", s_alpha_ent, 0},
5222 {"end", s_alpha_end, 0},
5223 {"mask", s_alpha_mask, 0},
5224 {"fmask", s_alpha_mask, 1},
5225 {"frame", s_alpha_frame, 0},
5226 {"prologue", s_alpha_prologue, 0},
5227 {"file", s_alpha_file, 5},
5228 {"loc", s_alpha_loc, 9},
5229 {"stabs", s_alpha_stab, 's'},
5230 {"stabn", s_alpha_stab, 'n'},
5231 {"usepv", s_alpha_usepv, 0},
5232 /* COFF debugging related pseudos. */
5233 {"begin", s_alpha_coff_wrapper, 0},
5234 {"bend", s_alpha_coff_wrapper, 1},
5235 {"def", s_alpha_coff_wrapper, 2},
5236 {"dim", s_alpha_coff_wrapper, 3},
5237 {"endef", s_alpha_coff_wrapper, 4},
5238 {"scl", s_alpha_coff_wrapper, 5},
5239 {"tag", s_alpha_coff_wrapper, 6},
5240 {"val", s_alpha_coff_wrapper, 7},
5243 {"prologue", s_alpha_prologue, 0},
5245 {"prologue", s_ignore, 0},
5248 {"gprel32", s_alpha_gprel32, 0},
5249 {"t_floating", s_alpha_float_cons, 'd'},
5250 {"s_floating", s_alpha_float_cons, 'f'},
5251 {"f_floating", s_alpha_float_cons, 'F'},
5252 {"g_floating", s_alpha_float_cons, 'G'},
5253 {"d_floating", s_alpha_float_cons, 'D'},
5255 {"proc", s_alpha_proc, 0},
5256 {"aproc", s_alpha_proc, 1},
5257 {"set", s_alpha_set, 0},
5258 {"reguse", s_ignore, 0},
5259 {"livereg", s_ignore, 0},
5260 {"base", s_alpha_base, 0}, /*??*/
5261 {"option", s_ignore, 0},
5262 {"aent", s_ignore, 0},
5263 {"ugen", s_ignore, 0},
5264 {"eflag", s_ignore, 0},
5266 {"align", s_alpha_align, 0},
5267 {"double", s_alpha_float_cons, 'd'},
5268 {"float", s_alpha_float_cons, 'f'},
5269 {"single", s_alpha_float_cons, 'f'},
5270 {"ascii", s_alpha_stringer, 0},
5271 {"asciz", s_alpha_stringer, 1},
5272 {"string", s_alpha_stringer, 1},
5273 {"space", s_alpha_space, 0},
5274 {"skip", s_alpha_space, 0},
5275 {"zero", s_alpha_space, 0},
5277 /* Unaligned data pseudos. */
5278 {"uword", s_alpha_ucons, 2},
5279 {"ulong", s_alpha_ucons, 4},
5280 {"uquad", s_alpha_ucons, 8},
5283 /* Dwarf wants these versions of unaligned. */
5284 {"2byte", s_alpha_ucons, 2},
5285 {"4byte", s_alpha_ucons, 4},
5286 {"8byte", s_alpha_ucons, 8},
5289 /* We don't do any optimizing, so we can safely ignore these. */
5290 {"noalias", s_ignore, 0},
5291 {"alias", s_ignore, 0},
5293 {"arch", s_alpha_arch, 0},
5300 /* @@@ GP selection voodoo. All of this seems overly complicated and
5301 unnecessary; which is the primary reason it's for ECOFF only. */
5304 maybe_set_gp (asection *sec)
5310 vma = bfd_get_section_vma (sec->owner, sec);
5311 if (vma && vma < alpha_gp_value)
5312 alpha_gp_value = vma;
5316 select_gp_value (void)
5318 gas_assert (alpha_gp_value == 0);
5320 /* Get minus-one in whatever width... */
5324 /* Select the smallest VMA of these existing sections. */
5325 maybe_set_gp (alpha_lita_section);
5327 /* @@ Will a simple 0x8000 work here? If not, why not? */
5328 #define GP_ADJUSTMENT (0x8000 - 0x10)
5330 alpha_gp_value += GP_ADJUSTMENT;
5332 S_SET_VALUE (alpha_gp_symbol, alpha_gp_value);
5335 printf (_("Chose GP value of %lx\n"), alpha_gp_value);
5338 #endif /* OBJ_ECOFF */
5341 /* Map 's' to SHF_ALPHA_GPREL. */
5344 alpha_elf_section_letter (int letter, const char **ptr_msg)
5347 return SHF_ALPHA_GPREL;
5349 *ptr_msg = _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5353 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5356 alpha_elf_section_flags (flagword flags, bfd_vma attr, int type ATTRIBUTE_UNUSED)
5358 if (attr & SHF_ALPHA_GPREL)
5359 flags |= SEC_SMALL_DATA;
5362 #endif /* OBJ_ELF */
5364 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5365 of an rs_align_code fragment. */
5368 alpha_handle_align (fragS *fragp)
5370 static unsigned char const unop[4] = { 0x00, 0x00, 0xfe, 0x2f };
5371 static unsigned char const nopunop[8] =
5373 0x1f, 0x04, 0xff, 0x47,
5374 0x00, 0x00, 0xfe, 0x2f
5380 if (fragp->fr_type != rs_align_code)
5383 bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
5384 p = fragp->fr_literal + fragp->fr_fix;
5397 memcpy (p, unop, 4);
5403 memcpy (p, nopunop, 8);
5405 fragp->fr_fix += fix;
5409 /* Public interface functions. */
5411 /* This function is called once, at assembler startup time. It sets
5412 up all the tables, etc. that the MD part of the assembler will
5413 need, that can be determined before arguments are parsed. */
5420 /* Verify that X_op field is wide enough. */
5425 gas_assert (e.X_op == O_max);
5428 /* Create the opcode hash table. */
5429 alpha_opcode_hash = hash_new ();
5431 for (i = 0; i < alpha_num_opcodes;)
5433 const char *name, *retval, *slash;
5435 name = alpha_opcodes[i].name;
5436 retval = hash_insert (alpha_opcode_hash, name, (void *) &alpha_opcodes[i]);
5438 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5441 /* Some opcodes include modifiers of various sorts with a "/mod"
5442 syntax, like the architecture manual suggests. However, for
5443 use with gcc at least, we also need access to those same opcodes
5446 if ((slash = strchr (name, '/')) != NULL)
5448 char *p = (char *) xmalloc (strlen (name));
5450 memcpy (p, name, slash - name);
5451 strcpy (p + (slash - name), slash + 1);
5453 (void) hash_insert (alpha_opcode_hash, p, (void *) &alpha_opcodes[i]);
5454 /* Ignore failures -- the opcode table does duplicate some
5455 variants in different forms, like "hw_stq" and "hw_st/q". */
5458 while (++i < alpha_num_opcodes
5459 && (alpha_opcodes[i].name == name
5460 || !strcmp (alpha_opcodes[i].name, name)))
5464 /* Create the macro hash table. */
5465 alpha_macro_hash = hash_new ();
5467 for (i = 0; i < alpha_num_macros;)
5469 const char *name, *retval;
5471 name = alpha_macros[i].name;
5472 retval = hash_insert (alpha_macro_hash, name, (void *) &alpha_macros[i]);
5474 as_fatal (_("internal error: can't hash macro `%s': %s"),
5477 while (++i < alpha_num_macros
5478 && (alpha_macros[i].name == name
5479 || !strcmp (alpha_macros[i].name, name)))
5483 /* Construct symbols for each of the registers. */
5484 for (i = 0; i < 32; ++i)
5488 sprintf (name, "$%d", i);
5489 alpha_register_table[i] = symbol_create (name, reg_section, i,
5490 &zero_address_frag);
5497 sprintf (name, "$f%d", i - 32);
5498 alpha_register_table[i] = symbol_create (name, reg_section, i,
5499 &zero_address_frag);
5502 /* Create the special symbols and sections we'll be using. */
5504 /* So .sbss will get used for tiny objects. */
5505 bfd_set_gp_size (stdoutput, g_switch_value);
5508 create_literal_section (".lita", &alpha_lita_section, &alpha_lita_symbol);
5510 /* For handling the GP, create a symbol that won't be output in the
5511 symbol table. We'll edit it out of relocs later. */
5512 alpha_gp_symbol = symbol_create ("<GP value>", alpha_lita_section, 0x8000,
5513 &zero_address_frag);
5517 create_literal_section (".link", &alpha_link_section, &alpha_link_symbol);
5521 if (ECOFF_DEBUGGING)
5523 segT sec = subseg_new (".mdebug", (subsegT) 0);
5524 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
5525 bfd_set_section_alignment (stdoutput, sec, 3);
5529 /* Create literal lookup hash table. */
5530 alpha_literal_hash = hash_new ();
5532 subseg_set (text_section, 0);
5535 /* The public interface to the instruction assembler. */
5538 md_assemble (char *str)
5540 /* Current maximum is 13. */
5542 expressionS tok[MAX_INSN_ARGS];
5546 /* Split off the opcode. */
5547 opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/46819");
5548 trunclen = (opnamelen < sizeof (opname) - 1
5550 : sizeof (opname) - 1);
5551 memcpy (opname, str, trunclen);
5552 opname[trunclen] = '\0';
5554 /* Tokenize the rest of the line. */
5555 if ((ntok = tokenize_arguments (str + opnamelen, tok, MAX_INSN_ARGS)) < 0)
5557 if (ntok != TOKENIZE_ERROR_REPORT)
5558 as_bad (_("syntax error"));
5563 /* Finish it off. */
5564 assemble_tokens (opname, tok, ntok, alpha_macros_on);
5567 /* Round up a section's size to the appropriate boundary. */
5570 md_section_align (segT seg, valueT size)
5572 int align = bfd_get_section_alignment (stdoutput, seg);
5573 valueT mask = ((valueT) 1 << align) - 1;
5575 return (size + mask) & ~mask;
5578 /* Turn a string in input_line_pointer into a floating point constant
5579 of type TYPE, and store the appropriate bytes in *LITP. The number
5580 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5581 returned, or NULL on OK. */
5584 md_atof (int type, char *litP, int *sizeP)
5586 extern const char *vax_md_atof (int, char *, int *);
5592 /* vax_md_atof() doesn't like "G" for some reason. */
5596 return vax_md_atof (type, litP, sizeP);
5599 return ieee_md_atof (type, litP, sizeP, FALSE);
5603 /* Take care of the target-specific command-line options. */
5606 md_parse_option (int c, const char *arg)
5611 alpha_nofloats_on = 1;
5615 alpha_addr32_on = 1;
5623 g_switch_value = atoi (arg);
5628 const struct cpu_type *p;
5630 for (p = cpu_types; p->name; ++p)
5631 if (strcmp (arg, p->name) == 0)
5633 alpha_target_name = p->name, alpha_target = p->flags;
5636 as_warn (_("Unknown CPU identifier `%s'"), arg);
5642 case '+': /* For g++. Hash any name > 63 chars long. */
5643 alpha_flag_hash_long_names = 1;
5646 case 'H': /* Show new symbol after hash truncation. */
5647 alpha_flag_show_after_trunc = 1;
5650 case 'h': /* For gnu-c/vax compatibility. */
5653 case OPTION_REPLACE:
5654 alpha_flag_replace = 1;
5657 case OPTION_NOREPLACE:
5658 alpha_flag_replace = 0;
5663 alpha_flag_relax = 1;
5668 alpha_flag_mdebug = 1;
5670 case OPTION_NO_MDEBUG:
5671 alpha_flag_mdebug = 0;
5682 /* Print a description of the command-line options that we accept. */
5685 md_show_usage (FILE *stream)
5689 -32addr treat addresses as 32-bit values\n\
5690 -F lack floating point instructions support\n\
5691 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5692 specify variant of Alpha architecture\n\
5693 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5694 these variants include PALcode opcodes\n"),
5699 -+ encode (don't truncate) names longer than 64 characters\n\
5700 -H show new symbol after hash truncation\n\
5701 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5706 /* Decide from what point a pc-relative relocation is relative to,
5707 relative to the pc-relative fixup. Er, relatively speaking. */
5710 md_pcrel_from (fixS *fixP)
5712 valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5714 switch (fixP->fx_r_type)
5716 case BFD_RELOC_23_PCREL_S2:
5717 case BFD_RELOC_ALPHA_HINT:
5718 case BFD_RELOC_ALPHA_BRSGP:
5725 /* Attempt to simplify or even eliminate a fixup. The return value is
5726 ignored; perhaps it was once meaningful, but now it is historical.
5727 To indicate that a fixup has been eliminated, set fixP->fx_done.
5729 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5730 internally into the GPDISP reloc used externally. We had to do
5731 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5732 the distance to the "lda" instruction for setting the addend to
5736 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
5738 char * const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5739 valueT value = * valP;
5740 unsigned image, size;
5742 switch (fixP->fx_r_type)
5744 /* The GPDISP relocations are processed internally with a symbol
5745 referring to the current function's section; we need to drop
5746 in a value which, when added to the address of the start of
5747 the function, gives the desired GP. */
5748 case BFD_RELOC_ALPHA_GPDISP_HI16:
5750 fixS *next = fixP->fx_next;
5752 /* With user-specified !gpdisp relocations, we can be missing
5753 the matching LO16 reloc. We will have already issued an
5756 fixP->fx_offset = (next->fx_frag->fr_address + next->fx_where
5757 - fixP->fx_frag->fr_address - fixP->fx_where);
5759 value = (value - sign_extend_16 (value)) >> 16;
5762 fixP->fx_r_type = BFD_RELOC_ALPHA_GPDISP;
5766 case BFD_RELOC_ALPHA_GPDISP_LO16:
5767 value = sign_extend_16 (value);
5768 fixP->fx_offset = 0;
5774 fixP->fx_addsy = section_symbol (seg);
5775 md_number_to_chars (fixpos, value, 2);
5780 fixP->fx_r_type = BFD_RELOC_16_PCREL;
5786 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5792 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5796 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5798 md_number_to_chars (fixpos, value, size);
5804 case BFD_RELOC_GPREL32:
5805 gas_assert (fixP->fx_subsy == alpha_gp_symbol);
5807 /* FIXME: inherited this obliviousness of `value' -- why? */
5808 md_number_to_chars (fixpos, -alpha_gp_value, 4);
5811 case BFD_RELOC_GPREL32:
5813 case BFD_RELOC_GPREL16:
5814 case BFD_RELOC_ALPHA_GPREL_HI16:
5815 case BFD_RELOC_ALPHA_GPREL_LO16:
5818 case BFD_RELOC_23_PCREL_S2:
5819 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5821 image = bfd_getl32 (fixpos);
5822 image = (image & ~0x1FFFFF) | ((value >> 2) & 0x1FFFFF);
5827 case BFD_RELOC_ALPHA_HINT:
5828 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5830 image = bfd_getl32 (fixpos);
5831 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5837 case BFD_RELOC_ALPHA_BRSGP:
5840 case BFD_RELOC_ALPHA_TLSGD:
5841 case BFD_RELOC_ALPHA_TLSLDM:
5842 case BFD_RELOC_ALPHA_GOTDTPREL16:
5843 case BFD_RELOC_ALPHA_DTPREL_HI16:
5844 case BFD_RELOC_ALPHA_DTPREL_LO16:
5845 case BFD_RELOC_ALPHA_DTPREL16:
5846 case BFD_RELOC_ALPHA_GOTTPREL16:
5847 case BFD_RELOC_ALPHA_TPREL_HI16:
5848 case BFD_RELOC_ALPHA_TPREL_LO16:
5849 case BFD_RELOC_ALPHA_TPREL16:
5851 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5856 case BFD_RELOC_ALPHA_LITERAL:
5857 md_number_to_chars (fixpos, value, 2);
5860 case BFD_RELOC_ALPHA_ELF_LITERAL:
5861 case BFD_RELOC_ALPHA_LITUSE:
5862 case BFD_RELOC_ALPHA_LINKAGE:
5863 case BFD_RELOC_ALPHA_CODEADDR:
5867 case BFD_RELOC_ALPHA_NOP:
5868 value -= (8 + 4); /* PC-relative, base is jsr+4. */
5870 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5871 "Finally, the ETIR$C_STC_BSR command passes the same address
5872 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5873 and the same test is done again." */
5874 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5876 fixP->fx_addnumber = -value;
5880 if ((abs (value) >> 2) & ~0xfffff)
5884 /* Change to a nop. */
5889 case BFD_RELOC_ALPHA_LDA:
5890 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5891 the value for an O_subtract. */
5893 && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5895 fixP->fx_addnumber = symbol_get_bfdsym (fixP->fx_subsy)->value;
5899 if ((abs (value)) & ~0x7fff)
5903 /* Change to an lda. */
5904 image = 0x237B0000 | (value & 0xFFFF);
5908 case BFD_RELOC_ALPHA_BSR:
5909 case BFD_RELOC_ALPHA_BOH:
5910 value -= 4; /* PC-relative, base is jsr+4. */
5912 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5913 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5915 fixP->fx_addnumber = -value;
5919 if ((abs (value) >> 2) & ~0xfffff)
5922 if (fixP->fx_r_type == BFD_RELOC_ALPHA_BOH)
5925 image = bfd_getl32(fixpos);
5926 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5933 /* Change to a branch. */
5934 image = 0xD3400000 | ((value >> 2) & 0x1FFFFF);
5939 case BFD_RELOC_VTABLE_INHERIT:
5940 case BFD_RELOC_VTABLE_ENTRY:
5945 const struct alpha_operand *operand;
5947 if ((int) fixP->fx_r_type >= 0)
5948 as_fatal (_("unhandled relocation type %s"),
5949 bfd_get_reloc_code_name (fixP->fx_r_type));
5951 gas_assert (-(int) fixP->fx_r_type < (int) alpha_num_operands);
5952 operand = &alpha_operands[-(int) fixP->fx_r_type];
5954 /* The rest of these fixups only exist internally during symbol
5955 resolution and have no representation in the object file.
5956 Therefore they must be completely resolved as constants. */
5958 if (fixP->fx_addsy != 0
5959 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
5960 as_bad_where (fixP->fx_file, fixP->fx_line,
5961 _("non-absolute expression in constant field"));
5963 image = bfd_getl32 (fixpos);
5964 image = insert_operand (image, operand, (offsetT) value,
5965 fixP->fx_file, fixP->fx_line);
5970 if (fixP->fx_addsy != 0 || fixP->fx_pcrel != 0)
5974 as_warn_where (fixP->fx_file, fixP->fx_line,
5975 _("type %d reloc done?\n"), (int) fixP->fx_r_type);
5980 md_number_to_chars (fixpos, image, 4);
5986 /* Look for a register name in the given symbol. */
5989 md_undefined_symbol (char *name)
5993 int is_float = 0, num;
5998 if (name[1] == 'p' && name[2] == '\0')
5999 return alpha_register_table[AXP_REG_FP];
6004 if (!ISDIGIT (*++name))
6008 case '0': case '1': case '2': case '3': case '4':
6009 case '5': case '6': case '7': case '8': case '9':
6010 if (name[1] == '\0')
6011 num = name[0] - '0';
6012 else if (name[0] != '0' && ISDIGIT (name[1]) && name[2] == '\0')
6014 num = (name[0] - '0') * 10 + name[1] - '0';
6021 if (!alpha_noat_on && (num + is_float) == AXP_REG_AT)
6022 as_warn (_("Used $at without \".set noat\""));
6023 return alpha_register_table[num + is_float];
6026 if (name[1] == 't' && name[2] == '\0')
6029 as_warn (_("Used $at without \".set noat\""));
6030 return alpha_register_table[AXP_REG_AT];
6035 if (name[1] == 'p' && name[2] == '\0')
6036 return alpha_register_table[alpha_gp_register];
6040 if (name[1] == 'p' && name[2] == '\0')
6041 return alpha_register_table[AXP_REG_SP];
6049 /* @@@ Magic ECOFF bits. */
6052 alpha_frob_ecoff_data (void)
6055 /* $zero and $f31 are read-only. */
6056 alpha_gprmask &= ~1;
6057 alpha_fprmask &= ~1;
6061 /* Hook to remember a recently defined label so that the auto-align
6062 code can adjust the symbol after we know what alignment will be
6066 alpha_define_label (symbolS *sym)
6068 alpha_insn_label = sym;
6070 dwarf2_emit_label (sym);
6074 /* Return true if we must always emit a reloc for a type and false if
6075 there is some hope of resolving it at assembly time. */
6078 alpha_force_relocation (fixS *f)
6080 if (alpha_flag_relax)
6083 switch (f->fx_r_type)
6085 case BFD_RELOC_ALPHA_GPDISP_HI16:
6086 case BFD_RELOC_ALPHA_GPDISP_LO16:
6087 case BFD_RELOC_ALPHA_GPDISP:
6088 case BFD_RELOC_ALPHA_LITERAL:
6089 case BFD_RELOC_ALPHA_ELF_LITERAL:
6090 case BFD_RELOC_ALPHA_LITUSE:
6091 case BFD_RELOC_GPREL16:
6092 case BFD_RELOC_GPREL32:
6093 case BFD_RELOC_ALPHA_GPREL_HI16:
6094 case BFD_RELOC_ALPHA_GPREL_LO16:
6095 case BFD_RELOC_ALPHA_LINKAGE:
6096 case BFD_RELOC_ALPHA_CODEADDR:
6097 case BFD_RELOC_ALPHA_BRSGP:
6098 case BFD_RELOC_ALPHA_TLSGD:
6099 case BFD_RELOC_ALPHA_TLSLDM:
6100 case BFD_RELOC_ALPHA_GOTDTPREL16:
6101 case BFD_RELOC_ALPHA_DTPREL_HI16:
6102 case BFD_RELOC_ALPHA_DTPREL_LO16:
6103 case BFD_RELOC_ALPHA_DTPREL16:
6104 case BFD_RELOC_ALPHA_GOTTPREL16:
6105 case BFD_RELOC_ALPHA_TPREL_HI16:
6106 case BFD_RELOC_ALPHA_TPREL_LO16:
6107 case BFD_RELOC_ALPHA_TPREL16:
6109 case BFD_RELOC_ALPHA_NOP:
6110 case BFD_RELOC_ALPHA_BSR:
6111 case BFD_RELOC_ALPHA_LDA:
6112 case BFD_RELOC_ALPHA_BOH:
6120 return generic_force_reloc (f);
6123 /* Return true if we can partially resolve a relocation now. */
6126 alpha_fix_adjustable (fixS *f)
6128 /* Are there any relocation types for which we must generate a
6129 reloc but we can adjust the values contained within it? */
6130 switch (f->fx_r_type)
6132 case BFD_RELOC_ALPHA_GPDISP_HI16:
6133 case BFD_RELOC_ALPHA_GPDISP_LO16:
6134 case BFD_RELOC_ALPHA_GPDISP:
6137 case BFD_RELOC_ALPHA_LITERAL:
6138 case BFD_RELOC_ALPHA_ELF_LITERAL:
6139 case BFD_RELOC_ALPHA_LITUSE:
6140 case BFD_RELOC_ALPHA_LINKAGE:
6141 case BFD_RELOC_ALPHA_CODEADDR:
6144 case BFD_RELOC_VTABLE_ENTRY:
6145 case BFD_RELOC_VTABLE_INHERIT:
6148 case BFD_RELOC_GPREL16:
6149 case BFD_RELOC_GPREL32:
6150 case BFD_RELOC_ALPHA_GPREL_HI16:
6151 case BFD_RELOC_ALPHA_GPREL_LO16:
6152 case BFD_RELOC_23_PCREL_S2:
6156 case BFD_RELOC_ALPHA_HINT:
6159 case BFD_RELOC_ALPHA_TLSGD:
6160 case BFD_RELOC_ALPHA_TLSLDM:
6161 case BFD_RELOC_ALPHA_GOTDTPREL16:
6162 case BFD_RELOC_ALPHA_DTPREL_HI16:
6163 case BFD_RELOC_ALPHA_DTPREL_LO16:
6164 case BFD_RELOC_ALPHA_DTPREL16:
6165 case BFD_RELOC_ALPHA_GOTTPREL16:
6166 case BFD_RELOC_ALPHA_TPREL_HI16:
6167 case BFD_RELOC_ALPHA_TPREL_LO16:
6168 case BFD_RELOC_ALPHA_TPREL16:
6169 /* ??? No idea why we can't return a reference to .tbss+10, but
6170 we're preventing this in the other assemblers. Follow for now. */
6174 case BFD_RELOC_ALPHA_BRSGP:
6175 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6176 let it get resolved at assembly time. */
6178 symbolS *sym = f->fx_addsy;
6182 if (generic_force_reloc (f))
6185 switch (S_GET_OTHER (sym) & STO_ALPHA_STD_GPLOAD)
6187 case STO_ALPHA_NOPV:
6189 case STO_ALPHA_STD_GPLOAD:
6193 if (S_IS_LOCAL (sym))
6196 name = S_GET_NAME (sym);
6197 as_bad_where (f->fx_file, f->fx_line,
6198 _("!samegp reloc against symbol without .prologue: %s"),
6202 f->fx_r_type = BFD_RELOC_23_PCREL_S2;
6203 f->fx_offset += offset;
6208 case BFD_RELOC_ALPHA_NOP:
6209 case BFD_RELOC_ALPHA_BSR:
6210 case BFD_RELOC_ALPHA_LDA:
6211 case BFD_RELOC_ALPHA_BOH:
6220 /* Generate the BFD reloc to be stuck in the object file from the
6221 fixup used internally in the assembler. */
6224 tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED,
6229 reloc = (arelent *) xmalloc (sizeof (* reloc));
6230 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6231 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6232 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6234 /* Make sure none of our internal relocations make it this far.
6235 They'd better have been fully resolved by this point. */
6236 gas_assert ((int) fixp->fx_r_type > 0);
6238 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6239 if (reloc->howto == NULL)
6241 as_bad_where (fixp->fx_file, fixp->fx_line,
6242 _("cannot represent `%s' relocation in object file"),
6243 bfd_get_reloc_code_name (fixp->fx_r_type));
6247 if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
6248 as_fatal (_("internal error? cannot generate `%s' relocation"),
6249 bfd_get_reloc_code_name (fixp->fx_r_type));
6251 gas_assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
6253 reloc->addend = fixp->fx_offset;
6256 /* Fake out bfd_perform_relocation. sigh. */
6257 /* ??? Better would be to use the special_function hook. */
6258 if (fixp->fx_r_type == BFD_RELOC_ALPHA_LITERAL)
6259 reloc->addend = -alpha_gp_value;
6263 switch (fixp->fx_r_type)
6265 struct evax_private_udata_struct *udata;
6269 case BFD_RELOC_ALPHA_LINKAGE:
6270 /* Copy the linkage index. */
6271 reloc->addend = fixp->fx_addnumber;
6274 case BFD_RELOC_ALPHA_NOP:
6275 case BFD_RELOC_ALPHA_BSR:
6276 case BFD_RELOC_ALPHA_LDA:
6277 case BFD_RELOC_ALPHA_BOH:
6278 pname = symbol_get_bfdsym (fixp->fx_addsy)->name;
6280 /* We need the non-suffixed name of the procedure. Beware that
6281 the main symbol might be equated so look it up and take its name. */
6282 pname_len = strlen (pname);
6283 if (pname_len > 4 && strcmp (pname + pname_len - 4, "..en") == 0)
6286 char *my_pname = (char *) xmalloc (pname_len - 4 + 1);
6288 memcpy (my_pname, pname, pname_len - 4);
6289 my_pname [pname_len - 4] = 0;
6290 sym = symbol_find (my_pname);
6295 while (symbol_equated_reloc_p (sym))
6297 symbolS *n = symbol_get_value_expression (sym)->X_add_symbol;
6299 /* We must avoid looping, as that can occur with a badly
6305 pname = symbol_get_bfdsym (sym)->name;
6308 udata = (struct evax_private_udata_struct *)
6309 xmalloc (sizeof (struct evax_private_udata_struct));
6310 udata->enbsym = symbol_get_bfdsym (fixp->fx_addsy);
6311 udata->bsym = symbol_get_bfdsym (fixp->tc_fix_data.info->psym);
6312 udata->origname = (char *)pname;
6313 udata->lkindex = ((struct evax_private_udata_struct *)
6314 symbol_get_bfdsym (fixp->tc_fix_data.info->sym)->udata.p)->lkindex;
6315 reloc->sym_ptr_ptr = (void *)udata;
6316 reloc->addend = fixp->fx_addnumber;
6326 /* Parse a register name off of the input_line and return a register
6327 number. Gets md_undefined_symbol above to do the register name
6330 Only called as a part of processing the ECOFF .frame directive. */
6333 tc_get_register (int frame ATTRIBUTE_UNUSED)
6335 int framereg = AXP_REG_SP;
6338 if (*input_line_pointer == '$')
6341 char c = get_symbol_name (&s);
6342 symbolS *sym = md_undefined_symbol (s);
6344 *strchr (s, '\0') = c;
6345 if (sym && (framereg = S_GET_VALUE (sym)) <= 31)
6348 as_warn (_("frame reg expected, using $%d."), framereg);
6351 note_gpreg (framereg);
6355 /* This is called before the symbol table is processed. In order to
6356 work with gcc when using mips-tfile, we must keep all local labels.
6357 However, in other cases, we want to discard them. If we were
6358 called with -g, but we didn't see any debugging information, it may
6359 mean that gcc is smuggling debugging information through to
6360 mips-tfile, in which case we must generate all local labels. */
6365 alpha_frob_file_before_adjust (void)
6367 if (alpha_debug != 0
6368 && ! ecoff_debugging_seen)
6369 flag_keep_locals = 1;
6372 #endif /* OBJ_ECOFF */
6374 /* The Alpha has support for some VAX floating point types, as well as for
6375 IEEE floating point. We consider IEEE to be the primary floating point
6376 format, and sneak in the VAX floating point support here. */
6377 #include "config/atof-vax.c"